1"use strict"; 2(self["webpackChunktypology_map"] = self["webpackChunktypology_map"] || []).push([[919],{ 3 4/***/ 28424: 5/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 6 7/* harmony export */ __webpack_require__.d(__webpack_exports__, { 8/* harmony export */ A: () => (/* binding */ ALL), 9/* harmony export */ B: () => (/* binding */ compose), 10/* harmony export */ C: () => (/* binding */ CALL), 11/* harmony export */ D: () => (/* binding */ logError), 12/* harmony export */ E: () => (/* binding */ wrapSagaDispatch), 13/* harmony export */ F: () => (/* binding */ FORK), 14/* harmony export */ G: () => (/* binding */ GET_CONTEXT), 15/* harmony export */ H: () => (/* binding */ identity), 16/* harmony export */ J: () => (/* binding */ JOIN), 17/* harmony export */ L: () => (/* binding */ take), 18/* harmony export */ M: () => (/* binding */ fork), 19/* harmony export */ N: () => (/* binding */ cancel), 20/* harmony export */ O: () => (/* binding */ call), 21/* harmony export */ P: () => (/* binding */ PUT), 22/* harmony export */ R: () => (/* binding */ RACE), 23/* harmony export */ S: () => (/* binding */ SELECT), 24/* harmony export */ T: () => (/* binding */ TAKE), 25/* harmony export */ Z: () => (/* binding */ put), 26/* harmony export */ a: () => (/* binding */ CPS), 27/* harmony export */ a4: () => (/* binding */ select), 28/* harmony export */ b: () => (/* binding */ CANCEL), 29/* harmony export */ d: () => (/* binding */ ACTION_CHANNEL), 30/* harmony export */ e: () => (/* binding */ expanding), 31/* harmony export */ f: () => (/* binding */ CANCELLED), 32/* harmony export */ g: () => (/* binding */ FLUSH), 33/* harmony export */ h: () => (/* binding */ SET_CONTEXT), 34/* harmony export */ i: () => (/* binding */ internalErr), 35/* harmony export */ j: () => (/* binding */ getMetaInfo), 36/* harmony export */ k: () => (/* binding */ kTrue), 37/* harmony export */ l: () => (/* binding */ createAllStyleChildCallbacks), 38/* harmony export */ m: () => (/* binding */ createEmptyArray), 39/* harmony export */ o: () => (/* binding */ once), 40/* harmony export */ p: () => (/* binding */ assignWithSymbols), 41/* harmony export */ q: () => (/* binding */ makeIterator), 42/* harmony export */ r: () => (/* binding */ remove), 43/* harmony export */ s: () => (/* binding */ shouldComplete), 44/* harmony export */ t: () => (/* binding */ noop), 45/* harmony export */ u: () => (/* binding */ flatMap), 46/* harmony export */ v: () => (/* binding */ getLocation), 47/* harmony export */ y: () => (/* binding */ shouldCancel), 48/* harmony export */ z: () => (/* binding */ shouldTerminate) 49/* harmony export */ }); 50/* unused harmony exports $, I, K, Q, U, V, W, X, Y, _, a0, a1, a2, a3, a5, a6, a7, a8, c, n, w, x */ 51/* harmony import */ var _redux_saga_symbols__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(90468); 52/* harmony import */ var _babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(58168); 53/* harmony import */ var _redux_saga_is__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(20704); 54/* harmony import */ var _redux_saga_delay_p__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(37089); 55 56 57 58 59 60var konst = function konst(v) { 61 return function () { 62 return v; 63 }; 64}; 65var kTrue = 66/*#__PURE__*/ 67konst(true); 68 69var noop = function noop() {}; 70 71if (false) {} 72var identity = function identity(v) { 73 return v; 74}; 75var hasSymbol = typeof Symbol === 'function'; 76var asyncIteratorSymbol = hasSymbol && Symbol.asyncIterator ? Symbol.asyncIterator : '@@asyncIterator'; 77function check(value, predicate, error) { 78 if (!predicate(value)) { 79 throw new Error(error); 80 } 81} 82var assignWithSymbols = function assignWithSymbols(target, source) { 83 (0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A)(target, source); 84 85 if (Object.getOwnPropertySymbols) { 86 Object.getOwnPropertySymbols(source).forEach(function (s) { 87 target[s] = source[s]; 88 }); 89 } 90}; 91var flatMap = function flatMap(mapper, arr) { 92 var _ref; 93 94 return (_ref = []).concat.apply(_ref, arr.map(mapper)); 95}; 96function remove(array, item) { 97 var index = array.indexOf(item); 98 99 if (index >= 0) { 100 array.splice(index, 1); 101 } 102} 103function once(fn) { 104 var called = false;
105 return function () { 106 if (called) { 107 return; 108 } 109 110 called = true; 111 fn(); 112 }; 113} 114 115var kThrow = function kThrow(err) { 116 throw err; 117}; 118 119var kReturn = function kReturn(value) { 120 return { 121 value: value, 122 done: true 123 }; 124}; 125 126function makeIterator(next, thro, name) { 127 if (thro === void 0) { 128 thro = kThrow; 129 } 130 131 if (name === void 0) { 132 name = 'iterator'; 133 } 134 135 var iterator = { 136 meta: { 137 name: name 138 }, 139 next: next, 140 throw: thro, 141 return: kReturn, 142 isSagaIterator: true 143 }; 144 145 if (typeof Symbol !== 'undefined') { 146 iterator[Symbol.iterator] = function () { 147 return iterator; 148 }; 149 } 150 151 return iterator; 152} 153function logError(error, _ref2) { 154 var sagaStack = _ref2.sagaStack; 155 156 /*eslint-disable no-console*/ 157 console.error(error); 158 console.error(sagaStack); 159} 160var internalErr = function internalErr(err) { 161 return new Error("\n redux-saga: Error checking hooks detected an inconsistent 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"); 162}; 163var createSetContextWarning = function createSetContextWarning(ctx, props) { 164 return (ctx ? ctx + '.' : '') + "setContext(props): argument " + props + " is not a plain object"; 165}; 166var FROZEN_ACTION_ERROR = "You can't put (a.k.a. dispatch from saga) frozen actions.\nWe have to define a special non-enumerable property on those actions for scheduling purposes.\nOtherwise you wouldn't be able to communicate properly between sagas & other subscribers (action ordering would become far less predictable).\nIf you are using redux and you care about this behaviour (frozen actions),\nthen you might want to switch to freezing actions in a middleware rather than in action creator.\nExample implementation:\n\nconst freezeActions = store => next => action => next(Object.freeze(action))\n"; // creates empty, but not-holey array 167 168var createEmptyArray = function createEmptyArray(n) { 169 return Array.apply(null, new Array(n)); 170}; 171var wrapSagaDispatch = function wrapSagaDispatch(dispatch) { 172 return function (action) { 173 if (false) {} 174 175 return dispatch(Object.defineProperty(action, _redux_saga_symbols__WEBPACK_IMPORTED_MODULE_0__.SAGA_ACTION, { 176 value: true 177 })); 178 }; 179}; 180var shouldTerminate = function shouldTerminate(res) { 181 return res === _redux_saga_symbols__WEBPACK_IMPORTED_MODULE_0__.TERMINATE; 182}; 183var shouldCancel = function shouldCancel(res) { 184 return res === _redux_saga_symbols__WEBPACK_IMPORTED_MODULE_0__.TASK_CANCEL; 185}; 186var shouldComplete = function shouldComplete(res) { 187 return shouldTerminate(res) || shouldCancel(res); 188}; 189function createAllStyleChildCallbacks(shape, parentCallback) { 190 var keys = Object.keys(shape); 191 var totalCount = keys.length; 192 193 if (false) {} 194 195 var completedCount = 0; 196 var completed; 197 var results = (0,_redux_saga_is__WEBPACK_IMPORTED_MODULE_1__/* .array */ .YO)(shape) ? createEmptyArray(totalCount) : {}; 198 var childCallbacks = {}; 199 200 function checkEnd() { 201 if (completedCount === totalCount) { 202 completed = true; 203 parentCallback(results); 204 } 205 } 206 207 keys.forEach(function (key) { 208 var chCbAtKey = function chCbAtKey(res, isErr) { 209 if (completed) { 210 return; 211 } 212 213 if (isErr || shouldComplete(res)) { 214 parentCallback.cancel(); 215 parentCallback(res, isErr); 216 } else { 217 results[key] = res; 218 completedCount++; 219 checkEnd(); 220 } 221 }; 222 223 chCbAtKey.cancel = noop; 224 childCallbacks[key] = chCbAtKey; 225 }); 226 227 parentCallback.cancel = function () { 228 if (!completed) { 229 completed = true; 230 keys.forEach(function (key) { 231 return childCallbacks[key].cancel(); 232 }); 233 } 234 }; 235 236 return childCallbacks; 237} 238function getMetaInfo(fn) { 239 return { 240 name: fn.name || 'anonymous', 241 location: getLocation(fn) 242 }; 243} 244function getLocation(instrumented) { 245 return instrumented[_redux_saga_symbols__WEBPACK_IMPORTED_MODULE_0__.SAGA_LOCATION]; 246} 247function compose() { 248 for (var _len = arguments.length, funcs = new Array(_len), _key = 0; _key < _len; _key++) { 249 funcs[_key] = arguments[_key]; 250 } 251 252 if (funcs.length === 0) { 253 return function (arg) { 254 return arg; 255 }; 256 } 257 258 if (funcs.length === 1) { 259 return funcs[0]; 260 } 261 262 return funcs.reduce(function (a, b) { 263 return function () {
264 return a(b.apply(void 0, arguments)); 265 }; 266 }); 267} 268 269var BUFFER_OVERFLOW = "Channel's Buffer overflow!"; 270var ON_OVERFLOW_THROW = 1; 271var ON_OVERFLOW_DROP = 2; 272var ON_OVERFLOW_SLIDE = 3; 273var ON_OVERFLOW_EXPAND = 4; 274var zeroBuffer = { 275 isEmpty: kTrue, 276 put: noop, 277 take: noop 278}; 279 280function ringBuffer(limit, overflowAction) { 281 if (limit === void 0) { 282 limit = 10; 283 } 284 285 var arr = new Array(limit); 286 var length = 0; 287 var pushIndex = 0; 288 var popIndex = 0; 289 290 var push = function push(it) { 291 arr[pushIndex] = it; 292 pushIndex = (pushIndex + 1) % limit; 293 length++; 294 }; 295 296 var take = function take() { 297 if (length != 0) { 298 var it = arr[popIndex]; 299 arr[popIndex] = null; 300 length--; 301 popIndex = (popIndex + 1) % limit; 302 return it; 303 } 304 }; 305 306 var flush = function flush() { 307 var items = []; 308 309 while (length) { 310 items.push(take()); 311 } 312 313 return items; 314 }; 315 316 return { 317 isEmpty: function isEmpty() { 318 return length == 0; 319 }, 320 put: function put(it) { 321 if (length < limit) { 322 push(it); 323 } else { 324 var doubledLimit; 325 326 switch (overflowAction) { 327 case ON_OVERFLOW_THROW: 328 throw new Error(BUFFER_OVERFLOW); 329 330 case ON_OVERFLOW_SLIDE: 331 arr[pushIndex] = it; 332 pushIndex = (pushIndex + 1) % limit; 333 popIndex = pushIndex; 334 break; 335 336 case ON_OVERFLOW_EXPAND: 337 doubledLimit = 2 * limit; 338 arr = flush(); 339 length = arr.length; 340 pushIndex = arr.length; 341 popIndex = 0; 342 arr.length = doubledLimit; 343 limit = doubledLimit; 344 push(it); 345 break; 346 347 default: // DROP 348 349 } 350 } 351 }, 352 take: take, 353 flush: flush 354 }; 355} 356 357var none = function none() { 358 return zeroBuffer; 359}; 360var fixed = function fixed(limit) { 361 return ringBuffer(limit, ON_OVERFLOW_THROW); 362}; 363var dropping = function dropping(limit) { 364 return ringBuffer(limit, ON_OVERFLOW_DROP); 365}; 366var sliding = function sliding(limit) { 367 return ringBuffer(limit, ON_OVERFLOW_SLIDE); 368}; 369var expanding = function expanding(initialSize) { 370 return ringBuffer(initialSize, ON_OVERFLOW_EXPAND); 371}; 372 373var buffers = /*#__PURE__*/Object.freeze({ 374 __proto__: null, 375 none: none, 376 fixed: fixed, 377 dropping: dropping, 378 sliding: sliding, 379 expanding: expanding 380}); 381 382var TAKE = 'TAKE'; 383var PUT = 'PUT'; 384var ALL = 'ALL'; 385var RACE = 'RACE'; 386var CALL = 'CALL'; 387var CPS = 'CPS'; 388var FORK = 'FORK'; 389var JOIN = 'JOIN'; 390var CANCEL = 'CANCEL'; 391var SELECT = 'SELECT'; 392var ACTION_CHANNEL = 'ACTION_CHANNEL'; 393var CANCELLED = 'CANCELLED'; 394var FLUSH = 'FLUSH'; 395var GET_CONTEXT = 'GET_CONTEXT'; 396var SET_CONTEXT = 'SET_CONTEXT'; 397 398var effectTypes = /*#__PURE__*/Object.freeze({ 399 __proto__: null, 400 TAKE: TAKE, 401 PUT: PUT, 402 ALL: ALL, 403 RACE: RACE, 404 CALL: CALL, 405 CPS: CPS, 406 FORK: FORK, 407 JOIN: JOIN, 408 CANCEL: CANCEL, 409 SELECT: SELECT, 410 ACTION_CHANNEL: ACTION_CHANNEL, 411 CANCELLED: CANCELLED, 412 FLUSH: FLUSH, 413 GET_CONTEXT: GET_CONTEXT, 414 SET_CONTEXT: SET_CONTEXT 415}); 416 417var TEST_HINT = '\n(HINT: if you are getting these errors in tests, consider using createMockTask from @redux-saga/testing-utils)'; 418 419var makeEffect = function makeEffect(type, payload) { 420 var _ref; 421 422 return _ref = {}, _ref[_redux_saga_symbols__WEBPACK_IMPORTED_MODULE_0__.IO] = true, _ref.combinator = false, _ref.type = type, _ref.payload = payload, _ref; 423}; 424 425var isForkEffect = function isForkEffect(eff) { 426 return effect(eff) && eff.type === FORK; 427}; 428 429var detach = function detach(eff) { 430 if (false) {} 431 432 return makeEffect(FORK, _extends({}, eff.payload, { 433 detached: true 434 })); 435}; 436function take(patternOrChannel, multicastPattern) { 437 if (patternOrChannel === void 0) { 438 patternOrChannel = '*'; 439 } 440 441 if (false) {} 442 443 if ((0,_redux_saga_is__WEBPACK_IMPORTED_MODULE_1__/* .pattern */ .T1)(patternOrChannel)) { 444 if ((0,_redux_saga_is__WEBPACK_IMPORTED_MODULE_1__/* .notUndef */ .uQ)(multicastPattern)) { 445 /* eslint-disable no-console */ 446 console.warn("take(pattern) takes one argument but two were provided. Consider passing an array for listening to several action types"); 447 } 448 449 return makeEffect(TAKE, { 450 pattern: patternOrChannel 451 }); 452 } 453 454 if ((0,_redux_saga_is__WEBPACK_IMPORTED_MODULE_1__/* .multicast */ .fD)(patternOrChannel) && (0,_redux_saga_is__WEBPACK_IMPORTED_MODULE_1__/* .notUndef */ .uQ)(multicastPattern) && (0,_redux_saga_is__WEBPACK_IMPORTED_MODULE_1__/* .pattern */ .T1)(multicastPattern)) { 455 return makeEffect(TAKE, { 456 channel: patternOrChannel, 457 pattern: multicastPattern 458 }); 459 } 460 461 if ((0,_redux_saga_is__WEBPACK_IMPORTED_MODULE_1__/* .channel */ .Ix)(patternOrChannel)) { 462 if ((0,_redux_saga_is__WEBPACK_IMPORTED_MODULE_1__/* .notUndef */ .uQ)(multicastPattern)) { 463 /* eslint-disable no-console */ 464 console.warn("take(channel) takes one argument but two were provided. Second argument is ignored."); 465 } 466 467 return makeEffect(TAKE, { 468 channel: patternOrChannel 469 }); 470 } 471 472 if (false) {} 473} 474var takeMaybe = function takeMaybe() { 475 var eff = take.apply(void 0, arguments); 476 eff.payload.maybe = true; 477 return eff; 478}; 479function put(channel$1, action) { 480 if (false) {} 481 482 if ((0,_redux_saga_is__WEBPACK_IMPORTED_MODULE_1__/* .undef */ .vD)(action)) { 483 action = channel$1; // `undefined` instead of `null` to make default parameter work 484 485 channel$1 = undefined; 486 } 487 488 return makeEffect(PUT, { 489 channel: channel$1, 490 action: action 491 }); 492} 493var putResolve = function putResolve() { 494 var eff = put.apply(void 0, arguments); 495 eff.payload.resolve = true; 496 return eff; 497}; 498function all(effects) { 499 var eff = makeEffect(ALL, effects);
500 eff.combinator = true; 501 return eff; 502} 503function race(effects) { 504 var eff = makeEffect(RACE, effects); 505 eff.combinator = true; 506 return eff; 507} // this match getFnCallDescriptor logic 508 509var validateFnDescriptor = function validateFnDescriptor(effectName, fnDescriptor) { 510 check(fnDescriptor, notUndef, effectName + ": argument fn is undefined or null"); 511 512 if (func(fnDescriptor)) { 513 return; 514 } 515 516 var context = null; 517 var fn; 518 519 if (array(fnDescriptor)) { 520 context = fnDescriptor[0]; 521 fn = fnDescriptor[1]; 522 check(fn, notUndef, effectName + ": argument of type [context, fn] has undefined or null `fn`"); 523 } else if (object(fnDescriptor)) { 524 context = fnDescriptor.context; 525 fn = fnDescriptor.fn; 526 check(fn, notUndef, effectName + ": argument of type {context, fn} has undefined or null `fn`"); 527 } else { 528 check(fnDescriptor, func, effectName + ": argument fn is not function"); 529 return; 530 } 531 532 if (context && string(fn)) { 533 check(context[fn], func, effectName + ": context arguments has no such method - \"" + fn + "\""); 534 return; 535 } 536 537 check(fn, func, effectName + ": unpacked fn argument (from [context, fn] or {context, fn}) is not a function"); 538}; 539 540function getFnCallDescriptor(fnDescriptor, args) { 541 var context = null; 542 var fn; 543 544 if ((0,_redux_saga_is__WEBPACK_IMPORTED_MODULE_1__/* .func */ .Pc)(fnDescriptor)) { 545 fn = fnDescriptor; 546 } else { 547 if ((0,_redux_saga_is__WEBPACK_IMPORTED_MODULE_1__/* .array */ .YO)(fnDescriptor)) { 548 context = fnDescriptor[0]; 549 fn = fnDescriptor[1]; 550 } else { 551 context = fnDescriptor.context; 552 fn = fnDescriptor.fn; 553 } 554 555 if (context && (0,_redux_saga_is__WEBPACK_IMPORTED_MODULE_1__/* .string */ .Yj)(fn) && (0,_redux_saga_is__WEBPACK_IMPORTED_MODULE_1__/* .func */ .Pc)(context[fn])) { 556 fn = context[fn]; 557 } 558 } 559 560 return { 561 context: context, 562 fn: fn, 563 args: args 564 }; 565} 566 567var isNotDelayEffect = function isNotDelayEffect(fn) { 568 return fn !== delay; 569}; 570 571function call(fnDescriptor) { 572 for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { 573 args[_key - 1] = arguments[_key]; 574 } 575 576 if (false) { var arg0; } 577 578 return makeEffect(CALL, getFnCallDescriptor(fnDescriptor, args)); 579} 580function apply(context, fn, args) { 581 if (args === void 0) { 582 args = []; 583 } 584 585 var fnDescriptor = [context, fn]; 586 587 if (false) {} 588 589 return makeEffect(CALL, getFnCallDescriptor([context, fn], args)); 590} 591function cps(fnDescriptor) { 592 if (false) {} 593 594 for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { 595 args[_key2 - 1] = arguments[_key2]; 596 } 597 598 return makeEffect(CPS, getFnCallDescriptor(fnDescriptor, args)); 599} 600function fork(fnDescriptor) { 601 if (false) {} 602 603 for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) { 604 args[_key3 - 1] = arguments[_key3]; 605 } 606 607 return makeEffect(FORK, getFnCallDescriptor(fnDescriptor, args)); 608} 609function spawn(fnDescriptor) { 610 if (false) {} 611 612 for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) { 613 args[_key4 - 1] = arguments[_key4]; 614 } 615 616 return detach(fork.apply(void 0, [fnDescriptor].concat(args))); 617} 618function join(taskOrTasks) { 619 if (false) {} 620 621 return makeEffect(JOIN, taskOrTasks); 622} 623function cancel(taskOrTasks) { 624 if (taskOrTasks === void 0) { 625 taskOrTasks = _redux_saga_symbols__WEBPACK_IMPORTED_MODULE_0__.SELF_CANCELLATION; 626 } 627 628 if (false) {} 629 630 return makeEffect(CANCEL, taskOrTasks); 631} 632function select(selector) { 633 if (selector === void 0) { 634 selector = identity; 635 } 636 637 for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) { 638 args[_key5 - 1] = arguments[_key5]; 639 } 640 641 if (false) {} 642 643 return makeEffect(SELECT, { 644 selector: selector, 645 args: args 646 }); 647} 648/** 649 channel(pattern, [buffer]) => creates a proxy channel for store actions 650**/ 651 652function actionChannel(pattern$1, buffer$1) { 653 if (false) {} 654 655 return makeEffect(ACTION_CHANNEL, { 656 pattern: pattern$1, 657 buffer: buffer$1 658 }); 659} 660function cancelled() { 661 return makeEffect(CANCELLED, {}); 662} 663function flush(channel$1) { 664 if (false) {} 665 666 return makeEffect(FLUSH, channel$1); 667} 668function getContext(prop) { 669 if (false) {} 670 671 return makeEffect(GET_CONTEXT, prop); 672} 673function setContext(props) { 674 if (false) {} 675 676 return makeEffect(SET_CONTEXT, props); 677}
678var delay = 679/*#__PURE__*/ 680(/* unused pure expression or super */ null && (call.bind(null, delayP))); 681 682 683 684 685/***/ }), 686 687/***/ 37089: 688/***/ ((__unused_webpack_module, __unused_webpack___webpack_exports__, __webpack_require__) => { 689 690/* harmony import */ var _redux_saga_symbols__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(90468); 691 692 693var MAX_SIGNED_INT = 2147483647; 694function delayP(ms, val) { 695 if (val === void 0) { 696 val = true; 697 } 698 699 // https://developer.mozilla.org/en-US/docs/Web/API/setTimeout#maximum_delay_value 700 if (false) {} 701 702 var timeoutId; 703 var promise = new Promise(function (resolve) { 704 timeoutId = setTimeout(resolve, Math.min(MAX_SIGNED_INT, ms), val); 705 }); 706 707 promise[CANCEL] = function () { 708 clearTimeout(timeoutId); 709 }; 710 711 return promise; 712} 713 714/* unused harmony default export */ var __WEBPACK_DEFAULT_EXPORT__ = ((/* unused pure expression or super */ null && (delayP))); 715 716 717/***/ }), 718 719/***/ 20704: 720/***/ ((__unused_webpack_module, exports, __webpack_require__) => { 721 722var __webpack_unused_export__; 723 724 725__webpack_unused_export__ = ({ value: true }); 726 727var symbols = __webpack_require__(90468); 728 729var undef = function undef(v) { 730 return v === null || v === undefined; 731}; 732var notUndef = function notUndef(v) { 733 return v !== null && v !== undefined; 734}; 735var func = function func(f) { 736 return typeof f === 'function'; 737}; 738var number = function number(n) { 739 return typeof n === 'number'; 740}; 741var string = function string(s) { 742 return typeof s === 'string'; 743}; 744var array = Array.isArray; 745var object = function object(obj) { 746 return obj && !array(obj) && typeof obj === 'object'; 747}; 748var promise = function promise(p) { 749 return p && func(p.then); 750}; 751var iterator = function iterator(it) { 752 return it && func(it.next) && func(it.throw); 753}; 754var iterable = function iterable(it) { 755 return it && func(Symbol) ? func(it[Symbol.iterator]) : array(it); 756}; 757var task = function task(t) { 758 return t && t[symbols.TASK]; 759}; 760var sagaAction = function sagaAction(a) { 761 return Boolean(a && a[symbols.SAGA_ACTION]); 762};
763var observable = function observable(ob) { 764 return ob && func(ob.subscribe); 765}; 766var buffer = function buffer(buf) { 767 return buf && func(buf.isEmpty) && func(buf.take) && func(buf.put); 768}; 769var pattern = function pattern(pat) { 770 return pat && (string(pat) || symbol(pat) || func(pat) || array(pat) && pat.every(pattern)); 771}; 772var channel = function channel(ch) { 773 return ch && func(ch.take) && func(ch.close); 774}; 775var stringableFunc = function stringableFunc(f) { 776 return func(f) && f.hasOwnProperty('toString'); 777}; 778var symbol = function symbol(sym) { 779 return Boolean(sym) && typeof Symbol === 'function' && sym.constructor === Symbol && sym !== Symbol.prototype; 780}; 781var multicast = function multicast(ch) { 782 return channel(ch) && ch[symbols.MULTICAST]; 783}; 784var effect = function effect(eff) { 785 return eff && eff[symbols.IO]; 786}; 787 788exports.YO = array; 789__webpack_unused_export__ = buffer; 790exports.Ix = channel; 791__webpack_unused_export__ = effect; 792exports.Pc = func; 793__webpack_unused_export__ = iterable; 794exports.lJ = iterator; 795exports.fD = multicast; 796exports.uQ = notUndef; 797__webpack_unused_export__ = number; 798__webpack_unused_export__ = object; 799__webpack_unused_export__ = observable; 800exports.T1 = pattern; 801exports.iv = promise; 802__webpack_unused_export__ = sagaAction; 803exports.Yj = string; 804exports.mr = stringableFunc; 805exports.HR = symbol; 806__webpack_unused_export__ = task; 807exports.vD = undef; 808 809 810/***/ }), 811 812/***/ 90468: 813/***/ ((__unused_webpack_module, exports) => { 814 815 816 817Object.defineProperty(exports, "__esModule", ({ value: true })); 818 819var createSymbol = function createSymbol(name) { 820 return "@@redux-saga/" + name; 821}; 822 823var CANCEL = 824/*#__PURE__*/ 825createSymbol('CANCEL_PROMISE'); 826var CHANNEL_END_TYPE = 827/*#__PURE__*/ 828createSymbol('CHANNEL_END'); 829var IO = 830/*#__PURE__*/ 831createSymbol('IO'); 832var MATCH = 833/*#__PURE__*/ 834createSymbol('MATCH'); 835var MULTICAST = 836/*#__PURE__*/ 837createSymbol('MULTICAST'); 838var SAGA_ACTION = 839/*#__PURE__*/ 840createSymbol('SAGA_ACTION'); 841var SELF_CANCELLATION = 842/*#__PURE__*/ 843createSymbol('SELF_CANCELLATION'); 844var TASK = 845/*#__PURE__*/ 846createSymbol('TASK'); 847var TASK_CANCEL = 848/*#__PURE__*/ 849createSymbol('TASK_CANCEL'); 850var TERMINATE = 851/*#__PURE__*/ 852createSymbol('TERMINATE'); 853var SAGA_LOCATION = 854/*#__PURE__*/ 855createSymbol('LOCATION'); 856 857exports.CANCEL = CANCEL; 858exports.CHANNEL_END_TYPE = CHANNEL_END_TYPE; 859exports.IO = IO; 860exports.MATCH = MATCH; 861exports.MULTICAST = MULTICAST; 862exports.SAGA_ACTION = SAGA_ACTION; 863exports.SAGA_LOCATION = SAGA_LOCATION; 864exports.SELF_CANCELLATION = SELF_CANCELLATION; 865exports.TASK = TASK; 866exports.TASK_CANCEL = TASK_CANCEL; 867exports.TERMINATE = TERMINATE; 868 869 870/***/ }), 871 872/***/ 27701: 873/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 874 875 876// EXPORTS 877__webpack_require__.d(__webpack_exports__, { 878 Ay: () => (/* binding */ redux_saga_core_npm_proxy_esm) 879}); 880 881// UNUSED EXPORTS: CANCEL, END, SAGA_LOCATION, buffers, channel, detach, eventChannel, isEnd, multicastChannel, runSaga, stdChannel 882 883// EXTERNAL MODULE: ./node_modules/@redux-saga/symbols/dist/redux-saga-symbols.cjs.js 884var redux_saga_symbols_cjs = __webpack_require__(90468); 885// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js 886var esm_extends = __webpack_require__(58168); 887// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js 888var objectWithoutPropertiesLoose = __webpack_require__(98587); 889// EXTERNAL MODULE: ./node_modules/@redux-saga/is/dist/redux-saga-is.cjs.js 890var redux_saga_is_cjs = __webpack_require__(20704); 891// EXTERNAL MODULE: ./node_modules/@redux-saga/core/dist/io-22ea0cf9.js 892var io_22ea0cf9 = __webpack_require__(28424); 893;// ./node_modules/@redux-saga/deferred/dist/redux-saga-deferred.esm.js 894function deferred() { 895 var def = {}; 896 def.promise = new Promise(function (resolve, reject) { 897 def.resolve = resolve; 898 def.reject = reject; 899 }); 900 return def; 901} 902function arrayOfDeferred(length) { 903 var arr = []; 904 905 for (var i = 0; i < length; i++) { 906 arr.push(deferred()); 907 } 908 909 return arr; 910} 911 912/* harmony default export */ const redux_saga_deferred_esm = (deferred); 913 914 915// EXTERNAL MODULE: ./node_modules/@redux-saga/delay-p/dist/redux-saga-delay-p.esm.js 916var redux_saga_delay_p_esm = __webpack_require__(37089); 917;// ./node_modules/@redux-saga/core/dist/redux-saga-core.esm.js 918 919 920 921 922 923 924 925 926 927 928var queue = []; 929/** 930 Variable to hold a counting semaphore 931 - Incrementing adds a lock and puts the scheduler in a `suspended` state (if it's not 932 already suspended) 933 - Decrementing releases a lock. Zero locks puts the scheduler in a `released` state. This 934 triggers flushing the queued tasks. 935**/ 936 937var semaphore = 0; 938/** 939 Executes a task 'atomically'. Tasks scheduled during this execution will be queued 940 and flushed after this task has finished (assuming the scheduler endup in a released 941 state). 942**/ 943 944function exec(task) { 945 try { 946 suspend(); 947 task(); 948 } finally { 949 release(); 950 } 951} 952/** 953 Executes or queues a task depending on the state of the scheduler (`suspended` or `released`) 954**/ 955 956 957function asap(task) { 958 queue.push(task); 959 960 if (!semaphore) { 961 suspend(); 962 flush(); 963 } 964} 965/** 966 * Puts the scheduler in a `suspended` state and executes a task immediately. 967 */ 968 969function immediately(task) { 970 try { 971 suspend(); 972 return task(); 973 } finally { 974 flush(); 975 } 976} 977/** 978 Puts the scheduler in a `suspended` state. Scheduled tasks will be queued until the 979 scheduler is released. 980**/ 981 982function suspend() { 983 semaphore++; 984} 985/** 986 Puts the scheduler in a `released` state. 987**/ 988 989 990function release() { 991 semaphore--; 992} 993/** 994 Releases the current lock. Executes all queued tasks if the scheduler is in the released state. 995**/ 996 997 998function flush() { 999 release(); 1000 var task; 1001 1002 while (!semaphore && (task = queue.shift()) !== undefined) { 1003 exec(task); 1004 } 1005} 1006 1007var array = function array(patterns) { 1008 return function (input) { 1009 return patterns.some(function (p) { 1010 return matcher(p)(input); 1011 }); 1012 }; 1013}; 1014var predicate = function predicate(_predicate) { 1015 return function (input) { 1016 return _predicate(input); 1017 }; 1018}; 1019var string = function string(pattern) { 1020 return function (input) { 1021 return input.type === String(pattern); 1022 }; 1023}; 1024var symbol = function symbol(pattern) { 1025 return function (input) { 1026 return input.type === pattern; 1027 }; 1028}; 1029var wildcard = function wildcard() { 1030 return io_22ea0cf9.k; 1031}; 1032function matcher(pattern) { 1033 // prettier-ignore 1034 var matcherCreator = pattern === '*' ? wildcard : (0,redux_saga_is_cjs/* string */.Yj)(pattern) ? string : (0,redux_saga_is_cjs/* array */.YO)(pattern) ? array : (0,redux_saga_is_cjs/* stringableFunc */.mr)(pattern) ? string : (0,redux_saga_is_cjs/* func */.Pc)(pattern) ? predicate : (0,redux_saga_is_cjs/* symbol */.HR)(pattern) ? symbol : null; 1035 1036 if (matcherCreator === null) { 1037 throw new Error("invalid pattern: " + pattern); 1038 } 1039 1040 return matcherCreator(pattern); 1041} 1042 1043var END = { 1044 type: redux_saga_symbols_cjs.CHANNEL_END_TYPE 1045}; 1046var isEnd = function isEnd(a) { 1047 return a && a.type === redux_saga_symbols_cjs.CHANNEL_END_TYPE; 1048}; 1049var CLOSED_CHANNEL_WITH_TAKERS = 'Cannot have a closed channel with pending takers';
1050var INVALID_BUFFER = 'invalid buffer passed to channel factory function'; 1051var UNDEFINED_INPUT_ERROR = "Saga or channel was provided with an undefined action\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"; 1052function channel(buffer$1) { 1053 if (buffer$1 === void 0) { 1054 buffer$1 = (0,io_22ea0cf9.e)(); 1055 } 1056 1057 var closed = false; 1058 var takers = []; 1059 1060 if (false) {} 1061 1062 function checkForbiddenStates() { 1063 if (closed && takers.length) { 1064 throw (0,io_22ea0cf9.i)(CLOSED_CHANNEL_WITH_TAKERS); 1065 } 1066 1067 if (takers.length && !buffer$1.isEmpty()) { 1068 throw (0,io_22ea0cf9.i)('Cannot have pending takers with non empty buffer'); 1069 } 1070 } 1071 1072 function put(input) { 1073 if (false) {} 1074 1075 if (closed) { 1076 return; 1077 } 1078 1079 if (takers.length === 0) { 1080 return buffer$1.put(input); 1081 } 1082 1083 var cb = takers.shift(); 1084 cb(input); 1085 } 1086 1087 function take(cb) { 1088 if (false) {} 1089 1090 if (closed && buffer$1.isEmpty()) { 1091 cb(END); 1092 } else if (!buffer$1.isEmpty()) { 1093 cb(buffer$1.take()); 1094 } else { 1095 takers.push(cb); 1096 1097 cb.cancel = function () { 1098 (0,io_22ea0cf9.r)(takers, cb); 1099 }; 1100 } 1101 } 1102 1103 function flush(cb) { 1104 if (false) {} 1105 1106 if (closed && buffer$1.isEmpty()) { 1107 cb(END); 1108 return; 1109 } 1110 1111 cb(buffer$1.flush()); 1112 } 1113 1114 function close() { 1115 if (false) {} 1116 1117 if (closed) { 1118 return; 1119 } 1120 1121 closed = true; 1122 var arr = takers; 1123 takers = []; 1124 1125 for (var i = 0, len = arr.length; i < len; i++) { 1126 var taker = arr[i]; 1127 taker(END); 1128 } 1129 } 1130 1131 return { 1132 take: take, 1133 put: put, 1134 flush: flush, 1135 close: close 1136 }; 1137} 1138function eventChannel(subscribe, buffer) { 1139 if (buffer === void 0) { 1140 buffer = none(); 1141 } 1142 1143 var closed = false; 1144 var unsubscribe; 1145 var chan = channel(buffer); 1146 1147 var close = function close() { 1148 if (closed) { 1149 return; 1150 } 1151 1152 closed = true; 1153 1154 if (func(unsubscribe)) { 1155 unsubscribe(); 1156 } 1157 1158 chan.close(); 1159 }; 1160 1161 unsubscribe = subscribe(function (input) { 1162 if (isEnd(input)) { 1163 close(); 1164 return; 1165 } 1166 1167 chan.put(input); 1168 }); 1169 1170 if (false) {} 1171 1172 unsubscribe = once(unsubscribe); 1173 1174 if (closed) { 1175 unsubscribe(); 1176 } 1177 1178 return { 1179 take: chan.take, 1180 flush: chan.flush, 1181 close: close 1182 }; 1183} 1184function multicastChannel() { 1185 var _ref; 1186 1187 var closed = false; 1188 var currentTakers = []; 1189 var nextTakers = currentTakers; 1190 1191 function checkForbiddenStates() { 1192 if (closed && nextTakers.length) { 1193 throw (0,io_22ea0cf9.i)(CLOSED_CHANNEL_WITH_TAKERS); 1194 } 1195 } 1196 1197 var ensureCanMutateNextTakers = function ensureCanMutateNextTakers() { 1198 if (nextTakers !== currentTakers) { 1199 return; 1200 } 1201 1202 nextTakers = currentTakers.slice(); 1203 }; 1204 1205 var close = function close() { 1206 if (false) {} 1207 1208 closed = true; 1209 var takers = currentTakers = nextTakers; 1210 nextTakers = []; 1211 takers.forEach(function (taker) { 1212 taker(END); 1213 }); 1214 }; 1215 1216 return _ref = {}, _ref[redux_saga_symbols_cjs.MULTICAST] = true, _ref.put = function put(input) { 1217 if (false) {} 1218 1219 if (closed) { 1220 return; 1221 } 1222 1223 if (isEnd(input)) { 1224 close(); 1225 return; 1226 } 1227 1228 var takers = currentTakers = nextTakers; 1229 1230 for (var i = 0, len = takers.length; i < len; i++) { 1231 var taker = takers[i]; 1232 1233 if (taker[redux_saga_symbols_cjs.MATCH](input)) { 1234 taker.cancel(); 1235 taker(input); 1236 } 1237 } 1238 }, _ref.take = function take(cb, matcher) { 1239 if (matcher === void 0) { 1240 matcher = wildcard; 1241 } 1242 1243 if (false) {} 1244 1245 if (closed) { 1246 cb(END); 1247 return; 1248 } 1249 1250 cb[redux_saga_symbols_cjs.MATCH] = matcher; 1251 ensureCanMutateNextTakers(); 1252 nextTakers.push(cb); 1253 cb.cancel = (0,io_22ea0cf9.o)(function () { 1254 ensureCanMutateNextTakers(); 1255 (0,io_22ea0cf9.r)(nextTakers, cb); 1256 }); 1257 }, _ref.close = close, _ref; 1258} 1259function stdChannel() { 1260 var chan = multicastChannel(); 1261 var put = chan.put; 1262 1263 chan.put = function (input) { 1264 if (input[redux_saga_symbols_cjs.SAGA_ACTION]) { 1265 put(input); 1266 return; 1267 } 1268 1269 asap(function () { 1270 put(input); 1271 }); 1272 }; 1273 1274 return chan; 1275} 1276 1277var RUNNING = 0; 1278var CANCELLED = 1; 1279var ABORTED = 2; 1280var DONE = 3; 1281
1282function resolvePromise(promise, cb) { 1283 var cancelPromise = promise[redux_saga_symbols_cjs.CANCEL]; 1284 1285 if ((0,redux_saga_is_cjs/* func */.Pc)(cancelPromise)) { 1286 cb.cancel = cancelPromise; 1287 } 1288 1289 promise.then(cb, function (error) { 1290 cb(error, true); 1291 }); 1292} 1293 1294var current = 0; 1295var nextSagaId = (function () { 1296 return ++current; 1297}); 1298 1299var _effectRunnerMap; 1300 1301function getIteratorMetaInfo(iterator, fn) { 1302 if (iterator.isSagaIterator) { 1303 return { 1304 name: iterator.meta.name 1305 }; 1306 } 1307 1308 return (0,io_22ea0cf9.j)(fn); 1309} 1310 1311function createTaskIterator(_ref) { 1312 var context = _ref.context, 1313 fn = _ref.fn, 1314 args = _ref.args; 1315 1316 // catch synchronous failures; see #152 and #441 1317 try { 1318 var result = fn.apply(context, args); // i.e. a generator function returns an iterator 1319 1320 if ((0,redux_saga_is_cjs/* iterator */.lJ)(result)) { 1321 return result; 1322 } 1323 1324 var resolved = false; 1325 1326 var next = function next(arg) { 1327 if (!resolved) { 1328 resolved = true; // Only promises returned from fork will be interpreted. See #1573 1329 1330 return { 1331 value: result, 1332 done: !(0,redux_saga_is_cjs/* promise */.iv)(result) 1333 }; 1334 } else { 1335 return { 1336 value: arg, 1337 done: true 1338 }; 1339 } 1340 }; 1341 1342 return (0,io_22ea0cf9.q)(next); 1343 } catch (err) { 1344 // do not bubble up synchronous failures for detached forks 1345 // instead create a failed task. See #152 and #441 1346 return (0,io_22ea0cf9.q)(function () { 1347 throw err; 1348 }); 1349 } 1350} 1351 1352function runPutEffect(env, _ref2, cb) { 1353 var channel = _ref2.channel, 1354 action = _ref2.action, 1355 resolve = _ref2.resolve; 1356 1357 /** 1358 Schedule the put in case another saga is holding a lock. 1359 The put will be executed atomically. ie nested puts will execute after 1360 this put has terminated. 1361 **/ 1362 asap(function () { 1363 var result; 1364 1365 try { 1366 result = (channel ? channel.put : env.dispatch)(action); 1367 } catch (error) { 1368 cb(error, true); 1369 return; 1370 } 1371 1372 if (resolve && (0,redux_saga_is_cjs/* promise */.iv)(result)) { 1373 resolvePromise(result, cb); 1374 } else { 1375 cb(result); 1376 } 1377 }); // Put effects are non cancellables 1378} 1379 1380function runTakeEffect(env, _ref3, cb) { 1381 var _ref3$channel = _ref3.channel, 1382 channel = _ref3$channel === void 0 ? env.channel : _ref3$channel, 1383 pattern = _ref3.pattern, 1384 maybe = _ref3.maybe; 1385 1386 var takeCb = function takeCb(input) { 1387 if (input instanceof Error) { 1388 cb(input, true); 1389 return; 1390 } 1391 1392 if (isEnd(input) && !maybe) { 1393 cb(redux_saga_symbols_cjs.TERMINATE); 1394 return; 1395 } 1396 1397 cb(input); 1398 }; 1399 1400 try { 1401 channel.take(takeCb, (0,redux_saga_is_cjs/* notUndef */.uQ)(pattern) ? matcher(pattern) : null); 1402 } catch (err) { 1403 cb(err, true); 1404 return; 1405 } 1406 1407 cb.cancel = takeCb.cancel; 1408} 1409 1410function runCallEffect(env, _ref4, cb, _ref5) { 1411 var context = _ref4.context, 1412 fn = _ref4.fn, 1413 args = _ref4.args; 1414 var task = _ref5.task; 1415 1416 // catch synchronous failures; see #152 1417 try { 1418 var result = fn.apply(context, args); 1419 1420 if ((0,redux_saga_is_cjs/* promise */.iv)(result)) { 1421 resolvePromise(result, cb); 1422 return; 1423 } 1424 1425 if ((0,redux_saga_is_cjs/* iterator */.lJ)(result)) { 1426 // resolve iterator 1427 proc(env, result, task.context, current, (0,io_22ea0cf9.j)(fn), 1428 /* isRoot */ 1429 false, cb); 1430 return; 1431 } 1432 1433 cb(result); 1434 } catch (error) { 1435 cb(error, true); 1436 } 1437} 1438 1439function runCPSEffect(env, _ref6, cb) { 1440 var context = _ref6.context, 1441 fn = _ref6.fn, 1442 args = _ref6.args; 1443 1444 // CPS (ie node style functions) can define their own cancellation logic 1445 // by setting cancel field on the cb 1446 // catch synchronous failures; see #152 1447 try { 1448 var cpsCb = function cpsCb(err, res) { 1449 if ((0,redux_saga_is_cjs/* undef */.vD)(err)) { 1450 cb(res); 1451 } else { 1452 cb(err, true); 1453 } 1454 }; 1455 1456 fn.apply(context, args.concat(cpsCb)); 1457 1458 if (cpsCb.cancel) { 1459 cb.cancel = cpsCb.cancel; 1460 } 1461 } catch (error) { 1462 cb(error, true); 1463 } 1464} 1465 1466function runForkEffect(env, _ref7, cb, _ref8) { 1467 var context = _ref7.context, 1468 fn = _ref7.fn, 1469 args = _ref7.args, 1470 detached = _ref7.detached; 1471 var parent = _ref8.task; 1472 var taskIterator = createTaskIterator({ 1473 context: context, 1474 fn: fn, 1475 args: args 1476 }); 1477 var meta = getIteratorMetaInfo(taskIterator, fn); 1478 immediately(function () { 1479 var child = proc(env, taskIterator, parent.context, current, meta, detached, undefined); 1480 1481 if (detached) { 1482 cb(child); 1483 } else { 1484 if (child.isRunning()) { 1485 parent.queue.addTask(child); 1486 cb(child); 1487 } else if (child.isAborted()) { 1488 parent.queue.abort(child.error()); 1489 } else { 1490 cb(child); 1491 } 1492 } 1493 }); // Fork effects are non cancellables 1494} 1495 1496function runJoinEffect(env, taskOrTasks, cb, _ref9) { 1497 var task = _ref9.task; 1498 1499 var joinSingleTask = function joinSingleTask(taskToJoin, cb) { 1500 if (taskToJoin.isRunning()) { 1501 var joiner = { 1502 task: task, 1503 cb: cb
1504 }; 1505 1506 cb.cancel = function () { 1507 if (taskToJoin.isRunning()) (0,io_22ea0cf9.r)(taskToJoin.joiners, joiner); 1508 }; 1509 1510 taskToJoin.joiners.push(joiner); 1511 } else { 1512 if (taskToJoin.isAborted()) { 1513 cb(taskToJoin.error(), true); 1514 } else { 1515 cb(taskToJoin.result()); 1516 } 1517 } 1518 }; 1519 1520 if ((0,redux_saga_is_cjs/* array */.YO)(taskOrTasks)) { 1521 if (taskOrTasks.length === 0) { 1522 cb([]); 1523 return; 1524 } 1525 1526 var childCallbacks = (0,io_22ea0cf9.l)(taskOrTasks, cb); 1527 taskOrTasks.forEach(function (t, i) { 1528 joinSingleTask(t, childCallbacks[i]); 1529 }); 1530 } else { 1531 joinSingleTask(taskOrTasks, cb); 1532 } 1533} 1534 1535function cancelSingleTask(taskToCancel) { 1536 if (taskToCancel.isRunning()) { 1537 taskToCancel.cancel(); 1538 } 1539} 1540 1541function runCancelEffect(env, taskOrTasks, cb, _ref10) { 1542 var task = _ref10.task; 1543 1544 if (taskOrTasks === redux_saga_symbols_cjs.SELF_CANCELLATION) { 1545 cancelSingleTask(task); 1546 } else if ((0,redux_saga_is_cjs/* array */.YO)(taskOrTasks)) { 1547 taskOrTasks.forEach(cancelSingleTask); 1548 } else { 1549 cancelSingleTask(taskOrTasks); 1550 } 1551 1552 cb(); // cancel effects are non cancellables 1553} 1554 1555function runAllEffect(env, effects, cb, _ref11) { 1556 var digestEffect = _ref11.digestEffect; 1557 var effectId = current; 1558 var keys = Object.keys(effects); 1559 1560 if (keys.length === 0) { 1561 cb((0,redux_saga_is_cjs/* array */.YO)(effects) ? [] : {}); 1562 return; 1563 } 1564 1565 var childCallbacks = (0,io_22ea0cf9.l)(effects, cb); 1566 keys.forEach(function (key) { 1567 digestEffect(effects[key], effectId, childCallbacks[key], key); 1568 }); 1569} 1570 1571function runRaceEffect(env, effects, cb, _ref12) { 1572 var digestEffect = _ref12.digestEffect; 1573 var effectId = current; 1574 var keys = Object.keys(effects); 1575 var response = (0,redux_saga_is_cjs/* array */.YO)(effects) ? (0,io_22ea0cf9.m)(keys.length) : {}; 1576 var childCbs = {}; 1577 var completed = false; 1578 keys.forEach(function (key) { 1579 var chCbAtKey = function chCbAtKey(res, isErr) { 1580 if (completed) { 1581 return; 1582 } 1583 1584 if (isErr || (0,io_22ea0cf9.s)(res)) { 1585 // Race Auto cancellation 1586 cb.cancel(); 1587 cb(res, isErr); 1588 } else { 1589 cb.cancel(); 1590 completed = true; 1591 response[key] = res; 1592 cb(response); 1593 } 1594 }; 1595 1596 chCbAtKey.cancel = io_22ea0cf9.t; 1597 childCbs[key] = chCbAtKey; 1598 }); 1599 1600 cb.cancel = function () { 1601 // prevents unnecessary cancellation 1602 if (!completed) { 1603 completed = true; 1604 keys.forEach(function (key) { 1605 return childCbs[key].cancel(); 1606 }); 1607 } 1608 }; 1609 1610 keys.forEach(function (key) { 1611 if (completed) { 1612 return; 1613 } 1614 1615 digestEffect(effects[key], effectId, childCbs[key], key); 1616 }); 1617} 1618 1619function runSelectEffect(env, _ref13, cb) { 1620 var selector = _ref13.selector, 1621 args = _ref13.args; 1622 1623 try { 1624 var state = selector.apply(void 0, [env.getState()].concat(args)); 1625 cb(state); 1626 } catch (error) { 1627 cb(error, true); 1628 } 1629} 1630 1631function runChannelEffect(env, _ref14, cb) { 1632 var pattern = _ref14.pattern, 1633 buffer = _ref14.buffer; 1634 var chan = channel(buffer); 1635 var match = matcher(pattern); 1636 1637 var taker = function taker(action) { 1638 if (!isEnd(action)) { 1639 env.channel.take(taker, match); 1640 } 1641 1642 chan.put(action); 1643 }; 1644 1645 var close = chan.close; 1646 1647 chan.close = function () { 1648 taker.cancel(); 1649 close(); 1650 }; 1651 1652 env.channel.take(taker, match); 1653 cb(chan); 1654} 1655 1656function runCancelledEffect(env, data, cb, _ref15) { 1657 var task = _ref15.task; 1658 cb(task.isCancelled()); 1659} 1660 1661function runFlushEffect(env, channel, cb) { 1662 channel.flush(cb); 1663} 1664 1665function runGetContextEffect(env, prop, cb, _ref16) { 1666 var task = _ref16.task; 1667 cb(task.context[prop]); 1668} 1669 1670function runSetContextEffect(env, props, cb, _ref17) { 1671 var task = _ref17.task; 1672 (0,io_22ea0cf9.p)(task.context, props); 1673 cb(); 1674} 1675 1676var effectRunnerMap = (_effectRunnerMap = {}, _effectRunnerMap[io_22ea0cf9.T] = runTakeEffect, _effectRunnerMap[io_22ea0cf9.P] = runPutEffect, _effectRunnerMap[io_22ea0cf9.A] = runAllEffect, _effectRunnerMap[io_22ea0cf9.R] = runRaceEffect, _effectRunnerMap[io_22ea0cf9.C] = runCallEffect, _effectRunnerMap[io_22ea0cf9.a] = runCPSEffect, _effectRunnerMap[io_22ea0cf9.F] = runForkEffect, _effectRunnerMap[io_22ea0cf9.J] = runJoinEffect, _effectRunnerMap[io_22ea0cf9.b] = runCancelEffect, _effectRunnerMap[io_22ea0cf9.S] = runSelectEffect, _effectRunnerMap[io_22ea0cf9.d] = runChannelEffect, _effectRunnerMap[io_22ea0cf9.f] = runCancelledEffect, _effectRunnerMap[io_22ea0cf9.g] = runFlushEffect, _effectRunnerMap[io_22ea0cf9.G] = runGetContextEffect, _effectRunnerMap[io_22ea0cf9.h] = runSetContextEffect, _effectRunnerMap); 1677 1678/** 1679 Used to track a parent task and its forks 1680 In the fork model, forked tasks are attached by default to their parent 1681 We model this using the concept of Parent task && main Task 1682 main task is the main flow of the current Generator, the parent tasks is the 1683 aggregation of the main tasks + all its forked tasks. 1684 Thus the whole model represents an execution tree with multiple branches (vs the 1685 linear execution tree in sequential (non parallel) programming) 1686 1687 A parent tasks has the following semantics 1688 - It completes if all its forks either complete or all cancelled 1689 - If it's cancelled, all forks are cancelled as well 1690 - It aborts if any uncaught error bubbles up from forks 1691 - If it completes, the return value is the one returned by the main task 1692 **/ 1693 1694function forkQueue(mainTask, onAbort, cont) { 1695 var tasks = []; 1696 var result; 1697 var completed = false;
1698 addTask(mainTask); 1699 1700 var getTasks = function getTasks() { 1701 return tasks; 1702 }; 1703 1704 function abort(err) { 1705 onAbort(); 1706 cancelAll(); 1707 cont(err, true); 1708 } 1709 1710 function addTask(task) { 1711 tasks.push(task); 1712 1713 task.cont = function (res, isErr) { 1714 if (completed) { 1715 return; 1716 } 1717 1718 (0,io_22ea0cf9.r)(tasks, task); 1719 task.cont = io_22ea0cf9.t; 1720 1721 if (isErr) { 1722 abort(res); 1723 } else { 1724 if (task === mainTask) { 1725 result = res; 1726 } 1727 1728 if (!tasks.length) { 1729 completed = true; 1730 cont(result); 1731 } 1732 } 1733 }; 1734 } 1735 1736 function cancelAll() { 1737 if (completed) { 1738 return; 1739 } 1740 1741 completed = true; 1742 tasks.forEach(function (t) { 1743 t.cont = io_22ea0cf9.t; 1744 t.cancel(); 1745 }); 1746 tasks = []; 1747 } 1748 1749 return { 1750 addTask: addTask, 1751 cancelAll: cancelAll, 1752 abort: abort, 1753 getTasks: getTasks 1754 }; 1755} 1756 1757// there can be only a single saga error created at any given moment 1758 1759function formatLocation(fileName, lineNumber) { 1760 return fileName + "?" + lineNumber; 1761} 1762 1763function effectLocationAsString(effect) { 1764 var location = (0,io_22ea0cf9.v)(effect); 1765 1766 if (location) { 1767 var code = location.code, 1768 fileName = location.fileName, 1769 lineNumber = location.lineNumber; 1770 var source = code + " " + formatLocation(fileName, lineNumber); 1771 return source; 1772 } 1773 1774 return ''; 1775} 1776 1777function sagaLocationAsString(sagaMeta) { 1778 var name = sagaMeta.name, 1779 location = sagaMeta.location; 1780 1781 if (location) { 1782 return name + " " + formatLocation(location.fileName, location.lineNumber); 1783 } 1784 1785 return name; 1786} 1787 1788function cancelledTasksAsString(sagaStack) { 1789 var cancelledTasks = (0,io_22ea0cf9.u)(function (i) { 1790 return i.cancelledTasks; 1791 }, sagaStack); 1792 1793 if (!cancelledTasks.length) { 1794 return ''; 1795 } 1796 1797 return ['Tasks cancelled due to error:'].concat(cancelledTasks).join('\n'); 1798} 1799 1800var crashedEffect = null; 1801var sagaStack = []; 1802var addSagaFrame = function addSagaFrame(frame) { 1803 frame.crashedEffect = crashedEffect; 1804 sagaStack.push(frame); 1805}; 1806var clear = function clear() { 1807 crashedEffect = null; 1808 sagaStack.length = 0; 1809}; // this sets crashed effect for the soon-to-be-reported saga frame 1810// this slightly streatches the singleton nature of this module into wrong direction 1811// as it's even less obvious what's the data flow here, but it is what it is for now 1812 1813var setCrashedEffect = function setCrashedEffect(effect) { 1814 crashedEffect = effect; 1815}; 1816/** 1817 @returns {string} 1818 1819 @example 1820 The above error occurred in task errorInPutSaga {pathToFile} 1821 when executing effect put({type: 'REDUCER_ACTION_ERROR_IN_PUT'}) {pathToFile} 1822 created by fetchSaga {pathToFile} 1823 created by rootSaga {pathToFile} 1824*/ 1825 1826var redux_saga_core_esm_toString = function toString() { 1827 var firstSaga = sagaStack[0], 1828 otherSagas = sagaStack.slice(1); 1829 var crashedEffectLocation = firstSaga.crashedEffect ? effectLocationAsString(firstSaga.crashedEffect) : null; 1830 var errorMessage = "The above error occurred in task " + sagaLocationAsString(firstSaga.meta) + (crashedEffectLocation ? " \n when executing effect " + crashedEffectLocation : ''); 1831 return [errorMessage].concat(otherSagas.map(function (s) { 1832 return " created by " + sagaLocationAsString(s.meta); 1833 }), [cancelledTasksAsString(sagaStack)]).join('\n'); 1834}; 1835 1836function newTask(env, mainTask, parentContext, parentEffectId, meta, isRoot, cont) { 1837 var _task; 1838 1839 if (cont === void 0) { 1840 cont = io_22ea0cf9.t; 1841 } 1842 1843 var status = RUNNING; 1844 var taskResult; 1845 var taskError; 1846 var deferredEnd = null; 1847 var cancelledDueToErrorTasks = []; 1848 var context = Object.create(parentContext); 1849 var queue = forkQueue(mainTask, function onAbort() { 1850 cancelledDueToErrorTasks.push.apply(cancelledDueToErrorTasks, queue.getTasks().map(function (t) { 1851 return t.meta.name; 1852 })); 1853 }, end); 1854 /** 1855 This may be called by a parent generator to trigger/propagate cancellation 1856 cancel all pending tasks (including the main task), then end the current task. 1857 Cancellation propagates down to the whole execution tree held by this Parent task 1858 It's also propagated to all joiners of this task and their execution tree/joiners 1859 Cancellation is noop for terminated/Cancelled tasks tasks 1860 **/ 1861 1862 function cancel() { 1863 if (status === RUNNING) { 1864 // Setting status to CANCELLED does not necessarily mean that the task/iterators are stopped 1865 // effects in the iterator's finally block will still be executed 1866 status = CANCELLED; 1867 queue.cancelAll(); // Ending with a TASK_CANCEL will propagate the Cancellation to all joiners 1868 1869 end(redux_saga_symbols_cjs.TASK_CANCEL, false); 1870 } 1871 } 1872 1873 function end(result, isErr) { 1874 if (!isErr) { 1875 // The status here may be RUNNING or CANCELLED 1876 // If the status is CANCELLED, then we do not need to change it here 1877 if (result === redux_saga_symbols_cjs.TASK_CANCEL) { 1878 status = CANCELLED; 1879 } else if (status !== CANCELLED) { 1880 status = DONE; 1881 } 1882 1883 taskResult = result; 1884 deferredEnd && deferredEnd.resolve(result); 1885 } else { 1886 status = ABORTED; 1887 addSagaFrame({ 1888 meta: meta, 1889 cancelledTasks: cancelledDueToErrorTasks 1890 }); 1891 1892 if (task.isRoot) { 1893 var sagaStack = redux_saga_core_esm_toString(); // we've dumped the saga stack to string and are passing it to user's code 1894 // we know that it won't be needed anymore and we need to clear it 1895 1896 clear(); 1897 env.onError(result, { 1898 sagaStack: sagaStack 1899 }); 1900 } 1901 1902 taskError = result; 1903 deferredEnd && deferredEnd.reject(result); 1904 } 1905 1906 task.cont(result, isErr);
1907 task.joiners.forEach(function (joiner) { 1908 joiner.cb(result, isErr); 1909 }); 1910 task.joiners = null; 1911 } 1912 1913 function setContext(props) { 1914 if (false) {} 1915 1916 (0,io_22ea0cf9.p)(context, props); 1917 } 1918 1919 function toPromise() { 1920 if (deferredEnd) { 1921 return deferredEnd.promise; 1922 } 1923 1924 deferredEnd = redux_saga_deferred_esm(); 1925 1926 if (status === ABORTED) { 1927 deferredEnd.reject(taskError); 1928 } else if (status !== RUNNING) { 1929 deferredEnd.resolve(taskResult); 1930 } 1931 1932 return deferredEnd.promise; 1933 } 1934 1935 var task = (_task = {}, _task[redux_saga_symbols_cjs.TASK] = true, _task.id = parentEffectId, _task.meta = meta, _task.isRoot = isRoot, _task.context = context, _task.joiners = [], _task.queue = queue, _task.cancel = cancel, _task.cont = cont, _task.end = end, _task.setContext = setContext, _task.toPromise = toPromise, _task.isRunning = function isRunning() { 1936 return status === RUNNING; 1937 }, _task.isCancelled = function isCancelled() { 1938 return status === CANCELLED || status === RUNNING && mainTask.status === CANCELLED; 1939 }, _task.isAborted = function isAborted() { 1940 return status === ABORTED; 1941 }, _task.result = function result() { 1942 return taskResult; 1943 }, _task.error = function error() { 1944 return taskError; 1945 }, _task); 1946 return task; 1947} 1948 1949function proc(env, iterator$1, parentContext, parentEffectId, meta, isRoot, cont) { 1950 if (false) {} 1951 1952 var finalRunEffect = env.finalizeRunEffect(runEffect); 1953 /** 1954 Tracks the current effect cancellation 1955 Each time the generator progresses. calling runEffect will set a new value 1956 on it. It allows propagating cancellation to child effects 1957 **/ 1958 1959 next.cancel = io_22ea0cf9.t; 1960 /** Creates a main task to track the main flow */ 1961 1962 var mainTask = { 1963 meta: meta, 1964 cancel: cancelMain, 1965 status: RUNNING 1966 }; 1967 /** 1968 Creates a new task descriptor for this generator. 1969 A task is the aggregation of it's mainTask and all it's forked tasks. 1970 **/ 1971 1972 var task = newTask(env, mainTask, parentContext, parentEffectId, meta, isRoot, cont); 1973 var executingContext = { 1974 task: task, 1975 digestEffect: digestEffect 1976 }; 1977 /** 1978 cancellation of the main task. We'll simply resume the Generator with a TASK_CANCEL 1979 **/ 1980 1981 function cancelMain() { 1982 if (mainTask.status === RUNNING) { 1983 mainTask.status = CANCELLED; 1984 next(redux_saga_symbols_cjs.TASK_CANCEL); 1985 } 1986 } 1987 /** 1988 attaches cancellation logic to this task's continuation 1989 this will permit cancellation to propagate down the call chain 1990 **/ 1991 1992 1993 if (cont) { 1994 cont.cancel = task.cancel; 1995 } // kicks up the generator 1996 1997 1998 next(); // then return the task descriptor to the caller 1999 2000 return task; 2001 /** 2002 * This is the generator driver 2003 * It's a recursive async/continuation function which calls itself 2004 * until the generator terminates or throws 2005 * @param {internal commands(TASK_CANCEL | TERMINATE) | any} arg - value, generator will be resumed with. 2006 * @param {boolean} isErr - the flag shows if effect finished with an error 2007 * 2008 * receives either (command | effect result, false) or (any thrown thing, true) 2009 */ 2010 2011 function next(arg, isErr) { 2012 try { 2013 var result; 2014 2015 if (isErr) { 2016 result = iterator$1.throw(arg); // user handled the error, we can clear bookkept values 2017 2018 clear(); 2019 } else if ((0,io_22ea0cf9.y)(arg)) { 2020 /** 2021 getting TASK_CANCEL automatically cancels the main task 2022 We can get this value here 2023 - By cancelling the parent task manually 2024 - By joining a Cancelled task 2025 **/ 2026 mainTask.status = CANCELLED; 2027 /** 2028 Cancels the current effect; this will propagate the cancellation down to any called tasks 2029 **/ 2030 2031 next.cancel(); 2032 /** 2033 If this Generator has a `return` method then invokes it 2034 This will jump to the finally block 2035 **/ 2036 2037 result = (0,redux_saga_is_cjs/* func */.Pc)(iterator$1.return) ? iterator$1.return(redux_saga_symbols_cjs.TASK_CANCEL) : { 2038 done: true, 2039 value: redux_saga_symbols_cjs.TASK_CANCEL 2040 }; 2041 } else if ((0,io_22ea0cf9.z)(arg)) { 2042 // We get TERMINATE flag, i.e. by taking from a channel that ended using `take` (and not `takem` used to trap End of channels) 2043 result = (0,redux_saga_is_cjs/* func */.Pc)(iterator$1.return) ? iterator$1.return() : { 2044 done: true 2045 }; 2046 } else { 2047 result = iterator$1.next(arg); 2048 } 2049 2050 if (!result.done) { 2051 digestEffect(result.value, parentEffectId, next); 2052 } else { 2053 /** 2054 This Generator has ended, terminate the main task and notify the fork queue 2055 **/ 2056 if (mainTask.status !== CANCELLED) { 2057 mainTask.status = DONE; 2058 } 2059 2060 mainTask.cont(result.value); 2061 } 2062 } catch (error) {
2063 if (mainTask.status === CANCELLED) { 2064 throw error; 2065 } 2066 2067 mainTask.status = ABORTED; 2068 mainTask.cont(error, true); 2069 } 2070 } 2071 2072 function runEffect(effect, effectId, currCb) { 2073 /** 2074 each effect runner must attach its own logic of cancellation to the provided callback 2075 it allows this generator to propagate cancellation downward. 2076 ATTENTION! effect runners must setup the cancel logic by setting cb.cancel = [cancelMethod] 2077 And the setup must occur before calling the callback 2078 This is a sort of inversion of control: called async functions are responsible 2079 of completing the flow by calling the provided continuation; while caller functions 2080 are responsible for aborting the current flow by calling the attached cancel function 2081 Library users can attach their own cancellation logic to promises by defining a 2082 promise[CANCEL] method in their returned promises 2083 ATTENTION! calling cancel must have no effect on an already completed or cancelled effect 2084 **/ 2085 if ((0,redux_saga_is_cjs/* promise */.iv)(effect)) { 2086 resolvePromise(effect, currCb); 2087 } else if ((0,redux_saga_is_cjs/* iterator */.lJ)(effect)) { 2088 // resolve iterator 2089 proc(env, effect, task.context, effectId, meta, 2090 /* isRoot */ 2091 false, currCb); 2092 } else if (effect && effect[redux_saga_symbols_cjs.IO]) { 2093 var effectRunner = effectRunnerMap[effect.type]; 2094 effectRunner(env, effect.payload, currCb, executingContext); 2095 } else { 2096 // anything else returned as is 2097 currCb(effect); 2098 } 2099 } 2100 2101 function digestEffect(effect, parentEffectId, cb, label) { 2102 if (label === void 0) { 2103 label = ''; 2104 } 2105 2106 var effectId = nextSagaId(); 2107 env.sagaMonitor && env.sagaMonitor.effectTriggered({ 2108 effectId: effectId, 2109 parentEffectId: parentEffectId, 2110 label: label, 2111 effect: effect 2112 }); 2113 /** 2114 completion callback and cancel callback are mutually exclusive 2115 We can't cancel an already completed effect 2116 And We can't complete an already cancelled effectId 2117 **/ 2118 2119 var effectSettled; // Completion callback passed to the appropriate effect runner 2120 2121 function currCb(res, isErr) { 2122 if (effectSettled) { 2123 return; 2124 } 2125 2126 effectSettled = true; 2127 cb.cancel = io_22ea0cf9.t; // defensive measure 2128 2129 if (env.sagaMonitor) { 2130 if (isErr) { 2131 env.sagaMonitor.effectRejected(effectId, res); 2132 } else { 2133 env.sagaMonitor.effectResolved(effectId, res); 2134 } 2135 } 2136 2137 if (isErr) { 2138 setCrashedEffect(effect); 2139 } 2140 2141 cb(res, isErr); 2142 } // tracks down the current cancel 2143 2144 2145 currCb.cancel = io_22ea0cf9.t; // setup cancellation logic on the parent cb 2146 2147 cb.cancel = function () { 2148 // prevents cancelling an already completed effect 2149 if (effectSettled) { 2150 return; 2151 } 2152 2153 effectSettled = true; 2154 currCb.cancel(); // propagates cancel downward 2155 2156 currCb.cancel = io_22ea0cf9.t; // defensive measure 2157 2158 env.sagaMonitor && env.sagaMonitor.effectCancelled(effectId); 2159 }; 2160 2161 finalRunEffect(effect, effectId, currCb); 2162 } 2163} 2164 2165var RUN_SAGA_SIGNATURE = 'runSaga(options, saga, ...args)'; 2166var NON_GENERATOR_ERR = RUN_SAGA_SIGNATURE + ": saga argument must be a Generator function!"; 2167function runSaga(_ref, saga) { 2168 var _ref$channel = _ref.channel, 2169 channel = _ref$channel === void 0 ? stdChannel() : _ref$channel, 2170 dispatch = _ref.dispatch, 2171 getState = _ref.getState, 2172 _ref$context = _ref.context, 2173 context = _ref$context === void 0 ? {} : _ref$context, 2174 sagaMonitor = _ref.sagaMonitor, 2175 effectMiddlewares = _ref.effectMiddlewares, 2176 _ref$onError = _ref.onError, 2177 onError = _ref$onError === void 0 ? io_22ea0cf9.D : _ref$onError; 2178 2179 if (false) {} 2180 2181 for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) { 2182 args[_key - 2] = arguments[_key]; 2183 } 2184 2185 var iterator$1 = saga.apply(void 0, args); 2186 2187 if (false) {} 2188 2189 var effectId = nextSagaId(); 2190 2191 if (sagaMonitor) { 2192 // monitors are expected to have a certain interface, let's fill-in any missing ones 2193 sagaMonitor.rootSagaStarted = sagaMonitor.rootSagaStarted || io_22ea0cf9.t; 2194 sagaMonitor.effectTriggered = sagaMonitor.effectTriggered || io_22ea0cf9.t; 2195 sagaMonitor.effectResolved = sagaMonitor.effectResolved || io_22ea0cf9.t; 2196 sagaMonitor.effectRejected = sagaMonitor.effectRejected || io_22ea0cf9.t;
2197 sagaMonitor.effectCancelled = sagaMonitor.effectCancelled || io_22ea0cf9.t; 2198 sagaMonitor.actionDispatched = sagaMonitor.actionDispatched || io_22ea0cf9.t; 2199 sagaMonitor.rootSagaStarted({ 2200 effectId: effectId, 2201 saga: saga, 2202 args: args 2203 }); 2204 } 2205 2206 if (false) { var MIDDLEWARE_TYPE_ERROR; } 2207 2208 var finalizeRunEffect; 2209 2210 if (effectMiddlewares) { 2211 var middleware = io_22ea0cf9.B.apply(void 0, effectMiddlewares); 2212 2213 finalizeRunEffect = function finalizeRunEffect(runEffect) { 2214 return function (effect, effectId, currCb) { 2215 var plainRunEffect = function plainRunEffect(eff) { 2216 return runEffect(eff, effectId, currCb); 2217 }; 2218 2219 return middleware(plainRunEffect)(effect); 2220 }; 2221 }; 2222 } else { 2223 finalizeRunEffect = io_22ea0cf9.H; 2224 } 2225 2226 var env = { 2227 channel: channel, 2228 dispatch: (0,io_22ea0cf9.E)(dispatch), 2229 getState: getState, 2230 sagaMonitor: sagaMonitor, 2231 onError: onError, 2232 finalizeRunEffect: finalizeRunEffect 2233 }; 2234 return immediately(function () { 2235 var task = proc(env, iterator$1, context, effectId, (0,io_22ea0cf9.j)(saga), 2236 /* isRoot */ 2237 true, undefined); 2238 2239 if (sagaMonitor) { 2240 sagaMonitor.effectResolved(effectId, task); 2241 } 2242 2243 return task; 2244 }); 2245} 2246 2247function sagaMiddlewareFactory(_temp) { 2248 var _ref = _temp === void 0 ? {} : _temp, 2249 _ref$context = _ref.context, 2250 context = _ref$context === void 0 ? {} : _ref$context, 2251 _ref$channel = _ref.channel, 2252 channel = _ref$channel === void 0 ? stdChannel() : _ref$channel, 2253 sagaMonitor = _ref.sagaMonitor, 2254 options = (0,objectWithoutPropertiesLoose/* default */.A)(_ref, ["context", "channel", "sagaMonitor"]); 2255 2256 var boundRunSaga; 2257 2258 if (false) {} 2259 2260 function sagaMiddleware(_ref2) { 2261 var getState = _ref2.getState, 2262 dispatch = _ref2.dispatch; 2263 boundRunSaga = runSaga.bind(null, (0,esm_extends/* default */.A)({}, options, { 2264 context: context, 2265 channel: channel, 2266 dispatch: dispatch, 2267 getState: getState, 2268 sagaMonitor: sagaMonitor 2269 })); 2270 return function (next) { 2271 return function (action) { 2272 if (sagaMonitor && sagaMonitor.actionDispatched) { 2273 sagaMonitor.actionDispatched(action); 2274 } 2275 2276 var result = next(action); // hit reducers 2277 2278 channel.put(action); 2279 return result; 2280 }; 2281 }; 2282 } 2283 2284 sagaMiddleware.run = function () { 2285 if (false) {} 2286 2287 return boundRunSaga.apply(void 0, arguments); 2288 }; 2289 2290 sagaMiddleware.setContext = function (props) { 2291 if (false) {} 2292 2293 (0,io_22ea0cf9.p)(context, props); 2294 }; 2295 2296 return sagaMiddleware; 2297} 2298 2299/* harmony default export */ const redux_saga_core_esm = (sagaMiddlewareFactory); 2300 2301 2302;// ./node_modules/redux-saga/dist/redux-saga-core-npm-proxy.esm.js 2303 2304 2305 2306 2307 2308/* harmony default export */ const redux_saga_core_npm_proxy_esm = (redux_saga_core_esm); 2309 2310 2311/***/ }), 2312 2313/***/ 43786: 2314/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 2315 2316 2317// EXPORTS 2318__webpack_require__.d(__webpack_exports__, { 2319 T1: () => (/* reexport */ io_22ea0cf9.O), 2320 Zy: () => (/* reexport */ io_22ea0cf9.M), 2321 yJ: () => (/* reexport */ io_22ea0cf9.Z), 2322 Lt: () => (/* reexport */ io_22ea0cf9.a4), 2323 jP: () => (/* reexport */ takeEvery$1), 2324 p8: () => (/* reexport */ takeLatest$1) 2325}); 2326 2327// UNUSED EXPORTS: actionChannel, all, apply, cancel, cancelled, cps, debounce, delay, effectTypes, flush, getContext, join, putResolve, race, retry, setContext, spawn, take, takeLeading, takeMaybe, throttle 2328 2329// EXTERNAL MODULE: ./node_modules/@redux-saga/symbols/dist/redux-saga-symbols.cjs.js 2330var redux_saga_symbols_cjs = __webpack_require__(90468); 2331// EXTERNAL MODULE: ./node_modules/@redux-saga/is/dist/redux-saga-is.cjs.js 2332var redux_saga_is_cjs = __webpack_require__(20704); 2333// EXTERNAL MODULE: ./node_modules/@redux-saga/core/dist/io-22ea0cf9.js 2334var io_22ea0cf9 = __webpack_require__(28424); 2335// EXTERNAL MODULE: ./node_modules/@redux-saga/delay-p/dist/redux-saga-delay-p.esm.js 2336var redux_saga_delay_p_esm = __webpack_require__(37089); 2337;// ./node_modules/@redux-saga/core/dist/redux-saga-effects.esm.js 2338 2339 2340 2341 2342 2343 2344 2345var done = function done(value) { 2346 return { 2347 done: true, 2348 value: value 2349 }; 2350}; 2351 2352var qEnd = {}; 2353function safeName(patternOrChannel) { 2354 if ((0,redux_saga_is_cjs/* channel */.Ix)(patternOrChannel)) { 2355 return 'channel'; 2356 } 2357 2358 if ((0,redux_saga_is_cjs/* stringableFunc */.mr)(patternOrChannel)) { 2359 return String(patternOrChannel); 2360 } 2361 2362 if ((0,redux_saga_is_cjs/* func */.Pc)(patternOrChannel)) { 2363 return patternOrChannel.name; 2364 } 2365 2366 return String(patternOrChannel); 2367} 2368function fsmIterator(fsm, startState, name) { 2369 var stateUpdater, 2370 errorState, 2371 effect, 2372 nextState = startState; 2373 2374 function next(arg, error) { 2375 if (nextState === qEnd) { 2376 return done(arg); 2377 } 2378 2379 if (error && !errorState) { 2380 nextState = qEnd; 2381 throw error; 2382 } else { 2383 stateUpdater && stateUpdater(arg); 2384 var currentState = error ? fsm[errorState](error) : fsm[nextState](); 2385 nextState = currentState.nextState; 2386 effect = currentState.effect; 2387 stateUpdater = currentState.stateUpdater; 2388 errorState = currentState.errorState; 2389 return nextState === qEnd ? done(arg) : effect; 2390 } 2391 } 2392 2393 return (0,io_22ea0cf9.q)(next, function (error) { 2394 return next(null, error); 2395 }, name); 2396} 2397 2398function takeEvery(patternOrChannel, worker) { 2399 for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) { 2400 args[_key - 2] = arguments[_key]; 2401 } 2402 2403 var yTake = { 2404 done: false, 2405 value: (0,io_22ea0cf9.L)(patternOrChannel) 2406 }; 2407 2408 var yFork = function yFork(ac) { 2409 return { 2410 done: false, 2411 value: io_22ea0cf9.M.apply(void 0, [worker].concat(args, [ac])) 2412 }; 2413 }; 2414 2415 var action,
2416 setAction = function setAction(ac) { 2417 return action = ac; 2418 }; 2419 2420 return fsmIterator({ 2421 q1: function q1() { 2422 return { 2423 nextState: 'q2', 2424 effect: yTake, 2425 stateUpdater: setAction 2426 }; 2427 }, 2428 q2: function q2() { 2429 return { 2430 nextState: 'q1', 2431 effect: yFork(action) 2432 }; 2433 } 2434 }, 'q1', "takeEvery(" + safeName(patternOrChannel) + ", " + worker.name + ")"); 2435} 2436 2437function takeLatest(patternOrChannel, worker) { 2438 for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) { 2439 args[_key - 2] = arguments[_key]; 2440 } 2441 2442 var yTake = { 2443 done: false, 2444 value: (0,io_22ea0cf9.L)(patternOrChannel) 2445 }; 2446 2447 var yFork = function yFork(ac) { 2448 return { 2449 done: false, 2450 value: io_22ea0cf9.M.apply(void 0, [worker].concat(args, [ac])) 2451 }; 2452 }; 2453 2454 var yCancel = function yCancel(task) { 2455 return { 2456 done: false, 2457 value: (0,io_22ea0cf9.N)(task) 2458 }; 2459 }; 2460 2461 var task, action; 2462 2463 var setTask = function setTask(t) { 2464 return task = t; 2465 }; 2466 2467 var setAction = function setAction(ac) { 2468 return action = ac; 2469 }; 2470 2471 return fsmIterator({ 2472 q1: function q1() { 2473 return { 2474 nextState: 'q2', 2475 effect: yTake, 2476 stateUpdater: setAction 2477 }; 2478 }, 2479 q2: function q2() { 2480 return task ? { 2481 nextState: 'q3', 2482 effect: yCancel(task) 2483 } : { 2484 nextState: 'q1', 2485 effect: yFork(action), 2486 stateUpdater: setTask 2487 }; 2488 }, 2489 q3: function q3() { 2490 return { 2491 nextState: 'q1', 2492 effect: yFork(action), 2493 stateUpdater: setTask 2494 }; 2495 } 2496 }, 'q1', "takeLatest(" + safeName(patternOrChannel) + ", " + worker.name + ")"); 2497} 2498 2499function takeLeading(patternOrChannel, worker) { 2500 for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) { 2501 args[_key - 2] = arguments[_key]; 2502 } 2503 2504 var yTake = { 2505 done: false, 2506 value: take(patternOrChannel) 2507 }; 2508 2509 var yCall = function yCall(ac) { 2510 return { 2511 done: false, 2512 value: call.apply(void 0, [worker].concat(args, [ac])) 2513 }; 2514 }; 2515 2516 var action; 2517 2518 var setAction = function setAction(ac) { 2519 return action = ac; 2520 }; 2521 2522 return fsmIterator({ 2523 q1: function q1() { 2524 return { 2525 nextState: 'q2', 2526 effect: yTake, 2527 stateUpdater: setAction 2528 }; 2529 }, 2530 q2: function q2() { 2531 return { 2532 nextState: 'q1', 2533 effect: yCall(action) 2534 }; 2535 } 2536 }, 'q1', "takeLeading(" + safeName(patternOrChannel) + ", " + worker.name + ")"); 2537} 2538 2539function throttle(delayLength, patternOrChannel, worker) { 2540 for (var _len = arguments.length, args = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) { 2541 args[_key - 3] = arguments[_key]; 2542 } 2543 2544 var action, channel$1; 2545 2546 var yTake = function yTake() { 2547 return { 2548 done: false, 2549 value: take(channel$1) 2550 }; 2551 }; 2552 2553 var yFork = function yFork(ac) { 2554 return { 2555 done: false, 2556 value: fork.apply(void 0, [worker].concat(args, [ac])) 2557 }; 2558 }; 2559 2560 var yDelay = { 2561 done: false, 2562 value: delay(delayLength) 2563 }; 2564 2565 var setAction = function setAction(ac) { 2566 return action = ac; 2567 }; 2568 2569 var setChannel = function setChannel(ch) { 2570 return channel$1 = ch; 2571 }; 2572 2573 var needsChannel = !channel(patternOrChannel); 2574 2575 if (!needsChannel) { 2576 setChannel(patternOrChannel); 2577 } 2578 2579 return fsmIterator({ 2580 q1: function q1() { 2581 var yActionChannel = { 2582 done: false, 2583 value: actionChannel(patternOrChannel, sliding(1)) 2584 }; 2585 return { 2586 nextState: 'q2', 2587 effect: yActionChannel, 2588 stateUpdater: setChannel 2589 }; 2590 }, 2591 q2: function q2() { 2592 return { 2593 nextState: 'q3', 2594 effect: yTake(), 2595 stateUpdater: setAction 2596 }; 2597 }, 2598 q3: function q3() { 2599 return { 2600 nextState: 'q4', 2601 effect: yFork(action) 2602 }; 2603 }, 2604 q4: function q4() { 2605 return { 2606 nextState: 'q2', 2607 effect: yDelay 2608 }; 2609 } 2610 }, needsChannel ? 'q1' : 'q2', "throttle(" + safeName(patternOrChannel) + ", " + worker.name + ")"); 2611} 2612 2613function retry(maxTries, delayLength, fn) { 2614 var counter = maxTries; 2615 2616 for (var _len = arguments.length, args = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) { 2617 args[_key - 3] = arguments[_key]; 2618 } 2619 2620 var yCall = { 2621 done: false, 2622 value: call.apply(void 0, [fn].concat(args)) 2623 }; 2624 var yDelay = { 2625 done: false, 2626 value: delay(delayLength) 2627 }; 2628 return fsmIterator({ 2629 q1: function q1() { 2630 return { 2631 nextState: 'q2', 2632 effect: yCall, 2633 errorState: 'q10' 2634 }; 2635 }, 2636 q2: function q2() { 2637 return { 2638 nextState: qEnd 2639 }; 2640 }, 2641 q10: function q10(error) { 2642 counter -= 1; 2643 2644 if (counter <= 0) { 2645 throw error; 2646 } 2647 2648 return { 2649 nextState: 'q1', 2650 effect: yDelay 2651 }; 2652 } 2653 }, 'q1', "retry(" + fn.name + ")"); 2654} 2655 2656function debounceHelper(delayLength, patternOrChannel, worker) { 2657 for (var _len = arguments.length, args = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) { 2658 args[_key - 3] = arguments[_key]; 2659 } 2660 2661 var action, raceOutput; 2662 var yTake = { 2663 done: false, 2664 value: take(patternOrChannel) 2665 }; 2666 var yRace = { 2667 done: false, 2668 value: race({ 2669 action: take(patternOrChannel), 2670 debounce: delay(delayLength) 2671 }) 2672 }; 2673 2674 var yFork = function yFork(ac) { 2675 return { 2676 done: false, 2677 value: fork.apply(void 0, [worker].concat(args, [ac])) 2678 }; 2679 }; 2680 2681 var yNoop = function yNoop(value) { 2682 return { 2683 done: false, 2684 value: value 2685 }; 2686 }; 2687 2688 var setAction = function setAction(ac) { 2689 return action = ac; 2690 }; 2691 2692 var setRaceOutput = function setRaceOutput(ro) { 2693 return raceOutput = ro; 2694 }; 2695 2696 return fsmIterator({ 2697 q1: function q1() { 2698 return { 2699 nextState: 'q2', 2700 effect: yTake, 2701 stateUpdater: setAction 2702 }; 2703 }, 2704 q2: function q2() { 2705 return { 2706 nextState: 'q3', 2707 effect: yRace, 2708 stateUpdater: setRaceOutput 2709 }; 2710 }, 2711 q3: function q3() { 2712 return raceOutput.debounce ? { 2713 nextState: 'q1', 2714 effect: yFork(action) 2715 } : { 2716 nextState: 'q2', 2717 effect: yNoop(raceOutput.action), 2718 stateUpdater: setAction 2719 }; 2720 } 2721 }, 'q1', "debounce(" + safeName(patternOrChannel) + ", " + worker.name + ")"); 2722} 2723 2724var validateTakeEffect = function validateTakeEffect(fn, patternOrChannel, worker) { 2725 check(patternOrChannel, notUndef, fn.name + " requires a pattern or channel"); 2726 check(worker, notUndef, fn.name + " requires a saga parameter"); 2727}; 2728 2729function takeEvery$1(patternOrChannel, worker) { 2730 if (false) {} 2731 2732 for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) { 2733 args[_key - 2] = arguments[_key]; 2734 } 2735 2736 return io_22ea0cf9.M.apply(void 0, [takeEvery, patternOrChannel, worker].concat(args)); 2737} 2738function takeLatest$1(patternOrChannel, worker) { 2739 if (false) {} 2740 2741 for (var _len2 = arguments.length, args = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) { 2742 args[_key2 - 2] = arguments[_key2]; 2743 } 2744 2745 return io_22ea0cf9.M.apply(void 0, [takeLatest, patternOrChannel, worker].concat(args)); 2746} 2747function takeLeading$1(patternOrChannel, worker) { 2748 if (false) {} 2749 2750 for (var _len3 = arguments.length, args = new Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) { 2751 args[_key3 - 2] = arguments[_key3]; 2752 } 2753 2754 return fork.apply(void 0, [takeLeading, patternOrChannel, worker].concat(args)); 2755} 2756function throttle$1(ms, patternOrChannel, worker) { 2757 if (false) {} 2758 2759 for (var _len4 = arguments.length, args = new Array(_len4 > 3 ? _len4 - 3 : 0), _key4 = 3; _key4 < _len4; _key4++) { 2760 args[_key4 - 3] = arguments[_key4]; 2761 } 2762 2763 return fork.apply(void 0, [throttle, ms, patternOrChannel, worker].concat(args)); 2764} 2765function retry$1(maxTries, delayLength, worker) { 2766 for (var _len5 = arguments.length, args = new Array(_len5 > 3 ? _len5 - 3 : 0), _key5 = 3; _key5 < _len5; _key5++) { 2767 args[_key5 - 3] = arguments[_key5]; 2768 } 2769 2770 return call.apply(void 0, [retry, maxTries, delayLength, worker].concat(args)); 2771} 2772function debounce(delayLength, pattern, worker) { 2773 for (var _len6 = arguments.length, args = new Array(_len6 > 3 ? _len6 - 3 : 0), _key6 = 3; _key6 < _len6; _key6++) { 2774 args[_key6 - 3] = arguments[_key6]; 2775 } 2776 2777 return fork.apply(void 0, [debounceHelper, delayLength, pattern, worker].concat(args)); 2778} 2779 2780 2781 2782;// ./node_modules/redux-saga/dist/redux-saga-effects-npm-proxy.esm.js 2783 2784 2785 2786/***/ }) 2787 2788}]);
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.