| [ Index ] |
PHP Cross Reference of WordPress |
[Summary view] [Print] [Text view]
1 this["wp"] = this["wp"] || {}; this["wp"]["data"] = 2 /******/ (function(modules) { // webpackBootstrap 3 /******/ // The module cache 4 /******/ var installedModules = {}; 5 /******/ 6 /******/ // The require function 7 /******/ function __webpack_require__(moduleId) { 8 /******/ 9 /******/ // Check if module is in cache 10 /******/ if(installedModules[moduleId]) { 11 /******/ return installedModules[moduleId].exports; 12 /******/ } 13 /******/ // Create a new module (and put it into the cache) 14 /******/ var module = installedModules[moduleId] = { 15 /******/ i: moduleId, 16 /******/ l: false, 17 /******/ exports: {} 18 /******/ }; 19 /******/ 20 /******/ // Execute the module function 21 /******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); 22 /******/ 23 /******/ // Flag the module as loaded 24 /******/ module.l = true; 25 /******/ 26 /******/ // Return the exports of the module 27 /******/ return module.exports; 28 /******/ } 29 /******/ 30 /******/ 31 /******/ // expose the modules object (__webpack_modules__) 32 /******/ __webpack_require__.m = modules; 33 /******/ 34 /******/ // expose the module cache 35 /******/ __webpack_require__.c = installedModules; 36 /******/ 37 /******/ // define getter function for harmony exports 38 /******/ __webpack_require__.d = function(exports, name, getter) { 39 /******/ if(!__webpack_require__.o(exports, name)) { 40 /******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); 41 /******/ } 42 /******/ }; 43 /******/ 44 /******/ // define __esModule on exports 45 /******/ __webpack_require__.r = function(exports) { 46 /******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { 47 /******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); 48 /******/ } 49 /******/ Object.defineProperty(exports, '__esModule', { value: true }); 50 /******/ }; 51 /******/ 52 /******/ // create a fake namespace object 53 /******/ // mode & 1: value is a module id, require it 54 /******/ // mode & 2: merge all properties of value into the ns 55 /******/ // mode & 4: return value when already ns object 56 /******/ // mode & 8|1: behave like require 57 /******/ __webpack_require__.t = function(value, mode) { 58 /******/ if(mode & 1) value = __webpack_require__(value); 59 /******/ if(mode & 8) return value; 60 /******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; 61 /******/ var ns = Object.create(null); 62 /******/ __webpack_require__.r(ns); 63 /******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); 64 /******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); 65 /******/ return ns; 66 /******/ }; 67 /******/ 68 /******/ // getDefaultExport function for compatibility with non-harmony modules 69 /******/ __webpack_require__.n = function(module) { 70 /******/ var getter = module && module.__esModule ? 71 /******/ function getDefault() { return module['default']; } : 72 /******/ function getModuleExports() { return module; }; 73 /******/ __webpack_require__.d(getter, 'a', getter); 74 /******/ return getter; 75 /******/ }; 76 /******/ 77 /******/ // Object.prototype.hasOwnProperty.call 78 /******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; 79 /******/ 80 /******/ // __webpack_public_path__ 81 /******/ __webpack_require__.p = ""; 82 /******/ 83 /******/ 84 /******/ // Load entry module and return exports 85 /******/ return __webpack_require__(__webpack_require__.s = 462); 86 /******/ }) 87 /************************************************************************/ 88 /******/ ({ 89 90 /***/ 0: 91 /***/ (function(module, exports) { 92 93 (function() { module.exports = window["wp"]["element"]; }()); 94 95 /***/ }), 96 97 /***/ 104: 98 /***/ (function(module, exports, __webpack_require__) { 99 100 "use strict"; 101 102 103 function _typeof(obj) { 104 if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { 105 _typeof = function (obj) { 106 return typeof obj; 107 }; 108 } else { 109 _typeof = function (obj) { 110 return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; 111 }; 112 } 113 114 return _typeof(obj); 115 } 116 117 function _classCallCheck(instance, Constructor) { 118 if (!(instance instanceof Constructor)) { 119 throw new TypeError("Cannot call a class as a function"); 120 } 121 } 122 123 function _defineProperties(target, props) { 124 for (var i = 0; i < props.length; i++) { 125 var descriptor = props[i]; 126 descriptor.enumerable = descriptor.enumerable || false; 127 descriptor.configurable = true; 128 if ("value" in descriptor) descriptor.writable = true; 129 Object.defineProperty(target, descriptor.key, descriptor); 130 } 131 } 132 133 function _createClass(Constructor, protoProps, staticProps) { 134 if (protoProps) _defineProperties(Constructor.prototype, protoProps); 135 if (staticProps) _defineProperties(Constructor, staticProps); 136 return Constructor; 137 } 138 139 /** 140 * Given an instance of EquivalentKeyMap, returns its internal value pair tuple 141 * for a key, if one exists. The tuple members consist of the last reference 142 * value for the key (used in efficient subsequent lookups) and the value 143 * assigned for the key at the leaf node. 144 * 145 * @param {EquivalentKeyMap} instance EquivalentKeyMap instance. 146 * @param {*} key The key for which to return value pair. 147 * 148 * @return {?Array} Value pair, if exists. 149 */ 150 function getValuePair(instance, key) { 151 var _map = instance._map, 152 _arrayTreeMap = instance._arrayTreeMap, 153 _objectTreeMap = instance._objectTreeMap; // Map keeps a reference to the last object-like key used to set the 154 // value, which can be used to shortcut immediately to the value. 155 156 if (_map.has(key)) { 157 return _map.get(key); 158 } // Sort keys to ensure stable retrieval from tree. 159 160 161 var properties = Object.keys(key).sort(); // Tree by type to avoid conflicts on numeric object keys, empty value. 162 163 var map = Array.isArray(key) ? _arrayTreeMap : _objectTreeMap; 164 165 for (var i = 0; i < properties.length; i++) { 166 var property = properties[i]; 167 map = map.get(property); 168 169 if (map === undefined) { 170 return; 171 } 172 173 var propertyValue = key[property]; 174 map = map.get(propertyValue); 175 176 if (map === undefined) { 177 return; 178 } 179 } 180 181 var valuePair = map.get('_ekm_value'); 182 183 if (!valuePair) { 184 return; 185 } // If reached, it implies that an object-like key was set with another 186 // reference, so delete the reference and replace with the current. 187 188 189 _map.delete(valuePair[0]); 190 191 valuePair[0] = key; 192 map.set('_ekm_value', valuePair); 193 194 _map.set(key, valuePair); 195 196 return valuePair; 197 } 198 /** 199 * Variant of a Map object which enables lookup by equivalent (deeply equal) 200 * object and array keys. 201 */ 202 203 204 var EquivalentKeyMap = 205 /*#__PURE__*/ 206 function () { 207 /** 208 * Constructs a new instance of EquivalentKeyMap. 209 * 210 * @param {Iterable.<*>} iterable Initial pair of key, value for map. 211 */ 212 function EquivalentKeyMap(iterable) { 213 _classCallCheck(this, EquivalentKeyMap); 214 215 this.clear(); 216 217 if (iterable instanceof EquivalentKeyMap) { 218 // Map#forEach is only means of iterating with support for IE11. 219 var iterablePairs = []; 220 iterable.forEach(function (value, key) { 221 iterablePairs.push([key, value]); 222 }); 223 iterable = iterablePairs; 224 } 225 226 if (iterable != null) { 227 for (var i = 0; i < iterable.length; i++) { 228 this.set(iterable[i][0], iterable[i][1]); 229 } 230 } 231 } 232 /** 233 * Accessor property returning the number of elements. 234 * 235 * @return {number} Number of elements. 236 */ 237 238 239 _createClass(EquivalentKeyMap, [{ 240 key: "set", 241 242 /** 243 * Add or update an element with a specified key and value. 244 * 245 * @param {*} key The key of the element to add. 246 * @param {*} value The value of the element to add. 247 * 248 * @return {EquivalentKeyMap} Map instance. 249 */ 250 value: function set(key, value) { 251 // Shortcut non-object-like to set on internal Map. 252 if (key === null || _typeof(key) !== 'object') { 253 this._map.set(key, value); 254 255 return this; 256 } // Sort keys to ensure stable assignment into tree. 257 258 259 var properties = Object.keys(key).sort(); 260 var valuePair = [key, value]; // Tree by type to avoid conflicts on numeric object keys, empty value. 261 262 var map = Array.isArray(key) ? this._arrayTreeMap : this._objectTreeMap; 263 264 for (var i = 0; i < properties.length; i++) { 265 var property = properties[i]; 266 267 if (!map.has(property)) { 268 map.set(property, new EquivalentKeyMap()); 269 } 270 271 map = map.get(property); 272 var propertyValue = key[property]; 273 274 if (!map.has(propertyValue)) { 275 map.set(propertyValue, new EquivalentKeyMap()); 276 } 277 278 map = map.get(propertyValue); 279 } // If an _ekm_value exists, there was already an equivalent key. Before 280 // overriding, ensure that the old key reference is removed from map to 281 // avoid memory leak of accumulating equivalent keys. This is, in a 282 // sense, a poor man's WeakMap, while still enabling iterability. 283 284 285 var previousValuePair = map.get('_ekm_value'); 286 287 if (previousValuePair) { 288 this._map.delete(previousValuePair[0]); 289 } 290 291 map.set('_ekm_value', valuePair); 292 293 this._map.set(key, valuePair); 294 295 return this; 296 } 297 /** 298 * Returns a specified element. 299 * 300 * @param {*} key The key of the element to return. 301 * 302 * @return {?*} The element associated with the specified key or undefined 303 * if the key can't be found. 304 */ 305 306 }, { 307 key: "get", 308 value: function get(key) { 309 // Shortcut non-object-like to get from internal Map. 310 if (key === null || _typeof(key) !== 'object') { 311 return this._map.get(key); 312 } 313 314 var valuePair = getValuePair(this, key); 315 316 if (valuePair) { 317 return valuePair[1]; 318 } 319 } 320 /** 321 * Returns a boolean indicating whether an element with the specified key 322 * exists or not. 323 * 324 * @param {*} key The key of the element to test for presence. 325 * 326 * @return {boolean} Whether an element with the specified key exists. 327 */ 328 329 }, { 330 key: "has", 331 value: function has(key) { 332 if (key === null || _typeof(key) !== 'object') { 333 return this._map.has(key); 334 } // Test on the _presence_ of the pair, not its value, as even undefined 335 // can be a valid member value for a key. 336 337 338 return getValuePair(this, key) !== undefined; 339 } 340 /** 341 * Removes the specified element. 342 * 343 * @param {*} key The key of the element to remove. 344 * 345 * @return {boolean} Returns true if an element existed and has been 346 * removed, or false if the element does not exist. 347 */ 348 349 }, { 350 key: "delete", 351 value: function _delete(key) { 352 if (!this.has(key)) { 353 return false; 354 } // This naive implementation will leave orphaned child trees. A better 355 // implementation should traverse and remove orphans. 356 357 358 this.set(key, undefined); 359 return true; 360 } 361 /** 362 * Executes a provided function once per each key/value pair, in insertion 363 * order. 364 * 365 * @param {Function} callback Function to execute for each element. 366 * @param {*} thisArg Value to use as `this` when executing 367 * `callback`. 368 */ 369 370 }, { 371 key: "forEach", 372 value: function forEach(callback) { 373 var _this = this; 374 375 var thisArg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this; 376 377 this._map.forEach(function (value, key) { 378 // Unwrap value from object-like value pair. 379 if (key !== null && _typeof(key) === 'object') { 380 value = value[1]; 381 } 382 383 callback.call(thisArg, value, key, _this); 384 }); 385 } 386 /** 387 * Removes all elements. 388 */ 389 390 }, { 391 key: "clear", 392 value: function clear() { 393 this._map = new Map(); 394 this._arrayTreeMap = new Map(); 395 this._objectTreeMap = new Map(); 396 } 397 }, { 398 key: "size", 399 get: function get() { 400 return this._map.size; 401 } 402 }]); 403 404 return EquivalentKeyMap; 405 }(); 406 407 module.exports = EquivalentKeyMap; 408 409 410 /***/ }), 411 412 /***/ 11: 413 /***/ (function(module, __webpack_exports__, __webpack_require__) { 414 415 "use strict"; 416 417 // EXPORTS 418 __webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ _slicedToArray; }); 419 420 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js 421 var arrayWithHoles = __webpack_require__(38); 422 423 // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js 424 function _iterableToArrayLimit(arr, i) { 425 if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; 426 var _arr = []; 427 var _n = true; 428 var _d = false; 429 var _e = undefined; 430 431 try { 432 for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { 433 _arr.push(_s.value); 434 435 if (i && _arr.length === i) break; 436 } 437 } catch (err) { 438 _d = true; 439 _e = err; 440 } finally { 441 try { 442 if (!_n && _i["return"] != null) _i["return"](); 443 } finally { 444 if (_d) throw _e; 445 } 446 } 447 448 return _arr; 449 } 450 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js 451 var unsupportedIterableToArray = __webpack_require__(31); 452 453 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js 454 var nonIterableRest = __webpack_require__(39); 455 456 // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js 457 458 459 460 461 function _slicedToArray(arr, i) { 462 return Object(arrayWithHoles["a" /* default */])(arr) || _iterableToArrayLimit(arr, i) || Object(unsupportedIterableToArray["a" /* default */])(arr, i) || Object(nonIterableRest["a" /* default */])(); 463 } 464 465 /***/ }), 466 467 /***/ 12: 468 /***/ (function(module, exports) { 469 470 (function() { module.exports = window["wp"]["compose"]; }()); 471 472 /***/ }), 473 474 /***/ 122: 475 /***/ (function(module, exports) { 476 477 var g; 478 479 // This works in non-strict mode 480 g = (function() { 481 return this; 482 })(); 483 484 try { 485 // This works if eval is allowed (see CSP) 486 g = g || new Function("return this")(); 487 } catch (e) { 488 // This works if the window reference is available 489 if (typeof window === "object") g = window; 490 } 491 492 // g can still be undefined, but nothing to do about it... 493 // We return undefined, instead of nothing here, so it's 494 // easier to handle this case. if(!global) { ...} 495 496 module.exports = g; 497 498 499 /***/ }), 500 501 /***/ 127: 502 /***/ (function(module, __webpack_exports__, __webpack_require__) { 503 504 "use strict"; 505 /* unused harmony export useCallback */ 506 /* unused harmony export useCallbackOne */ 507 /* unused harmony export useMemo */ 508 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return useMemoOne; }); 509 /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(14); 510 /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__); 511 512 513 function areInputsEqual(newInputs, lastInputs) { 514 if (newInputs.length !== lastInputs.length) { 515 return false; 516 } 517 518 for (var i = 0; i < newInputs.length; i++) { 519 if (newInputs[i] !== lastInputs[i]) { 520 return false; 521 } 522 } 523 524 return true; 525 } 526 527 function useMemoOne(getResult, inputs) { 528 var initial = Object(react__WEBPACK_IMPORTED_MODULE_0__["useState"])(function () { 529 return { 530 inputs: inputs, 531 result: getResult() 532 }; 533 })[0]; 534 var isFirstRun = Object(react__WEBPACK_IMPORTED_MODULE_0__["useRef"])(true); 535 var committed = Object(react__WEBPACK_IMPORTED_MODULE_0__["useRef"])(initial); 536 var useCache = isFirstRun.current || Boolean(inputs && committed.current.inputs && areInputsEqual(inputs, committed.current.inputs)); 537 var cache = useCache ? committed.current : { 538 inputs: inputs, 539 result: getResult() 540 }; 541 Object(react__WEBPACK_IMPORTED_MODULE_0__["useEffect"])(function () { 542 isFirstRun.current = false; 543 committed.current = cache; 544 }, [cache]); 545 return cache.result; 546 } 547 function useCallbackOne(callback, inputs) { 548 return useMemoOne(function () { 549 return callback; 550 }, inputs); 551 } 552 var useMemo = useMemoOne; 553 var useCallback = useCallbackOne; 554 555 556 557 558 /***/ }), 559 560 /***/ 14: 561 /***/ (function(module, exports) { 562 563 (function() { module.exports = window["React"]; }()); 564 565 /***/ }), 566 567 /***/ 15: 568 /***/ (function(module, __webpack_exports__, __webpack_require__) { 569 570 "use strict"; 571 572 // EXPORTS 573 __webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ _toConsumableArray; }); 574 575 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js 576 var arrayLikeToArray = __webpack_require__(24); 577 578 // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js 579 580 function _arrayWithoutHoles(arr) { 581 if (Array.isArray(arr)) return Object(arrayLikeToArray["a" /* default */])(arr); 582 } 583 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArray.js 584 var iterableToArray = __webpack_require__(37); 585 586 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js 587 var unsupportedIterableToArray = __webpack_require__(31); 588 589 // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js 590 function _nonIterableSpread() { 591 throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); 592 } 593 // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js 594 595 596 597 598 function _toConsumableArray(arr) { 599 return _arrayWithoutHoles(arr) || Object(iterableToArray["a" /* default */])(arr) || Object(unsupportedIterableToArray["a" /* default */])(arr) || _nonIterableSpread(); 600 } 601 602 /***/ }), 603 604 /***/ 152: 605 /***/ (function(module, exports) { 606 607 (function() { module.exports = window["wp"]["priorityQueue"]; }()); 608 609 /***/ }), 610 611 /***/ 153: 612 /***/ (function(module, exports) { 613 614 module.exports = isPromise; 615 module.exports.default = isPromise; 616 617 function isPromise(obj) { 618 return !!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function'; 619 } 620 621 622 /***/ }), 623 624 /***/ 16: 625 /***/ (function(module, exports) { 626 627 (function() { module.exports = window["regeneratorRuntime"]; }()); 628 629 /***/ }), 630 631 /***/ 170: 632 /***/ (function(module, exports) { 633 634 function combineReducers( reducers ) { 635 var keys = Object.keys( reducers ), 636 getNextState; 637 638 getNextState = ( function() { 639 var fn, i, key; 640 641 fn = 'return {'; 642 for ( i = 0; i < keys.length; i++ ) { 643 // Rely on Quoted escaping of JSON.stringify with guarantee that 644 // each member of Object.keys is a string. 645 // 646 // "If Type(value) is String, then return the result of calling the 647 // abstract operation Quote with argument value. [...] The abstract 648 // operation Quote(value) wraps a String value in double quotes and 649 // escapes characters within it." 650 // 651 // https://www.ecma-international.org/ecma-262/5.1/#sec-15.12.3 652 key = JSON.stringify( keys[ i ] ); 653 654 fn += key + ':r[' + key + '](s[' + key + '],a),'; 655 } 656 fn += '}'; 657 658 return new Function( 'r,s,a', fn ); 659 } )(); 660 661 return function combinedReducer( state, action ) { 662 var nextState, i, key; 663 664 // Assumed changed if initial state. 665 if ( state === undefined ) { 666 return getNextState( reducers, {}, action ); 667 } 668 669 nextState = getNextState( reducers, state, action ); 670 671 // Determine whether state has changed. 672 i = keys.length; 673 while ( i-- ) { 674 key = keys[ i ]; 675 if ( state[ key ] !== nextState[ key ] ) { 676 // Return immediately if a changed value is encountered. 677 return nextState; 678 } 679 } 680 681 return state; 682 }; 683 } 684 685 module.exports = combineReducers; 686 687 688 /***/ }), 689 690 /***/ 2: 691 /***/ (function(module, exports) { 692 693 (function() { module.exports = window["lodash"]; }()); 694 695 /***/ }), 696 697 /***/ 208: 698 /***/ (function(module, __webpack_exports__, __webpack_require__) { 699 700 "use strict"; 701 /* WEBPACK VAR INJECTION */(function(global, module) {/* harmony import */ var _ponyfill_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(292); 702 /* global window */ 703 704 705 var root; 706 707 if (typeof self !== 'undefined') { 708 root = self; 709 } else if (typeof window !== 'undefined') { 710 root = window; 711 } else if (typeof global !== 'undefined') { 712 root = global; 713 } else if (true) { 714 root = module; 715 } else {} 716 717 var result = Object(_ponyfill_js__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(root); 718 /* harmony default export */ __webpack_exports__["a"] = (result); 719 720 /* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(122), __webpack_require__(438)(module))) 721 722 /***/ }), 723 724 /***/ 24: 725 /***/ (function(module, __webpack_exports__, __webpack_require__) { 726 727 "use strict"; 728 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayLikeToArray; }); 729 function _arrayLikeToArray(arr, len) { 730 if (len == null || len > arr.length) len = arr.length; 731 732 for (var i = 0, arr2 = new Array(len); i < len; i++) { 733 arr2[i] = arr[i]; 734 } 735 736 return arr2; 737 } 738 739 /***/ }), 740 741 /***/ 291: 742 /***/ (function(module, exports) { 743 744 (function() { module.exports = window["wp"]["reduxRoutine"]; }()); 745 746 /***/ }), 747 748 /***/ 292: 749 /***/ (function(module, __webpack_exports__, __webpack_require__) { 750 751 "use strict"; 752 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return symbolObservablePonyfill; }); 753 function symbolObservablePonyfill(root) { 754 var result; 755 var Symbol = root.Symbol; 756 757 if (typeof Symbol === 'function') { 758 if (Symbol.observable) { 759 result = Symbol.observable; 760 } else { 761 result = Symbol('observable'); 762 Symbol.observable = result; 763 } 764 } else { 765 result = '@@observable'; 766 } 767 768 return result; 769 }; 770 771 772 /***/ }), 773 774 /***/ 31: 775 /***/ (function(module, __webpack_exports__, __webpack_require__) { 776 777 "use strict"; 778 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _unsupportedIterableToArray; }); 779 /* harmony import */ var _babel_runtime_helpers_esm_arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(24); 780 781 function _unsupportedIterableToArray(o, minLen) { 782 if (!o) return; 783 if (typeof o === "string") return Object(_babel_runtime_helpers_esm_arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(o, minLen); 784 var n = Object.prototype.toString.call(o).slice(8, -1); 785 if (n === "Object" && o.constructor) n = o.constructor.name; 786 if (n === "Map" || n === "Set") return Array.from(o); 787 if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return Object(_babel_runtime_helpers_esm_arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(o, minLen); 788 } 789 790 /***/ }), 791 792 /***/ 35: 793 /***/ (function(module, exports) { 794 795 (function() { module.exports = window["wp"]["deprecated"]; }()); 796 797 /***/ }), 798 799 /***/ 37: 800 /***/ (function(module, __webpack_exports__, __webpack_require__) { 801 802 "use strict"; 803 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _iterableToArray; }); 804 function _iterableToArray(iter) { 805 if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); 806 } 807 808 /***/ }), 809 810 /***/ 38: 811 /***/ (function(module, __webpack_exports__, __webpack_require__) { 812 813 "use strict"; 814 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayWithHoles; }); 815 function _arrayWithHoles(arr) { 816 if (Array.isArray(arr)) return arr; 817 } 818 819 /***/ }), 820 821 /***/ 39: 822 /***/ (function(module, __webpack_exports__, __webpack_require__) { 823 824 "use strict"; 825 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _nonIterableRest; }); 826 function _nonIterableRest() { 827 throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); 828 } 829 830 /***/ }), 831 832 /***/ 438: 833 /***/ (function(module, exports) { 834 835 module.exports = function(originalModule) { 836 if (!originalModule.webpackPolyfill) { 837 var module = Object.create(originalModule); 838 // module.parent = undefined by default 839 if (!module.children) module.children = []; 840 Object.defineProperty(module, "loaded", { 841 enumerable: true, 842 get: function() { 843 return module.l; 844 } 845 }); 846 Object.defineProperty(module, "id", { 847 enumerable: true, 848 get: function() { 849 return module.i; 850 } 851 }); 852 Object.defineProperty(module, "exports", { 853 enumerable: true 854 }); 855 module.webpackPolyfill = 1; 856 } 857 return module; 858 }; 859 860 861 /***/ }), 862 863 /***/ 462: 864 /***/ (function(module, __webpack_exports__, __webpack_require__) { 865 866 "use strict"; 867 // ESM COMPAT FLAG 868 __webpack_require__.r(__webpack_exports__); 869 870 // EXPORTS 871 __webpack_require__.d(__webpack_exports__, "withSelect", function() { return /* reexport */ with_select; }); 872 __webpack_require__.d(__webpack_exports__, "withDispatch", function() { return /* reexport */ with_dispatch; }); 873 __webpack_require__.d(__webpack_exports__, "withRegistry", function() { return /* reexport */ with_registry; }); 874 __webpack_require__.d(__webpack_exports__, "RegistryProvider", function() { return /* reexport */ context; }); 875 __webpack_require__.d(__webpack_exports__, "RegistryConsumer", function() { return /* reexport */ RegistryConsumer; }); 876 __webpack_require__.d(__webpack_exports__, "useRegistry", function() { return /* reexport */ useRegistry; }); 877 __webpack_require__.d(__webpack_exports__, "useSelect", function() { return /* reexport */ useSelect; }); 878 __webpack_require__.d(__webpack_exports__, "useDispatch", function() { return /* reexport */ use_dispatch; }); 879 __webpack_require__.d(__webpack_exports__, "AsyncModeProvider", function() { return /* reexport */ async_mode_provider_context; }); 880 __webpack_require__.d(__webpack_exports__, "createRegistry", function() { return /* reexport */ createRegistry; }); 881 __webpack_require__.d(__webpack_exports__, "createRegistrySelector", function() { return /* reexport */ createRegistrySelector; }); 882 __webpack_require__.d(__webpack_exports__, "createRegistryControl", function() { return /* reexport */ createRegistryControl; }); 883 __webpack_require__.d(__webpack_exports__, "controls", function() { return /* reexport */ controls_controls; }); 884 __webpack_require__.d(__webpack_exports__, "createReduxStore", function() { return /* reexport */ createReduxStore; }); 885 __webpack_require__.d(__webpack_exports__, "plugins", function() { return /* reexport */ plugins_namespaceObject; }); 886 __webpack_require__.d(__webpack_exports__, "combineReducers", function() { return /* reexport */ turbo_combine_reducers_default.a; }); 887 __webpack_require__.d(__webpack_exports__, "select", function() { return /* binding */ build_module_select; }); 888 __webpack_require__.d(__webpack_exports__, "__experimentalResolveSelect", function() { return /* binding */ build_module_experimentalResolveSelect; }); 889 __webpack_require__.d(__webpack_exports__, "dispatch", function() { return /* binding */ build_module_dispatch; }); 890 __webpack_require__.d(__webpack_exports__, "subscribe", function() { return /* binding */ build_module_subscribe; }); 891 __webpack_require__.d(__webpack_exports__, "registerGenericStore", function() { return /* binding */ build_module_registerGenericStore; }); 892 __webpack_require__.d(__webpack_exports__, "registerStore", function() { return /* binding */ build_module_registerStore; }); 893 __webpack_require__.d(__webpack_exports__, "use", function() { return /* binding */ build_module_use; }); 894 __webpack_require__.d(__webpack_exports__, "register", function() { return /* binding */ build_module_register; }); 895 896 // NAMESPACE OBJECT: ./node_modules/@wordpress/data/build-module/redux-store/metadata/selectors.js 897 var selectors_namespaceObject = {}; 898 __webpack_require__.r(selectors_namespaceObject); 899 __webpack_require__.d(selectors_namespaceObject, "getIsResolving", function() { return getIsResolving; }); 900 __webpack_require__.d(selectors_namespaceObject, "hasStartedResolution", function() { return hasStartedResolution; }); 901 __webpack_require__.d(selectors_namespaceObject, "hasFinishedResolution", function() { return hasFinishedResolution; }); 902 __webpack_require__.d(selectors_namespaceObject, "isResolving", function() { return isResolving; }); 903 __webpack_require__.d(selectors_namespaceObject, "getCachedResolvers", function() { return getCachedResolvers; }); 904 905 // NAMESPACE OBJECT: ./node_modules/@wordpress/data/build-module/redux-store/metadata/actions.js 906 var actions_namespaceObject = {}; 907 __webpack_require__.r(actions_namespaceObject); 908 __webpack_require__.d(actions_namespaceObject, "startResolution", function() { return startResolution; }); 909 __webpack_require__.d(actions_namespaceObject, "finishResolution", function() { return finishResolution; }); 910 __webpack_require__.d(actions_namespaceObject, "invalidateResolution", function() { return invalidateResolution; }); 911 __webpack_require__.d(actions_namespaceObject, "invalidateResolutionForStore", function() { return invalidateResolutionForStore; }); 912 __webpack_require__.d(actions_namespaceObject, "invalidateResolutionForStoreSelector", function() { return invalidateResolutionForStoreSelector; }); 913 914 // NAMESPACE OBJECT: ./node_modules/@wordpress/data/build-module/plugins/index.js 915 var plugins_namespaceObject = {}; 916 __webpack_require__.r(plugins_namespaceObject); 917 __webpack_require__.d(plugins_namespaceObject, "controls", function() { return plugins_controls; }); 918 __webpack_require__.d(plugins_namespaceObject, "persistence", function() { return plugins_persistence; }); 919 920 // EXTERNAL MODULE: ./node_modules/turbo-combine-reducers/index.js 921 var turbo_combine_reducers = __webpack_require__(170); 922 var turbo_combine_reducers_default = /*#__PURE__*/__webpack_require__.n(turbo_combine_reducers); 923 924 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules 925 var slicedToArray = __webpack_require__(11); 926 927 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js 928 var defineProperty = __webpack_require__(5); 929 930 // EXTERNAL MODULE: external "lodash" 931 var external_lodash_ = __webpack_require__(2); 932 933 // EXTERNAL MODULE: external "regeneratorRuntime" 934 var external_regeneratorRuntime_ = __webpack_require__(16); 935 var external_regeneratorRuntime_default = /*#__PURE__*/__webpack_require__.n(external_regeneratorRuntime_); 936 937 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js 938 var asyncToGenerator = __webpack_require__(47); 939 940 // EXTERNAL MODULE: ./node_modules/symbol-observable/es/index.js 941 var es = __webpack_require__(208); 942 943 // CONCATENATED MODULE: ./node_modules/redux/es/redux.js 944 945 946 /** 947 * These are private action types reserved by Redux. 948 * For any unknown actions, you must return the current state. 949 * If the current state is undefined, you must return the initial state. 950 * Do not reference these action types directly in your code. 951 */ 952 var randomString = function randomString() { 953 return Math.random().toString(36).substring(7).split('').join('.'); 954 }; 955 956 var ActionTypes = { 957 INIT: "@@redux/INIT" + randomString(), 958 REPLACE: "@@redux/REPLACE" + randomString(), 959 PROBE_UNKNOWN_ACTION: function PROBE_UNKNOWN_ACTION() { 960 return "@@redux/PROBE_UNKNOWN_ACTION" + randomString(); 961 } 962 }; 963 964 /** 965 * @param {any} obj The object to inspect. 966 * @returns {boolean} True if the argument appears to be a plain object. 967 */ 968 function isPlainObject(obj) { 969 if (typeof obj !== 'object' || obj === null) return false; 970 var proto = obj; 971 972 while (Object.getPrototypeOf(proto) !== null) { 973 proto = Object.getPrototypeOf(proto); 974 } 975 976 return Object.getPrototypeOf(obj) === proto; 977 } 978 979 /** 980 * Creates a Redux store that holds the state tree. 981 * The only way to change the data in the store is to call `dispatch()` on it. 982 * 983 * There should only be a single store in your app. To specify how different 984 * parts of the state tree respond to actions, you may combine several reducers 985 * into a single reducer function by using `combineReducers`. 986 * 987 * @param {Function} reducer A function that returns the next state tree, given 988 * the current state tree and the action to handle. 989 * 990 * @param {any} [preloadedState] The initial state. You may optionally specify it 991 * to hydrate the state from the server in universal apps, or to restore a 992 * previously serialized user session. 993 * If you use `combineReducers` to produce the root reducer function, this must be 994 * an object with the same shape as `combineReducers` keys. 995 * 996 * @param {Function} [enhancer] The store enhancer. You may optionally specify it 997 * to enhance the store with third-party capabilities such as middleware, 998 * time travel, persistence, etc. The only store enhancer that ships with Redux 999 * is `applyMiddleware()`. 1000 * 1001 * @returns {Store} A Redux store that lets you read the state, dispatch actions 1002 * and subscribe to changes. 1003 */ 1004 1005 function createStore(reducer, preloadedState, enhancer) { 1006 var _ref2; 1007 1008 if (typeof preloadedState === 'function' && typeof enhancer === 'function' || typeof enhancer === 'function' && typeof arguments[3] === 'function') { 1009 throw new Error('It looks like you are passing several store enhancers to ' + 'createStore(). This is not supported. Instead, compose them ' + 'together to a single function.'); 1010 } 1011 1012 if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') { 1013 enhancer = preloadedState; 1014 preloadedState = undefined; 1015 } 1016 1017 if (typeof enhancer !== 'undefined') { 1018 if (typeof enhancer !== 'function') { 1019 throw new Error('Expected the enhancer to be a function.'); 1020 } 1021 1022 return enhancer(createStore)(reducer, preloadedState); 1023 } 1024 1025 if (typeof reducer !== 'function') { 1026 throw new Error('Expected the reducer to be a function.'); 1027 } 1028 1029 var currentReducer = reducer; 1030 var currentState = preloadedState; 1031 var currentListeners = []; 1032 var nextListeners = currentListeners; 1033 var isDispatching = false; 1034 /** 1035 * This makes a shallow copy of currentListeners so we can use 1036 * nextListeners as a temporary list while dispatching. 1037 * 1038 * This prevents any bugs around consumers calling 1039 * subscribe/unsubscribe in the middle of a dispatch. 1040 */ 1041 1042 function ensureCanMutateNextListeners() { 1043 if (nextListeners === currentListeners) { 1044 nextListeners = currentListeners.slice(); 1045 } 1046 } 1047 /** 1048 * Reads the state tree managed by the store. 1049 * 1050 * @returns {any} The current state tree of your application. 1051 */ 1052 1053 1054 function getState() { 1055 if (isDispatching) { 1056 throw new Error('You may not call store.getState() while the reducer is executing. ' + 'The reducer has already received the state as an argument. ' + 'Pass it down from the top reducer instead of reading it from the store.'); 1057 } 1058 1059 return currentState; 1060 } 1061 /** 1062 * Adds a change listener. It will be called any time an action is dispatched, 1063 * and some part of the state tree may potentially have changed. You may then 1064 * call `getState()` to read the current state tree inside the callback. 1065 * 1066 * You may call `dispatch()` from a change listener, with the following 1067 * caveats: 1068 * 1069 * 1. The subscriptions are snapshotted just before every `dispatch()` call. 1070 * If you subscribe or unsubscribe while the listeners are being invoked, this 1071 * will not have any effect on the `dispatch()` that is currently in progress. 1072 * However, the next `dispatch()` call, whether nested or not, will use a more 1073 * recent snapshot of the subscription list. 1074 * 1075 * 2. The listener should not expect to see all state changes, as the state 1076 * might have been updated multiple times during a nested `dispatch()` before 1077 * the listener is called. It is, however, guaranteed that all subscribers 1078 * registered before the `dispatch()` started will be called with the latest 1079 * state by the time it exits. 1080 * 1081 * @param {Function} listener A callback to be invoked on every dispatch. 1082 * @returns {Function} A function to remove this change listener. 1083 */ 1084 1085 1086 function subscribe(listener) { 1087 if (typeof listener !== 'function') { 1088 throw new Error('Expected the listener to be a function.'); 1089 } 1090 1091 if (isDispatching) { 1092 throw new Error('You may not call store.subscribe() while the reducer is executing. ' + 'If you would like to be notified after the store has been updated, subscribe from a ' + 'component and invoke store.getState() in the callback to access the latest state. ' + 'See https://redux.js.org/api-reference/store#subscribelistener for more details.'); 1093 } 1094 1095 var isSubscribed = true; 1096 ensureCanMutateNextListeners(); 1097 nextListeners.push(listener); 1098 return function unsubscribe() { 1099 if (!isSubscribed) { 1100 return; 1101 } 1102 1103 if (isDispatching) { 1104 throw new Error('You may not unsubscribe from a store listener while the reducer is executing. ' + 'See https://redux.js.org/api-reference/store#subscribelistener for more details.'); 1105 } 1106 1107 isSubscribed = false; 1108 ensureCanMutateNextListeners(); 1109 var index = nextListeners.indexOf(listener); 1110 nextListeners.splice(index, 1); 1111 currentListeners = null; 1112 }; 1113 } 1114 /** 1115 * Dispatches an action. It is the only way to trigger a state change. 1116 * 1117 * The `reducer` function, used to create the store, will be called with the 1118 * current state tree and the given `action`. Its return value will 1119 * be considered the **next** state of the tree, and the change listeners 1120 * will be notified. 1121 * 1122 * The base implementation only supports plain object actions. If you want to 1123 * dispatch a Promise, an Observable, a thunk, or something else, you need to 1124 * wrap your store creating function into the corresponding middleware. For 1125 * example, see the documentation for the `redux-thunk` package. Even the 1126 * middleware will eventually dispatch plain object actions using this method. 1127 * 1128 * @param {Object} action A plain object representing “what changed”. It is 1129 * a good idea to keep actions serializable so you can record and replay user 1130 * sessions, or use the time travelling `redux-devtools`. An action must have 1131 * a `type` property which may not be `undefined`. It is a good idea to use 1132 * string constants for action types. 1133 * 1134 * @returns {Object} For convenience, the same action object you dispatched. 1135 * 1136 * Note that, if you use a custom middleware, it may wrap `dispatch()` to 1137 * return something else (for example, a Promise you can await). 1138 */ 1139 1140 1141 function dispatch(action) { 1142 if (!isPlainObject(action)) { 1143 throw new Error('Actions must be plain objects. ' + 'Use custom middleware for async actions.'); 1144 } 1145 1146 if (typeof action.type === 'undefined') { 1147 throw new Error('Actions may not have an undefined "type" property. ' + 'Have you misspelled a constant?'); 1148 } 1149 1150 if (isDispatching) { 1151 throw new Error('Reducers may not dispatch actions.'); 1152 } 1153 1154 try { 1155 isDispatching = true; 1156 currentState = currentReducer(currentState, action); 1157 } finally { 1158 isDispatching = false; 1159 } 1160 1161 var listeners = currentListeners = nextListeners; 1162 1163 for (var i = 0; i < listeners.length; i++) { 1164 var listener = listeners[i]; 1165 listener(); 1166 } 1167 1168 return action; 1169 } 1170 /** 1171 * Replaces the reducer currently used by the store to calculate the state. 1172 * 1173 * You might need this if your app implements code splitting and you want to 1174 * load some of the reducers dynamically. You might also need this if you 1175 * implement a hot reloading mechanism for Redux. 1176 * 1177 * @param {Function} nextReducer The reducer for the store to use instead. 1178 * @returns {void} 1179 */ 1180 1181 1182 function replaceReducer(nextReducer) { 1183 if (typeof nextReducer !== 'function') { 1184 throw new Error('Expected the nextReducer to be a function.'); 1185 } 1186 1187 currentReducer = nextReducer; // This action has a similiar effect to ActionTypes.INIT. 1188 // Any reducers that existed in both the new and old rootReducer 1189 // will receive the previous state. This effectively populates 1190 // the new state tree with any relevant data from the old one. 1191 1192 dispatch({ 1193 type: ActionTypes.REPLACE 1194 }); 1195 } 1196 /** 1197 * Interoperability point for observable/reactive libraries. 1198 * @returns {observable} A minimal observable of state changes. 1199 * For more information, see the observable proposal: 1200 * https://github.com/tc39/proposal-observable 1201 */ 1202 1203 1204 function observable() { 1205 var _ref; 1206 1207 var outerSubscribe = subscribe; 1208 return _ref = { 1209 /** 1210 * The minimal observable subscription method. 1211 * @param {Object} observer Any object that can be used as an observer. 1212 * The observer object should have a `next` method. 1213 * @returns {subscription} An object with an `unsubscribe` method that can 1214 * be used to unsubscribe the observable from the store, and prevent further 1215 * emission of values from the observable. 1216 */ 1217 subscribe: function subscribe(observer) { 1218 if (typeof observer !== 'object' || observer === null) { 1219 throw new TypeError('Expected the observer to be an object.'); 1220 } 1221 1222 function observeState() { 1223 if (observer.next) { 1224 observer.next(getState()); 1225 } 1226 } 1227 1228 observeState(); 1229 var unsubscribe = outerSubscribe(observeState); 1230 return { 1231 unsubscribe: unsubscribe 1232 }; 1233 } 1234 }, _ref[es["a" /* default */]] = function () { 1235 return this; 1236 }, _ref; 1237 } // When a store is created, an "INIT" action is dispatched so that every 1238 // reducer returns their initial state. This effectively populates 1239 // the initial state tree. 1240 1241 1242 dispatch({ 1243 type: ActionTypes.INIT 1244 }); 1245 return _ref2 = { 1246 dispatch: dispatch, 1247 subscribe: subscribe, 1248 getState: getState, 1249 replaceReducer: replaceReducer 1250 }, _ref2[es["a" /* default */]] = observable, _ref2; 1251 } 1252 1253 /** 1254 * Prints a warning in the console if it exists. 1255 * 1256 * @param {String} message The warning message. 1257 * @returns {void} 1258 */ 1259 function warning(message) { 1260 /* eslint-disable no-console */ 1261 if (typeof console !== 'undefined' && typeof console.error === 'function') { 1262 console.error(message); 1263 } 1264 /* eslint-enable no-console */ 1265 1266 1267 try { 1268 // This error was thrown as a convenience so that if you enable 1269 // "break on all exceptions" in your console, 1270 // it would pause the execution at this line. 1271 throw new Error(message); 1272 } catch (e) {} // eslint-disable-line no-empty 1273 1274 } 1275 1276 function getUndefinedStateErrorMessage(key, action) { 1277 var actionType = action && action.type; 1278 var actionDescription = actionType && "action \"" + String(actionType) + "\"" || 'an action'; 1279 return "Given " + actionDescription + ", reducer \"" + key + "\" returned undefined. " + "To ignore an action, you must explicitly return the previous state. " + "If you want this reducer to hold no value, you can return null instead of undefined."; 1280 } 1281 1282 function getUnexpectedStateShapeWarningMessage(inputState, reducers, action, unexpectedKeyCache) { 1283 var reducerKeys = Object.keys(reducers); 1284 var argumentName = action && action.type === ActionTypes.INIT ? 'preloadedState argument passed to createStore' : 'previous state received by the reducer'; 1285 1286 if (reducerKeys.length === 0) { 1287 return 'Store does not have a valid reducer. Make sure the argument passed ' + 'to combineReducers is an object whose values are reducers.'; 1288 } 1289 1290 if (!isPlainObject(inputState)) { 1291 return "The " + argumentName + " has unexpected type of \"" + {}.toString.call(inputState).match(/\s([a-z|A-Z]+)/)[1] + "\". Expected argument to be an object with the following " + ("keys: \"" + reducerKeys.join('", "') + "\""); 1292 } 1293 1294 var unexpectedKeys = Object.keys(inputState).filter(function (key) { 1295 return !reducers.hasOwnProperty(key) && !unexpectedKeyCache[key]; 1296 }); 1297 unexpectedKeys.forEach(function (key) { 1298 unexpectedKeyCache[key] = true; 1299 }); 1300 if (action && action.type === ActionTypes.REPLACE) return; 1301 1302 if (unexpectedKeys.length > 0) { 1303 return "Unexpected " + (unexpectedKeys.length > 1 ? 'keys' : 'key') + " " + ("\"" + unexpectedKeys.join('", "') + "\" found in " + argumentName + ". ") + "Expected to find one of the known reducer keys instead: " + ("\"" + reducerKeys.join('", "') + "\". Unexpected keys will be ignored."); 1304 } 1305 } 1306 1307 function assertReducerShape(reducers) { 1308 Object.keys(reducers).forEach(function (key) { 1309 var reducer = reducers[key]; 1310 var initialState = reducer(undefined, { 1311 type: ActionTypes.INIT 1312 }); 1313 1314 if (typeof initialState === 'undefined') { 1315 throw new Error("Reducer \"" + key + "\" returned undefined during initialization. " + "If the state passed to the reducer is undefined, you must " + "explicitly return the initial state. The initial state may " + "not be undefined. If you don't want to set a value for this reducer, " + "you can use null instead of undefined."); 1316 } 1317 1318 if (typeof reducer(undefined, { 1319 type: ActionTypes.PROBE_UNKNOWN_ACTION() 1320 }) === 'undefined') { 1321 throw new Error("Reducer \"" + key + "\" returned undefined when probed with a random type. " + ("Don't try to handle " + ActionTypes.INIT + " or other actions in \"redux/*\" ") + "namespace. They are considered private. Instead, you must return the " + "current state for any unknown actions, unless it is undefined, " + "in which case you must return the initial state, regardless of the " + "action type. The initial state may not be undefined, but can be null."); 1322 } 1323 }); 1324 } 1325 /** 1326 * Turns an object whose values are different reducer functions, into a single 1327 * reducer function. It will call every child reducer, and gather their results 1328 * into a single state object, whose keys correspond to the keys of the passed 1329 * reducer functions. 1330 * 1331 * @param {Object} reducers An object whose values correspond to different 1332 * reducer functions that need to be combined into one. One handy way to obtain 1333 * it is to use ES6 `import * as reducers` syntax. The reducers may never return 1334 * undefined for any action. Instead, they should return their initial state 1335 * if the state passed to them was undefined, and the current state for any 1336 * unrecognized action. 1337 * 1338 * @returns {Function} A reducer function that invokes every reducer inside the 1339 * passed object, and builds a state object with the same shape. 1340 */ 1341 1342 1343 function combineReducers(reducers) { 1344 var reducerKeys = Object.keys(reducers); 1345 var finalReducers = {}; 1346 1347 for (var i = 0; i < reducerKeys.length; i++) { 1348 var key = reducerKeys[i]; 1349 1350 if (false) {} 1351 1352 if (typeof reducers[key] === 'function') { 1353 finalReducers[key] = reducers[key]; 1354 } 1355 } 1356 1357 var finalReducerKeys = Object.keys(finalReducers); // This is used to make sure we don't warn about the same 1358 // keys multiple times. 1359 1360 var unexpectedKeyCache; 1361 1362 if (false) {} 1363 1364 var shapeAssertionError; 1365 1366 try { 1367 assertReducerShape(finalReducers); 1368 } catch (e) { 1369 shapeAssertionError = e; 1370 } 1371 1372 return function combination(state, action) { 1373 if (state === void 0) { 1374 state = {}; 1375 } 1376 1377 if (shapeAssertionError) { 1378 throw shapeAssertionError; 1379 } 1380 1381 if (false) { var warningMessage; } 1382 1383 var hasChanged = false; 1384 var nextState = {}; 1385 1386 for (var _i = 0; _i < finalReducerKeys.length; _i++) { 1387 var _key = finalReducerKeys[_i]; 1388 var reducer = finalReducers[_key]; 1389 var previousStateForKey = state[_key]; 1390 var nextStateForKey = reducer(previousStateForKey, action); 1391 1392 if (typeof nextStateForKey === 'undefined') { 1393 var errorMessage = getUndefinedStateErrorMessage(_key, action); 1394 throw new Error(errorMessage); 1395 } 1396 1397 nextState[_key] = nextStateForKey; 1398 hasChanged = hasChanged || nextStateForKey !== previousStateForKey; 1399 } 1400 1401 hasChanged = hasChanged || finalReducerKeys.length !== Object.keys(state).length; 1402 return hasChanged ? nextState : state; 1403 }; 1404 } 1405 1406 function bindActionCreator(actionCreator, dispatch) { 1407 return function () { 1408 return dispatch(actionCreator.apply(this, arguments)); 1409 }; 1410 } 1411 /** 1412 * Turns an object whose values are action creators, into an object with the 1413 * same keys, but with every function wrapped into a `dispatch` call so they 1414 * may be invoked directly. This is just a convenience method, as you can call 1415 * `store.dispatch(MyActionCreators.doSomething())` yourself just fine. 1416 * 1417 * For convenience, you can also pass an action creator as the first argument, 1418 * and get a dispatch wrapped function in return. 1419 * 1420 * @param {Function|Object} actionCreators An object whose values are action 1421 * creator functions. One handy way to obtain it is to use ES6 `import * as` 1422 * syntax. You may also pass a single function. 1423 * 1424 * @param {Function} dispatch The `dispatch` function available on your Redux 1425 * store. 1426 * 1427 * @returns {Function|Object} The object mimicking the original object, but with 1428 * every action creator wrapped into the `dispatch` call. If you passed a 1429 * function as `actionCreators`, the return value will also be a single 1430 * function. 1431 */ 1432 1433 1434 function bindActionCreators(actionCreators, dispatch) { 1435 if (typeof actionCreators === 'function') { 1436 return bindActionCreator(actionCreators, dispatch); 1437 } 1438 1439 if (typeof actionCreators !== 'object' || actionCreators === null) { 1440 throw new Error("bindActionCreators expected an object or a function, instead received " + (actionCreators === null ? 'null' : typeof actionCreators) + ". " + "Did you write \"import ActionCreators from\" instead of \"import * as ActionCreators from\"?"); 1441 } 1442 1443 var boundActionCreators = {}; 1444 1445 for (var key in actionCreators) { 1446 var actionCreator = actionCreators[key]; 1447 1448 if (typeof actionCreator === 'function') { 1449 boundActionCreators[key] = bindActionCreator(actionCreator, dispatch); 1450 } 1451 } 1452 1453 return boundActionCreators; 1454 } 1455 1456 function _defineProperty(obj, key, value) { 1457 if (key in obj) { 1458 Object.defineProperty(obj, key, { 1459 value: value, 1460 enumerable: true, 1461 configurable: true, 1462 writable: true 1463 }); 1464 } else { 1465 obj[key] = value; 1466 } 1467 1468 return obj; 1469 } 1470 1471 function ownKeys(object, enumerableOnly) { 1472 var keys = Object.keys(object); 1473 1474 if (Object.getOwnPropertySymbols) { 1475 keys.push.apply(keys, Object.getOwnPropertySymbols(object)); 1476 } 1477 1478 if (enumerableOnly) keys = keys.filter(function (sym) { 1479 return Object.getOwnPropertyDescriptor(object, sym).enumerable; 1480 }); 1481 return keys; 1482 } 1483 1484 function _objectSpread2(target) { 1485 for (var i = 1; i < arguments.length; i++) { 1486 var source = arguments[i] != null ? arguments[i] : {}; 1487 1488 if (i % 2) { 1489 ownKeys(source, true).forEach(function (key) { 1490 _defineProperty(target, key, source[key]); 1491 }); 1492 } else if (Object.getOwnPropertyDescriptors) { 1493 Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); 1494 } else { 1495 ownKeys(source).forEach(function (key) { 1496 Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); 1497 }); 1498 } 1499 } 1500 1501 return target; 1502 } 1503 1504 /** 1505 * Composes single-argument functions from right to left. The rightmost 1506 * function can take multiple arguments as it provides the signature for 1507 * the resulting composite function. 1508 * 1509 * @param {...Function} funcs The functions to compose. 1510 * @returns {Function} A function obtained by composing the argument functions 1511 * from right to left. For example, compose(f, g, h) is identical to doing 1512 * (...args) => f(g(h(...args))). 1513 */ 1514 function compose() { 1515 for (var _len = arguments.length, funcs = new Array(_len), _key = 0; _key < _len; _key++) { 1516 funcs[_key] = arguments[_key]; 1517 } 1518 1519 if (funcs.length === 0) { 1520 return function (arg) { 1521 return arg; 1522 }; 1523 } 1524 1525 if (funcs.length === 1) { 1526 return funcs[0]; 1527 } 1528 1529 return funcs.reduce(function (a, b) { 1530 return function () { 1531 return a(b.apply(void 0, arguments)); 1532 }; 1533 }); 1534 } 1535 1536 /** 1537 * Creates a store enhancer that applies middleware to the dispatch method 1538 * of the Redux store. This is handy for a variety of tasks, such as expressing 1539 * asynchronous actions in a concise manner, or logging every action payload. 1540 * 1541 * See `redux-thunk` package as an example of the Redux middleware. 1542 * 1543 * Because middleware is potentially asynchronous, this should be the first 1544 * store enhancer in the composition chain. 1545 * 1546 * Note that each middleware will be given the `dispatch` and `getState` functions 1547 * as named arguments. 1548 * 1549 * @param {...Function} middlewares The middleware chain to be applied. 1550 * @returns {Function} A store enhancer applying the middleware. 1551 */ 1552 1553 function applyMiddleware() { 1554 for (var _len = arguments.length, middlewares = new Array(_len), _key = 0; _key < _len; _key++) { 1555 middlewares[_key] = arguments[_key]; 1556 } 1557 1558 return function (createStore) { 1559 return function () { 1560 var store = createStore.apply(void 0, arguments); 1561 1562 var _dispatch = function dispatch() { 1563 throw new Error('Dispatching while constructing your middleware is not allowed. ' + 'Other middleware would not be applied to this dispatch.'); 1564 }; 1565 1566 var middlewareAPI = { 1567 getState: store.getState, 1568 dispatch: function dispatch() { 1569 return _dispatch.apply(void 0, arguments); 1570 } 1571 }; 1572 var chain = middlewares.map(function (middleware) { 1573 return middleware(middlewareAPI); 1574 }); 1575 _dispatch = compose.apply(void 0, chain)(store.dispatch); 1576 return _objectSpread2({}, store, { 1577 dispatch: _dispatch 1578 }); 1579 }; 1580 }; 1581 } 1582 1583 /* 1584 * This is a dummy function to check if the function name has been altered by minification. 1585 * If the function has been minified and NODE_ENV !== 'production', warn the user. 1586 */ 1587 1588 function isCrushed() {} 1589 1590 if (false) {} 1591 1592 1593 1594 // EXTERNAL MODULE: ./node_modules/equivalent-key-map/equivalent-key-map.js 1595 var equivalent_key_map = __webpack_require__(104); 1596 var equivalent_key_map_default = /*#__PURE__*/__webpack_require__.n(equivalent_key_map); 1597 1598 // EXTERNAL MODULE: external ["wp","reduxRoutine"] 1599 var external_wp_reduxRoutine_ = __webpack_require__(291); 1600 var external_wp_reduxRoutine_default = /*#__PURE__*/__webpack_require__.n(external_wp_reduxRoutine_); 1601 1602 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + 2 modules 1603 var toConsumableArray = __webpack_require__(15); 1604 1605 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/factory.js 1606 /** 1607 * Creates a selector function that takes additional curried argument with the 1608 * registry `select` function. While a regular selector has signature 1609 * ```js 1610 * ( state, ...selectorArgs ) => ( result ) 1611 * ``` 1612 * that allows to select data from the store's `state`, a registry selector 1613 * has signature: 1614 * ```js 1615 * ( select ) => ( state, ...selectorArgs ) => ( result ) 1616 * ``` 1617 * that supports also selecting from other registered stores. 1618 * 1619 * @example 1620 * ```js 1621 * const getCurrentPostId = createRegistrySelector( ( select ) => ( state ) => { 1622 * return select( 'core/editor' ).getCurrentPostId(); 1623 * } ); 1624 * 1625 * const getPostEdits = createRegistrySelector( ( select ) => ( state ) => { 1626 * // calling another registry selector just like any other function 1627 * const postType = getCurrentPostType( state ); 1628 * const postId = getCurrentPostId( state ); 1629 * return select( 'core' ).getEntityRecordEdits( 'postType', postType, postId ); 1630 * } ); 1631 * ``` 1632 * 1633 * Note how the `getCurrentPostId` selector can be called just like any other function, 1634 * (it works even inside a regular non-registry selector) and we don't need to pass the 1635 * registry as argument. The registry binding happens automatically when registering the selector 1636 * with a store. 1637 * 1638 * @param {Function} registrySelector Function receiving a registry `select` 1639 * function and returning a state selector. 1640 * 1641 * @return {Function} Registry selector that can be registered with a store. 1642 */ 1643 function createRegistrySelector(registrySelector) { 1644 // create a selector function that is bound to the registry referenced by `selector.registry` 1645 // and that has the same API as a regular selector. Binding it in such a way makes it 1646 // possible to call the selector directly from another selector. 1647 var selector = function selector() { 1648 return registrySelector(selector.registry.select).apply(void 0, arguments); 1649 }; 1650 /** 1651 * Flag indicating that the selector is a registry selector that needs the correct registry 1652 * reference to be assigned to `selecto.registry` to make it work correctly. 1653 * be mapped as a registry selector. 1654 * 1655 * @type {boolean} 1656 */ 1657 1658 1659 selector.isRegistrySelector = true; 1660 return selector; 1661 } 1662 /** 1663 * Creates a control function that takes additional curried argument with the `registry` object. 1664 * While a regular control has signature 1665 * ```js 1666 * ( action ) => ( iteratorOrPromise ) 1667 * ``` 1668 * where the control works with the `action` that it's bound to, a registry control has signature: 1669 * ```js 1670 * ( registry ) => ( action ) => ( iteratorOrPromise ) 1671 * ``` 1672 * A registry control is typically used to select data or dispatch an action to a registered 1673 * store. 1674 * 1675 * When registering a control created with `createRegistryControl` with a store, the store 1676 * knows which calling convention to use when executing the control. 1677 * 1678 * @param {Function} registryControl Function receiving a registry object and returning a control. 1679 * 1680 * @return {Function} Registry control that can be registered with a store. 1681 */ 1682 1683 function createRegistryControl(registryControl) { 1684 registryControl.isRegistryControl = true; 1685 return registryControl; 1686 } 1687 1688 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/controls.js 1689 1690 1691 1692 var _builtinControls; 1693 1694 /** 1695 * Internal dependencies 1696 */ 1697 1698 var SELECT = '@@data/SELECT'; 1699 var RESOLVE_SELECT = '@@data/RESOLVE_SELECT'; 1700 var DISPATCH = '@@data/DISPATCH'; 1701 /** 1702 * Dispatches a control action for triggering a synchronous registry select. 1703 * 1704 * Note: This control synchronously returns the current selector value, triggering the 1705 * resolution, but not waiting for it. 1706 * 1707 * @param {string} storeKey The key for the store the selector belongs to. 1708 * @param {string} selectorName The name of the selector. 1709 * @param {Array} args Arguments for the selector. 1710 * 1711 * @example 1712 * ```js 1713 * import { controls } from '@wordpress/data'; 1714 * 1715 * // Action generator using `select`. 1716 * export function* myAction() { 1717 * const isEditorSideBarOpened = yield controls.select( 'core/edit-post', 'isEditorSideBarOpened' ); 1718 * // Do stuff with the result from the `select`. 1719 * } 1720 * ``` 1721 * 1722 * @return {Object} The control descriptor. 1723 */ 1724 1725 function controls_select(storeKey, selectorName) { 1726 for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) { 1727 args[_key - 2] = arguments[_key]; 1728 } 1729 1730 return { 1731 type: SELECT, 1732 storeKey: storeKey, 1733 selectorName: selectorName, 1734 args: args 1735 }; 1736 } 1737 /** 1738 * Dispatches a control action for triggering and resolving a registry select. 1739 * 1740 * Note: when this control action is handled, it automatically considers 1741 * selectors that may have a resolver. In such case, it will return a `Promise` that resolves 1742 * after the selector finishes resolving, with the final result value. 1743 * 1744 * @param {string} storeKey The key for the store the selector belongs to 1745 * @param {string} selectorName The name of the selector 1746 * @param {Array} args Arguments for the selector. 1747 * 1748 * @example 1749 * ```js 1750 * import { controls } from '@wordpress/data'; 1751 * 1752 * // Action generator using resolveSelect 1753 * export function* myAction() { 1754 * const isSidebarOpened = yield controls.resolveSelect( 'core/edit-post', 'isEditorSideBarOpened' ); 1755 * // do stuff with the result from the select. 1756 * } 1757 * ``` 1758 * 1759 * @return {Object} The control descriptor. 1760 */ 1761 1762 1763 function resolveSelect(storeKey, selectorName) { 1764 for (var _len2 = arguments.length, args = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) { 1765 args[_key2 - 2] = arguments[_key2]; 1766 } 1767 1768 return { 1769 type: RESOLVE_SELECT, 1770 storeKey: storeKey, 1771 selectorName: selectorName, 1772 args: args 1773 }; 1774 } 1775 /** 1776 * Dispatches a control action for triggering a registry dispatch. 1777 * 1778 * @param {string} storeKey The key for the store the action belongs to 1779 * @param {string} actionName The name of the action to dispatch 1780 * @param {Array} args Arguments for the dispatch action. 1781 * 1782 * @example 1783 * ```js 1784 * import { controls } from '@wordpress/data-controls'; 1785 * 1786 * // Action generator using dispatch 1787 * export function* myAction() { 1788 * yield controls.dispatch( 'core/edit-post', 'togglePublishSidebar' ); 1789 * // do some other things. 1790 * } 1791 * ``` 1792 * 1793 * @return {Object} The control descriptor. 1794 */ 1795 1796 1797 function controls_dispatch(storeKey, actionName) { 1798 for (var _len3 = arguments.length, args = new Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) { 1799 args[_key3 - 2] = arguments[_key3]; 1800 } 1801 1802 return { 1803 type: DISPATCH, 1804 storeKey: storeKey, 1805 actionName: actionName, 1806 args: args 1807 }; 1808 } 1809 1810 var controls_controls = { 1811 select: controls_select, 1812 resolveSelect: resolveSelect, 1813 dispatch: controls_dispatch 1814 }; 1815 var builtinControls = (_builtinControls = {}, Object(defineProperty["a" /* default */])(_builtinControls, SELECT, createRegistryControl(function (registry) { 1816 return function (_ref) { 1817 var _registry$select; 1818 1819 var storeKey = _ref.storeKey, 1820 selectorName = _ref.selectorName, 1821 args = _ref.args; 1822 return (_registry$select = registry.select(storeKey))[selectorName].apply(_registry$select, Object(toConsumableArray["a" /* default */])(args)); 1823 }; 1824 })), Object(defineProperty["a" /* default */])(_builtinControls, RESOLVE_SELECT, createRegistryControl(function (registry) { 1825 return function (_ref2) { 1826 var _registry$method; 1827 1828 var storeKey = _ref2.storeKey, 1829 selectorName = _ref2.selectorName, 1830 args = _ref2.args; 1831 var method = registry.select(storeKey)[selectorName].hasResolver ? '__experimentalResolveSelect' : 'select'; 1832 return (_registry$method = registry[method](storeKey))[selectorName].apply(_registry$method, Object(toConsumableArray["a" /* default */])(args)); 1833 }; 1834 })), Object(defineProperty["a" /* default */])(_builtinControls, DISPATCH, createRegistryControl(function (registry) { 1835 return function (_ref3) { 1836 var _registry$dispatch; 1837 1838 var storeKey = _ref3.storeKey, 1839 actionName = _ref3.actionName, 1840 args = _ref3.args; 1841 return (_registry$dispatch = registry.dispatch(storeKey))[actionName].apply(_registry$dispatch, Object(toConsumableArray["a" /* default */])(args)); 1842 }; 1843 })), _builtinControls); 1844 1845 // EXTERNAL MODULE: ./node_modules/is-promise/index.js 1846 var is_promise = __webpack_require__(153); 1847 var is_promise_default = /*#__PURE__*/__webpack_require__.n(is_promise); 1848 1849 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/promise-middleware.js 1850 /** 1851 * External dependencies 1852 */ 1853 1854 /** 1855 * Simplest possible promise redux middleware. 1856 * 1857 * @return {Function} middleware. 1858 */ 1859 1860 var promise_middleware_promiseMiddleware = function promiseMiddleware() { 1861 return function (next) { 1862 return function (action) { 1863 if (is_promise_default()(action)) { 1864 return action.then(function (resolvedAction) { 1865 if (resolvedAction) { 1866 return next(resolvedAction); 1867 } 1868 }); 1869 } 1870 1871 return next(action); 1872 }; 1873 }; 1874 }; 1875 1876 /* harmony default export */ var promise_middleware = (promise_middleware_promiseMiddleware); 1877 1878 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/resolvers-cache-middleware.js 1879 1880 1881 1882 /** 1883 * External dependencies 1884 */ 1885 1886 /** @typedef {import('./registry').WPDataRegistry} WPDataRegistry */ 1887 1888 /** 1889 * Creates a middleware handling resolvers cache invalidation. 1890 * 1891 * @param {WPDataRegistry} registry The registry reference for which to create 1892 * the middleware. 1893 * @param {string} reducerKey The namespace for which to create the 1894 * middleware. 1895 * 1896 * @return {Function} Middleware function. 1897 */ 1898 1899 var resolvers_cache_middleware_createResolversCacheMiddleware = function createResolversCacheMiddleware(registry, reducerKey) { 1900 return function () { 1901 return function (next) { 1902 return function (action) { 1903 var resolvers = registry.select('core/data').getCachedResolvers(reducerKey); 1904 Object.entries(resolvers).forEach(function (_ref) { 1905 var _ref2 = Object(slicedToArray["a" /* default */])(_ref, 2), 1906 selectorName = _ref2[0], 1907 resolversByArgs = _ref2[1]; 1908 1909 var resolver = Object(external_lodash_["get"])(registry.stores, [reducerKey, 'resolvers', selectorName]); 1910 1911 if (!resolver || !resolver.shouldInvalidate) { 1912 return; 1913 } 1914 1915 resolversByArgs.forEach(function (value, args) { 1916 // resolversByArgs is the map Map([ args ] => boolean) storing the cache resolution status for a given selector. 1917 // If the value is false it means this resolver has finished its resolution which means we need to invalidate it, 1918 // if it's true it means it's inflight and the invalidation is not necessary. 1919 if (value !== false || !resolver.shouldInvalidate.apply(resolver, [action].concat(Object(toConsumableArray["a" /* default */])(args)))) { 1920 return; 1921 } // Trigger cache invalidation 1922 1923 1924 registry.dispatch('core/data').invalidateResolution(reducerKey, selectorName, args); 1925 }); 1926 }); 1927 return next(action); 1928 }; 1929 }; 1930 }; 1931 }; 1932 1933 /* harmony default export */ var resolvers_cache_middleware = (resolvers_cache_middleware_createResolversCacheMiddleware); 1934 1935 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/redux-store/thunk-middleware.js 1936 function createThunkMiddleware(args) { 1937 return function () { 1938 return function (next) { 1939 return function (action) { 1940 if (typeof action === 'function') { 1941 return action(args); 1942 } 1943 1944 return next(action); 1945 }; 1946 }; 1947 }; 1948 } 1949 1950 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/redux-store/metadata/utils.js 1951 1952 1953 function utils_ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } 1954 1955 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { utils_ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { utils_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } 1956 1957 /** 1958 * Higher-order reducer creator which creates a combined reducer object, keyed 1959 * by a property on the action object. 1960 * 1961 * @param {string} actionProperty Action property by which to key object. 1962 * 1963 * @return {Function} Higher-order reducer. 1964 */ 1965 var utils_onSubKey = function onSubKey(actionProperty) { 1966 return function (reducer) { 1967 return function () { 1968 var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 1969 var action = arguments.length > 1 ? arguments[1] : undefined; 1970 // Retrieve subkey from action. Do not track if undefined; useful for cases 1971 // where reducer is scoped by action shape. 1972 var key = action[actionProperty]; 1973 1974 if (key === undefined) { 1975 return state; 1976 } // Avoid updating state if unchanged. Note that this also accounts for a 1977 // reducer which returns undefined on a key which is not yet tracked. 1978 1979 1980 var nextKeyState = reducer(state[key], action); 1981 1982 if (nextKeyState === state[key]) { 1983 return state; 1984 } 1985 1986 return _objectSpread(_objectSpread({}, state), {}, Object(defineProperty["a" /* default */])({}, key, nextKeyState)); 1987 }; 1988 }; 1989 }; 1990 1991 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/redux-store/metadata/reducer.js 1992 /** 1993 * External dependencies 1994 */ 1995 1996 1997 /** 1998 * Internal dependencies 1999 */ 2000 2001 2002 /** 2003 * Reducer function returning next state for selector resolution of 2004 * subkeys, object form: 2005 * 2006 * selectorName -> EquivalentKeyMap<Array,boolean> 2007 * 2008 * @param {Object} state Current state. 2009 * @param {Object} action Dispatched action. 2010 * 2011 * @return {Object} Next state. 2012 */ 2013 2014 var subKeysIsResolved = utils_onSubKey('selectorName')(function () { 2015 var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new equivalent_key_map_default.a(); 2016 var action = arguments.length > 1 ? arguments[1] : undefined; 2017 2018 switch (action.type) { 2019 case 'START_RESOLUTION': 2020 case 'FINISH_RESOLUTION': 2021 { 2022 var isStarting = action.type === 'START_RESOLUTION'; 2023 var nextState = new equivalent_key_map_default.a(state); 2024 nextState.set(action.args, isStarting); 2025 return nextState; 2026 } 2027 2028 case 'INVALIDATE_RESOLUTION': 2029 { 2030 var _nextState = new equivalent_key_map_default.a(state); 2031 2032 _nextState.delete(action.args); 2033 2034 return _nextState; 2035 } 2036 } 2037 2038 return state; 2039 }); 2040 /** 2041 * Reducer function returning next state for selector resolution, object form: 2042 * 2043 * selectorName -> EquivalentKeyMap<Array, boolean> 2044 * 2045 * @param {Object} state Current state. 2046 * @param {Object} action Dispatched action. 2047 * 2048 * @return {Object} Next state. 2049 */ 2050 2051 var reducer_isResolved = function isResolved() { 2052 var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 2053 var action = arguments.length > 1 ? arguments[1] : undefined; 2054 2055 switch (action.type) { 2056 case 'INVALIDATE_RESOLUTION_FOR_STORE': 2057 return {}; 2058 2059 case 'INVALIDATE_RESOLUTION_FOR_STORE_SELECTOR': 2060 return Object(external_lodash_["has"])(state, [action.selectorName]) ? Object(external_lodash_["omit"])(state, [action.selectorName]) : state; 2061 2062 case 'START_RESOLUTION': 2063 case 'FINISH_RESOLUTION': 2064 case 'INVALIDATE_RESOLUTION': 2065 return subKeysIsResolved(state, action); 2066 } 2067 2068 return state; 2069 }; 2070 2071 /* harmony default export */ var metadata_reducer = (reducer_isResolved); 2072 2073 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/redux-store/metadata/selectors.js 2074 /** 2075 * External dependencies 2076 */ 2077 2078 /** 2079 * Returns the raw `isResolving` value for a given selector name, 2080 * and arguments set. May be undefined if the selector has never been resolved 2081 * or not resolved for the given set of arguments, otherwise true or false for 2082 * resolution started and completed respectively. 2083 * 2084 * @param {Object} state Data state. 2085 * @param {string} selectorName Selector name. 2086 * @param {Array} args Arguments passed to selector. 2087 * 2088 * @return {?boolean} isResolving value. 2089 */ 2090 2091 function getIsResolving(state, selectorName, args) { 2092 var map = Object(external_lodash_["get"])(state, [selectorName]); 2093 2094 if (!map) { 2095 return; 2096 } 2097 2098 return map.get(args); 2099 } 2100 /** 2101 * Returns true if resolution has already been triggered for a given 2102 * selector name, and arguments set. 2103 * 2104 * @param {Object} state Data state. 2105 * @param {string} selectorName Selector name. 2106 * @param {?Array} args Arguments passed to selector (default `[]`). 2107 * 2108 * @return {boolean} Whether resolution has been triggered. 2109 */ 2110 2111 function hasStartedResolution(state, selectorName) { 2112 var args = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : []; 2113 return getIsResolving(state, selectorName, args) !== undefined; 2114 } 2115 /** 2116 * Returns true if resolution has completed for a given selector 2117 * name, and arguments set. 2118 * 2119 * @param {Object} state Data state. 2120 * @param {string} selectorName Selector name. 2121 * @param {?Array} args Arguments passed to selector. 2122 * 2123 * @return {boolean} Whether resolution has completed. 2124 */ 2125 2126 function hasFinishedResolution(state, selectorName) { 2127 var args = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : []; 2128 return getIsResolving(state, selectorName, args) === false; 2129 } 2130 /** 2131 * Returns true if resolution has been triggered but has not yet completed for 2132 * a given selector name, and arguments set. 2133 * 2134 * @param {Object} state Data state. 2135 * @param {string} selectorName Selector name. 2136 * @param {?Array} args Arguments passed to selector. 2137 * 2138 * @return {boolean} Whether resolution is in progress. 2139 */ 2140 2141 function isResolving(state, selectorName) { 2142 var args = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : []; 2143 return getIsResolving(state, selectorName, args) === true; 2144 } 2145 /** 2146 * Returns the list of the cached resolvers. 2147 * 2148 * @param {Object} state Data state. 2149 * 2150 * @return {Object} Resolvers mapped by args and selectorName. 2151 */ 2152 2153 function getCachedResolvers(state) { 2154 return state; 2155 } 2156 2157 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/redux-store/metadata/actions.js 2158 /** 2159 * Returns an action object used in signalling that selector resolution has 2160 * started. 2161 * 2162 * @param {string} selectorName Name of selector for which resolver triggered. 2163 * @param {...*} args Arguments to associate for uniqueness. 2164 * 2165 * @return {Object} Action object. 2166 */ 2167 function startResolution(selectorName, args) { 2168 return { 2169 type: 'START_RESOLUTION', 2170 selectorName: selectorName, 2171 args: args 2172 }; 2173 } 2174 /** 2175 * Returns an action object used in signalling that selector resolution has 2176 * completed. 2177 * 2178 * @param {string} selectorName Name of selector for which resolver triggered. 2179 * @param {...*} args Arguments to associate for uniqueness. 2180 * 2181 * @return {Object} Action object. 2182 */ 2183 2184 function finishResolution(selectorName, args) { 2185 return { 2186 type: 'FINISH_RESOLUTION', 2187 selectorName: selectorName, 2188 args: args 2189 }; 2190 } 2191 /** 2192 * Returns an action object used in signalling that we should invalidate the resolution cache. 2193 * 2194 * @param {string} selectorName Name of selector for which resolver should be invalidated. 2195 * @param {Array} args Arguments to associate for uniqueness. 2196 * 2197 * @return {Object} Action object. 2198 */ 2199 2200 function invalidateResolution(selectorName, args) { 2201 return { 2202 type: 'INVALIDATE_RESOLUTION', 2203 selectorName: selectorName, 2204 args: args 2205 }; 2206 } 2207 /** 2208 * Returns an action object used in signalling that the resolution 2209 * should be invalidated. 2210 * 2211 * @return {Object} Action object. 2212 */ 2213 2214 function invalidateResolutionForStore() { 2215 return { 2216 type: 'INVALIDATE_RESOLUTION_FOR_STORE' 2217 }; 2218 } 2219 /** 2220 * Returns an action object used in signalling that the resolution cache for a 2221 * given selectorName should be invalidated. 2222 * 2223 * @param {string} selectorName Name of selector for which all resolvers should 2224 * be invalidated. 2225 * 2226 * @return {Object} Action object. 2227 */ 2228 2229 function invalidateResolutionForStoreSelector(selectorName) { 2230 return { 2231 type: 'INVALIDATE_RESOLUTION_FOR_STORE_SELECTOR', 2232 selectorName: selectorName 2233 }; 2234 } 2235 2236 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/redux-store/index.js 2237 2238 2239 2240 2241 function redux_store_ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } 2242 2243 function redux_store_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { redux_store_ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { redux_store_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } 2244 2245 /** 2246 * External dependencies 2247 */ 2248 2249 2250 2251 2252 /** 2253 * WordPress dependencies 2254 */ 2255 2256 2257 /** 2258 * Internal dependencies 2259 */ 2260 2261 2262 2263 2264 2265 2266 2267 2268 /** @typedef {import('../types').WPDataRegistry} WPDataRegistry */ 2269 2270 /** @typedef {import('../types').WPDataStore} WPDataStore */ 2271 2272 /** @typedef {import('../types').WPDataReduxStoreConfig} WPDataReduxStoreConfig */ 2273 2274 /** 2275 * Create a cache to track whether resolvers started running or not. 2276 * 2277 * @return {Object} Resolvers Cache. 2278 */ 2279 2280 function createResolversCache() { 2281 var cache = {}; 2282 return { 2283 isRunning: function isRunning(selectorName, args) { 2284 return cache[selectorName] && cache[selectorName].get(args); 2285 }, 2286 clear: function clear(selectorName, args) { 2287 if (cache[selectorName]) { 2288 cache[selectorName].delete(args); 2289 } 2290 }, 2291 markAsRunning: function markAsRunning(selectorName, args) { 2292 if (!cache[selectorName]) { 2293 cache[selectorName] = new equivalent_key_map_default.a(); 2294 } 2295 2296 cache[selectorName].set(args, true); 2297 } 2298 }; 2299 } 2300 /** 2301 * Creates a data store definition for the provided Redux store options containing 2302 * properties describing reducer, actions, selectors, controls and resolvers. 2303 * 2304 * @example 2305 * ```js 2306 * import { createReduxStore } from '@wordpress/data'; 2307 * 2308 * const store = createReduxStore( 'demo', { 2309 * reducer: ( state = 'OK' ) => state, 2310 * selectors: { 2311 * getValue: ( state ) => state, 2312 * }, 2313 * } ); 2314 * ``` 2315 * 2316 * @param {string} key Unique namespace identifier. 2317 * @param {WPDataReduxStoreConfig} options Registered store options, with properties 2318 * describing reducer, actions, selectors, 2319 * and resolvers. 2320 * 2321 * @return {WPDataStore} Store Object. 2322 */ 2323 2324 2325 function createReduxStore(key, options) { 2326 return { 2327 name: key, 2328 instantiate: function instantiate(registry) { 2329 var reducer = options.reducer; 2330 var thunkArgs = { 2331 registry: registry, 2332 2333 get dispatch() { 2334 return Object.assign(function (action) { 2335 return store.dispatch(action); 2336 }, getActions()); 2337 }, 2338 2339 get select() { 2340 return Object.assign(function (selector) { 2341 return selector(store.__unstableOriginalGetState()); 2342 }, getSelectors()); 2343 }, 2344 2345 get resolveSelect() { 2346 return getResolveSelectors(); 2347 } 2348 2349 }; 2350 var store = instantiateReduxStore(key, options, registry, thunkArgs); 2351 var resolversCache = createResolversCache(); 2352 var resolvers; 2353 var actions = mapActions(redux_store_objectSpread(redux_store_objectSpread({}, actions_namespaceObject), options.actions), store); 2354 var selectors = mapSelectors(redux_store_objectSpread(redux_store_objectSpread({}, Object(external_lodash_["mapValues"])(selectors_namespaceObject, function (selector) { 2355 return function (state) { 2356 for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { 2357 args[_key - 1] = arguments[_key]; 2358 } 2359 2360 return selector.apply(void 0, [state.metadata].concat(args)); 2361 }; 2362 })), Object(external_lodash_["mapValues"])(options.selectors, function (selector) { 2363 if (selector.isRegistrySelector) { 2364 selector.registry = registry; 2365 } 2366 2367 return function (state) { 2368 for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { 2369 args[_key2 - 1] = arguments[_key2]; 2370 } 2371 2372 return selector.apply(void 0, [state.root].concat(args)); 2373 }; 2374 })), store); 2375 2376 if (options.resolvers) { 2377 var result = mapResolvers(options.resolvers, selectors, store, resolversCache); 2378 resolvers = result.resolvers; 2379 selectors = result.selectors; 2380 } 2381 2382 var getSelectors = function getSelectors() { 2383 return selectors; 2384 }; 2385 2386 var getActions = function getActions() { 2387 return actions; 2388 }; 2389 2390 var getResolveSelectors = function getResolveSelectors() { 2391 return mapResolveSelectors(selectors, store); 2392 }; // We have some modules monkey-patching the store object 2393 // It's wrong to do so but until we refactor all of our effects to controls 2394 // We need to keep the same "store" instance here. 2395 2396 2397 store.__unstableOriginalGetState = store.getState; 2398 2399 store.getState = function () { 2400 return store.__unstableOriginalGetState().root; 2401 }; // Customize subscribe behavior to call listeners only on effective change, 2402 // not on every dispatch. 2403 2404 2405 var subscribe = store && function (listener) { 2406 var lastState = store.__unstableOriginalGetState(); 2407 2408 return store.subscribe(function () { 2409 var state = store.__unstableOriginalGetState(); 2410 2411 var hasChanged = state !== lastState; 2412 lastState = state; 2413 2414 if (hasChanged) { 2415 listener(); 2416 } 2417 }); 2418 }; // This can be simplified to just { subscribe, getSelectors, getActions } 2419 // Once we remove the use function. 2420 2421 2422 return { 2423 reducer: reducer, 2424 store: store, 2425 actions: actions, 2426 selectors: selectors, 2427 resolvers: resolvers, 2428 getSelectors: getSelectors, 2429 __experimentalGetResolveSelectors: getResolveSelectors, 2430 getActions: getActions, 2431 subscribe: subscribe 2432 }; 2433 } 2434 }; 2435 } 2436 /** 2437 * Creates a redux store for a namespace. 2438 * 2439 * @param {string} key Unique namespace identifier. 2440 * @param {Object} options Registered store options, with properties 2441 * describing reducer, actions, selectors, 2442 * and resolvers. 2443 * @param {WPDataRegistry} registry Registry reference. 2444 * @param {Object} thunkArgs Argument object for the thunk middleware. 2445 * @return {Object} Newly created redux store. 2446 */ 2447 2448 function instantiateReduxStore(key, options, registry, thunkArgs) { 2449 var controls = redux_store_objectSpread(redux_store_objectSpread({}, options.controls), builtinControls); 2450 2451 var normalizedControls = Object(external_lodash_["mapValues"])(controls, function (control) { 2452 return control.isRegistryControl ? control(registry) : control; 2453 }); 2454 var middlewares = [resolvers_cache_middleware(registry, key), promise_middleware, external_wp_reduxRoutine_default()(normalizedControls)]; 2455 2456 if (options.__experimentalUseThunks) { 2457 middlewares.push(createThunkMiddleware(thunkArgs)); 2458 } 2459 2460 var enhancers = [applyMiddleware.apply(void 0, middlewares)]; 2461 2462 if (typeof window !== 'undefined' && window.__REDUX_DEVTOOLS_EXTENSION__) { 2463 enhancers.push(window.__REDUX_DEVTOOLS_EXTENSION__({ 2464 name: key, 2465 instanceId: key 2466 })); 2467 } 2468 2469 var reducer = options.reducer, 2470 initialState = options.initialState; 2471 var enhancedReducer = turbo_combine_reducers_default()({ 2472 metadata: metadata_reducer, 2473 root: reducer 2474 }); 2475 return createStore(enhancedReducer, { 2476 root: initialState 2477 }, Object(external_lodash_["flowRight"])(enhancers)); 2478 } 2479 /** 2480 * Maps selectors to a store. 2481 * 2482 * @param {Object} selectors Selectors to register. Keys will be used as the 2483 * public facing API. Selectors will get passed the 2484 * state as first argument. 2485 * @param {Object} store The store to which the selectors should be mapped. 2486 * @return {Object} Selectors mapped to the provided store. 2487 */ 2488 2489 2490 function mapSelectors(selectors, store) { 2491 var createStateSelector = function createStateSelector(registrySelector) { 2492 var selector = function runSelector() { 2493 // This function is an optimized implementation of: 2494 // 2495 // selector( store.getState(), ...arguments ) 2496 // 2497 // Where the above would incur an `Array#concat` in its application, 2498 // the logic here instead efficiently constructs an arguments array via 2499 // direct assignment. 2500 var argsLength = arguments.length; 2501 var args = new Array(argsLength + 1); 2502 args[0] = store.__unstableOriginalGetState(); 2503 2504 for (var i = 0; i < argsLength; i++) { 2505 args[i + 1] = arguments[i]; 2506 } 2507 2508 return registrySelector.apply(void 0, args); 2509 }; 2510 2511 selector.hasResolver = false; 2512 return selector; 2513 }; 2514 2515 return Object(external_lodash_["mapValues"])(selectors, createStateSelector); 2516 } 2517 /** 2518 * Maps actions to dispatch from a given store. 2519 * 2520 * @param {Object} actions Actions to register. 2521 * @param {Object} store The redux store to which the actions should be mapped. 2522 * @return {Object} Actions mapped to the redux store provided. 2523 */ 2524 2525 2526 function mapActions(actions, store) { 2527 var createBoundAction = function createBoundAction(action) { 2528 return function () { 2529 return Promise.resolve(store.dispatch(action.apply(void 0, arguments))); 2530 }; 2531 }; 2532 2533 return Object(external_lodash_["mapValues"])(actions, createBoundAction); 2534 } 2535 /** 2536 * Maps selectors to functions that return a resolution promise for them 2537 * 2538 * @param {Object} selectors Selectors to map. 2539 * @param {Object} store The redux store the selectors select from. 2540 * @return {Object} Selectors mapped to their resolution functions. 2541 */ 2542 2543 2544 function mapResolveSelectors(selectors, store) { 2545 return Object(external_lodash_["mapValues"])(Object(external_lodash_["omit"])(selectors, ['getIsResolving', 'hasStartedResolution', 'hasFinishedResolution', 'isResolving', 'getCachedResolvers']), function (selector, selectorName) { 2546 return function () { 2547 for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { 2548 args[_key3] = arguments[_key3]; 2549 } 2550 2551 return new Promise(function (resolve) { 2552 var hasFinished = function hasFinished() { 2553 return selectors.hasFinishedResolution(selectorName, args); 2554 }; 2555 2556 var getResult = function getResult() { 2557 return selector.apply(null, args); 2558 }; // trigger the selector (to trigger the resolver) 2559 2560 2561 var result = getResult(); 2562 2563 if (hasFinished()) { 2564 return resolve(result); 2565 } 2566 2567 var unsubscribe = store.subscribe(function () { 2568 if (hasFinished()) { 2569 unsubscribe(); 2570 resolve(getResult()); 2571 } 2572 }); 2573 }); 2574 }; 2575 }); 2576 } 2577 /** 2578 * Returns resolvers with matched selectors for a given namespace. 2579 * Resolvers are side effects invoked once per argument set of a given selector call, 2580 * used in ensuring that the data needs for the selector are satisfied. 2581 * 2582 * @param {Object} resolvers Resolvers to register. 2583 * @param {Object} selectors The current selectors to be modified. 2584 * @param {Object} store The redux store to which the resolvers should be mapped. 2585 * @param {Object} resolversCache Resolvers Cache. 2586 */ 2587 2588 2589 function mapResolvers(resolvers, selectors, store, resolversCache) { 2590 // The `resolver` can be either a function that does the resolution, or, in more advanced 2591 // cases, an object with a `fullfill` method and other optional methods like `isFulfilled`. 2592 // Here we normalize the `resolver` function to an object with `fulfill` method. 2593 var mappedResolvers = Object(external_lodash_["mapValues"])(resolvers, function (resolver) { 2594 if (resolver.fulfill) { 2595 return resolver; 2596 } 2597 2598 return redux_store_objectSpread(redux_store_objectSpread({}, resolver), {}, { 2599 // copy the enumerable properties of the resolver function 2600 fulfill: resolver // add the fulfill method 2601 2602 }); 2603 }); 2604 2605 var mapSelector = function mapSelector(selector, selectorName) { 2606 var resolver = resolvers[selectorName]; 2607 2608 if (!resolver) { 2609 selector.hasResolver = false; 2610 return selector; 2611 } 2612 2613 var selectorResolver = function selectorResolver() { 2614 for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) { 2615 args[_key4] = arguments[_key4]; 2616 } 2617 2618 function fulfillSelector() { 2619 return _fulfillSelector.apply(this, arguments); 2620 } 2621 2622 function _fulfillSelector() { 2623 _fulfillSelector = Object(asyncToGenerator["a" /* default */])( /*#__PURE__*/external_regeneratorRuntime_default.a.mark(function _callee2() { 2624 var state, _store$__unstableOrig, metadata; 2625 2626 return external_regeneratorRuntime_default.a.wrap(function _callee2$(_context2) { 2627 while (1) { 2628 switch (_context2.prev = _context2.next) { 2629 case 0: 2630 state = store.getState(); 2631 2632 if (!(resolversCache.isRunning(selectorName, args) || typeof resolver.isFulfilled === 'function' && resolver.isFulfilled.apply(resolver, [state].concat(args)))) { 2633 _context2.next = 3; 2634 break; 2635 } 2636 2637 return _context2.abrupt("return"); 2638 2639 case 3: 2640 _store$__unstableOrig = store.__unstableOriginalGetState(), metadata = _store$__unstableOrig.metadata; 2641 2642 if (!hasStartedResolution(metadata, selectorName, args)) { 2643 _context2.next = 6; 2644 break; 2645 } 2646 2647 return _context2.abrupt("return"); 2648 2649 case 6: 2650 resolversCache.markAsRunning(selectorName, args); 2651 setTimeout( /*#__PURE__*/Object(asyncToGenerator["a" /* default */])( /*#__PURE__*/external_regeneratorRuntime_default.a.mark(function _callee() { 2652 return external_regeneratorRuntime_default.a.wrap(function _callee$(_context) { 2653 while (1) { 2654 switch (_context.prev = _context.next) { 2655 case 0: 2656 resolversCache.clear(selectorName, args); 2657 store.dispatch(startResolution(selectorName, args)); 2658 _context.next = 4; 2659 return fulfillResolver.apply(void 0, [store, mappedResolvers, selectorName].concat(args)); 2660 2661 case 4: 2662 store.dispatch(finishResolution(selectorName, args)); 2663 2664 case 5: 2665 case "end": 2666 return _context.stop(); 2667 } 2668 } 2669 }, _callee); 2670 }))); 2671 2672 case 8: 2673 case "end": 2674 return _context2.stop(); 2675 } 2676 } 2677 }, _callee2); 2678 })); 2679 return _fulfillSelector.apply(this, arguments); 2680 } 2681 2682 fulfillSelector.apply(void 0, args); 2683 return selector.apply(void 0, args); 2684 }; 2685 2686 selectorResolver.hasResolver = true; 2687 return selectorResolver; 2688 }; 2689 2690 return { 2691 resolvers: mappedResolvers, 2692 selectors: Object(external_lodash_["mapValues"])(selectors, mapSelector) 2693 }; 2694 } 2695 /** 2696 * Calls a resolver given arguments 2697 * 2698 * @param {Object} store Store reference, for fulfilling via resolvers 2699 * @param {Object} resolvers Store Resolvers 2700 * @param {string} selectorName Selector name to fulfill. 2701 * @param {Array} args Selector Arguments. 2702 */ 2703 2704 2705 function fulfillResolver(_x, _x2, _x3) { 2706 return _fulfillResolver.apply(this, arguments); 2707 } 2708 2709 function _fulfillResolver() { 2710 _fulfillResolver = Object(asyncToGenerator["a" /* default */])( /*#__PURE__*/external_regeneratorRuntime_default.a.mark(function _callee3(store, resolvers, selectorName) { 2711 var resolver, 2712 _len5, 2713 args, 2714 _key5, 2715 action, 2716 _args3 = arguments; 2717 2718 return external_regeneratorRuntime_default.a.wrap(function _callee3$(_context3) { 2719 while (1) { 2720 switch (_context3.prev = _context3.next) { 2721 case 0: 2722 resolver = Object(external_lodash_["get"])(resolvers, [selectorName]); 2723 2724 if (resolver) { 2725 _context3.next = 3; 2726 break; 2727 } 2728 2729 return _context3.abrupt("return"); 2730 2731 case 3: 2732 for (_len5 = _args3.length, args = new Array(_len5 > 3 ? _len5 - 3 : 0), _key5 = 3; _key5 < _len5; _key5++) { 2733 args[_key5 - 3] = _args3[_key5]; 2734 } 2735 2736 action = resolver.fulfill.apply(resolver, args); 2737 2738 if (!action) { 2739 _context3.next = 8; 2740 break; 2741 } 2742 2743 _context3.next = 8; 2744 return store.dispatch(action); 2745 2746 case 8: 2747 case "end": 2748 return _context3.stop(); 2749 } 2750 } 2751 }, _callee3); 2752 })); 2753 return _fulfillResolver.apply(this, arguments); 2754 } 2755 2756 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/store/index.js 2757 2758 2759 function store_ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } 2760 2761 function store_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { store_ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { store_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } 2762 2763 function createCoreDataStore(registry) { 2764 var getCoreDataSelector = function getCoreDataSelector(selectorName) { 2765 return function (key) { 2766 var _registry$select; 2767 2768 for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { 2769 args[_key - 1] = arguments[_key]; 2770 } 2771 2772 return (_registry$select = registry.select(key))[selectorName].apply(_registry$select, args); 2773 }; 2774 }; 2775 2776 var getCoreDataAction = function getCoreDataAction(actionName) { 2777 return function (key) { 2778 var _registry$dispatch; 2779 2780 for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { 2781 args[_key2 - 1] = arguments[_key2]; 2782 } 2783 2784 return (_registry$dispatch = registry.dispatch(key))[actionName].apply(_registry$dispatch, args); 2785 }; 2786 }; 2787 2788 return { 2789 getSelectors: function getSelectors() { 2790 return ['getIsResolving', 'hasStartedResolution', 'hasFinishedResolution', 'isResolving', 'getCachedResolvers'].reduce(function (memo, selectorName) { 2791 return store_objectSpread(store_objectSpread({}, memo), {}, Object(defineProperty["a" /* default */])({}, selectorName, getCoreDataSelector(selectorName))); 2792 }, {}); 2793 }, 2794 getActions: function getActions() { 2795 return ['startResolution', 'finishResolution', 'invalidateResolution', 'invalidateResolutionForStore', 'invalidateResolutionForStoreSelector'].reduce(function (memo, actionName) { 2796 return store_objectSpread(store_objectSpread({}, memo), {}, Object(defineProperty["a" /* default */])({}, actionName, getCoreDataAction(actionName))); 2797 }, {}); 2798 }, 2799 subscribe: function subscribe() { 2800 // There's no reasons to trigger any listener when we subscribe to this store 2801 // because there's no state stored in this store that need to retrigger selectors 2802 // if a change happens, the corresponding store where the tracking stated live 2803 // would have already triggered a "subscribe" call. 2804 return function () {}; 2805 } 2806 }; 2807 } 2808 2809 /* harmony default export */ var build_module_store = (createCoreDataStore); 2810 2811 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/registry.js 2812 2813 2814 2815 function registry_ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } 2816 2817 function registry_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { registry_ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { registry_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } 2818 2819 /** 2820 * External dependencies 2821 */ 2822 2823 /** 2824 * Internal dependencies 2825 */ 2826 2827 2828 2829 /** @typedef {import('./types').WPDataStore} WPDataStore */ 2830 2831 /** 2832 * @typedef {Object} WPDataRegistry An isolated orchestrator of store registrations. 2833 * 2834 * @property {Function} registerGenericStore Given a namespace key and settings 2835 * object, registers a new generic 2836 * store. 2837 * @property {Function} registerStore Given a namespace key and settings 2838 * object, registers a new namespace 2839 * store. 2840 * @property {Function} subscribe Given a function callback, invokes 2841 * the callback on any change to state 2842 * within any registered store. 2843 * @property {Function} select Given a namespace key, returns an 2844 * object of the store's registered 2845 * selectors. 2846 * @property {Function} dispatch Given a namespace key, returns an 2847 * object of the store's registered 2848 * action dispatchers. 2849 */ 2850 2851 /** 2852 * @typedef {Object} WPDataPlugin An object of registry function overrides. 2853 * 2854 * @property {Function} registerStore registers store. 2855 */ 2856 2857 /** 2858 * Creates a new store registry, given an optional object of initial store 2859 * configurations. 2860 * 2861 * @param {Object} storeConfigs Initial store configurations. 2862 * @param {Object?} parent Parent registry. 2863 * 2864 * @return {WPDataRegistry} Data registry. 2865 */ 2866 2867 function createRegistry() { 2868 var storeConfigs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 2869 var parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; 2870 var stores = {}; 2871 var listeners = []; 2872 2873 var __experimentalListeningStores = new Set(); 2874 /** 2875 * Global listener called for each store's update. 2876 */ 2877 2878 2879 function globalListener() { 2880 listeners.forEach(function (listener) { 2881 return listener(); 2882 }); 2883 } 2884 /** 2885 * Subscribe to changes to any data. 2886 * 2887 * @param {Function} listener Listener function. 2888 * 2889 * @return {Function} Unsubscribe function. 2890 */ 2891 2892 2893 var subscribe = function subscribe(listener) { 2894 listeners.push(listener); 2895 return function () { 2896 listeners = Object(external_lodash_["without"])(listeners, listener); 2897 }; 2898 }; 2899 /** 2900 * Calls a selector given the current state and extra arguments. 2901 * 2902 * @param {string|WPDataStore} storeNameOrDefinition Unique namespace identifier for the store 2903 * or the store definition. 2904 * 2905 * @return {*} The selector's returned value. 2906 */ 2907 2908 2909 function select(storeNameOrDefinition) { 2910 var storeName = Object(external_lodash_["isObject"])(storeNameOrDefinition) ? storeNameOrDefinition.name : storeNameOrDefinition; 2911 2912 __experimentalListeningStores.add(storeName); 2913 2914 var store = stores[storeName]; 2915 2916 if (store) { 2917 return store.getSelectors(); 2918 } 2919 2920 return parent && parent.select(storeName); 2921 } 2922 2923 function __experimentalMarkListeningStores(callback, ref) { 2924 __experimentalListeningStores.clear(); 2925 2926 var result = callback.call(this); 2927 ref.current = Array.from(__experimentalListeningStores); 2928 return result; 2929 } 2930 /** 2931 * Given the name of a registered store, returns an object containing the store's 2932 * selectors pre-bound to state so that you only need to supply additional arguments, 2933 * and modified so that they return promises that resolve to their eventual values, 2934 * after any resolvers have ran. 2935 * 2936 * @param {string|WPDataStore} storeNameOrDefinition Unique namespace identifier for the store 2937 * or the store definition. 2938 * 2939 * @return {Object} Each key of the object matches the name of a selector. 2940 */ 2941 2942 2943 function __experimentalResolveSelect(storeNameOrDefinition) { 2944 var storeName = Object(external_lodash_["isObject"])(storeNameOrDefinition) ? storeNameOrDefinition.name : storeNameOrDefinition; 2945 2946 __experimentalListeningStores.add(storeName); 2947 2948 var store = stores[storeName]; 2949 2950 if (store) { 2951 return store.__experimentalGetResolveSelectors(); 2952 } 2953 2954 return parent && parent.__experimentalResolveSelect(storeName); 2955 } 2956 /** 2957 * Returns the available actions for a part of the state. 2958 * 2959 * @param {string|WPDataStore} storeNameOrDefinition Unique namespace identifier for the store 2960 * or the store definition. 2961 * 2962 * @return {*} The action's returned value. 2963 */ 2964 2965 2966 function dispatch(storeNameOrDefinition) { 2967 var storeName = Object(external_lodash_["isObject"])(storeNameOrDefinition) ? storeNameOrDefinition.name : storeNameOrDefinition; 2968 var store = stores[storeName]; 2969 2970 if (store) { 2971 return store.getActions(); 2972 } 2973 2974 return parent && parent.dispatch(storeName); 2975 } // 2976 // Deprecated 2977 // TODO: Remove this after `use()` is removed. 2978 // 2979 2980 2981 function withPlugins(attributes) { 2982 return Object(external_lodash_["mapValues"])(attributes, function (attribute, key) { 2983 if (typeof attribute !== 'function') { 2984 return attribute; 2985 } 2986 2987 return function () { 2988 return registry[key].apply(null, arguments); 2989 }; 2990 }); 2991 } 2992 /** 2993 * Registers a generic store. 2994 * 2995 * @param {string} key Store registry key. 2996 * @param {Object} config Configuration (getSelectors, getActions, subscribe). 2997 */ 2998 2999 3000 function registerGenericStore(key, config) { 3001 if (typeof config.getSelectors !== 'function') { 3002 throw new TypeError('config.getSelectors must be a function'); 3003 } 3004 3005 if (typeof config.getActions !== 'function') { 3006 throw new TypeError('config.getActions must be a function'); 3007 } 3008 3009 if (typeof config.subscribe !== 'function') { 3010 throw new TypeError('config.subscribe must be a function'); 3011 } 3012 3013 stores[key] = config; 3014 config.subscribe(globalListener); 3015 } 3016 /** 3017 * Registers a new store definition. 3018 * 3019 * @param {WPDataStore} store Store definition. 3020 */ 3021 3022 3023 function register(store) { 3024 registerGenericStore(store.name, store.instantiate(registry)); 3025 } 3026 /** 3027 * Subscribe handler to a store. 3028 * 3029 * @param {string[]} storeName The store name. 3030 * @param {Function} handler The function subscribed to the store. 3031 * @return {Function} A function to unsubscribe the handler. 3032 */ 3033 3034 3035 function __experimentalSubscribeStore(storeName, handler) { 3036 if (storeName in stores) { 3037 return stores[storeName].subscribe(handler); 3038 } // Trying to access a store that hasn't been registered, 3039 // this is a pattern rarely used but seen in some places. 3040 // We fallback to regular `subscribe` here for backward-compatibility for now. 3041 // See https://github.com/WordPress/gutenberg/pull/27466 for more info. 3042 3043 3044 if (!parent) { 3045 return subscribe(handler); 3046 } 3047 3048 return parent.__experimentalSubscribeStore(storeName, handler); 3049 } 3050 3051 var registry = { 3052 registerGenericStore: registerGenericStore, 3053 stores: stores, 3054 namespaces: stores, 3055 // TODO: Deprecate/remove this. 3056 subscribe: subscribe, 3057 select: select, 3058 __experimentalResolveSelect: __experimentalResolveSelect, 3059 dispatch: dispatch, 3060 use: use, 3061 register: register, 3062 __experimentalMarkListeningStores: __experimentalMarkListeningStores, 3063 __experimentalSubscribeStore: __experimentalSubscribeStore 3064 }; 3065 /** 3066 * Registers a standard `@wordpress/data` store. 3067 * 3068 * @param {string} storeName Unique namespace identifier. 3069 * @param {Object} options Store description (reducer, actions, selectors, resolvers). 3070 * 3071 * @return {Object} Registered store object. 3072 */ 3073 3074 registry.registerStore = function (storeName, options) { 3075 if (!options.reducer) { 3076 throw new TypeError('Must specify store reducer'); 3077 } 3078 3079 var store = createReduxStore(storeName, options).instantiate(registry); 3080 registerGenericStore(storeName, store); 3081 return store.store; 3082 }; // 3083 // TODO: 3084 // This function will be deprecated as soon as it is no longer internally referenced. 3085 // 3086 3087 3088 function use(plugin, options) { 3089 registry = registry_objectSpread(registry_objectSpread({}, registry), plugin(registry, options)); 3090 return registry; 3091 } 3092 3093 registerGenericStore('core/data', build_module_store(registry)); 3094 Object.entries(storeConfigs).forEach(function (_ref) { 3095 var _ref2 = Object(slicedToArray["a" /* default */])(_ref, 2), 3096 name = _ref2[0], 3097 config = _ref2[1]; 3098 3099 return registry.registerStore(name, config); 3100 }); 3101 3102 if (parent) { 3103 parent.subscribe(globalListener); 3104 } 3105 3106 return withPlugins(registry); 3107 } 3108 3109 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/default-registry.js 3110 /** 3111 * Internal dependencies 3112 */ 3113 3114 /* harmony default export */ var default_registry = (createRegistry()); 3115 3116 // EXTERNAL MODULE: external ["wp","deprecated"] 3117 var external_wp_deprecated_ = __webpack_require__(35); 3118 var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_); 3119 3120 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/plugins/controls/index.js 3121 /** 3122 * WordPress dependencies 3123 */ 3124 3125 /* harmony default export */ var plugins_controls = (function (registry) { 3126 external_wp_deprecated_default()('wp.data.plugins.controls', { 3127 hint: 'The controls plugins is now baked-in.' 3128 }); 3129 return registry; 3130 }); 3131 3132 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/plugins/persistence/storage/object.js 3133 var objectStorage; 3134 var object_storage = { 3135 getItem: function getItem(key) { 3136 if (!objectStorage || !objectStorage[key]) { 3137 return null; 3138 } 3139 3140 return objectStorage[key]; 3141 }, 3142 setItem: function setItem(key, value) { 3143 if (!objectStorage) { 3144 object_storage.clear(); 3145 } 3146 3147 objectStorage[key] = String(value); 3148 }, 3149 clear: function clear() { 3150 objectStorage = Object.create(null); 3151 } 3152 }; 3153 /* harmony default export */ var object = (object_storage); 3154 3155 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/plugins/persistence/storage/default.js 3156 /** 3157 * Internal dependencies 3158 */ 3159 3160 var default_storage; 3161 3162 try { 3163 // Private Browsing in Safari 10 and earlier will throw an error when 3164 // attempting to set into localStorage. The test here is intentional in 3165 // causing a thrown error as condition for using fallback object storage. 3166 default_storage = window.localStorage; 3167 default_storage.setItem('__wpDataTestLocalStorage', ''); 3168 default_storage.removeItem('__wpDataTestLocalStorage'); 3169 } catch (error) { 3170 default_storage = object; 3171 } 3172 3173 /* harmony default export */ var storage_default = (default_storage); 3174 3175 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/plugins/persistence/index.js 3176 3177 3178 function persistence_ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } 3179 3180 function persistence_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { persistence_ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { persistence_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } 3181 3182 /** 3183 * External dependencies 3184 */ 3185 3186 /** 3187 * Internal dependencies 3188 */ 3189 3190 3191 3192 /** @typedef {import('../../registry').WPDataRegistry} WPDataRegistry */ 3193 3194 /** @typedef {import('../../registry').WPDataPlugin} WPDataPlugin */ 3195 3196 /** 3197 * @typedef {Object} WPDataPersistencePluginOptions Persistence plugin options. 3198 * 3199 * @property {Storage} storage Persistent storage implementation. This must 3200 * at least implement `getItem` and `setItem` of 3201 * the Web Storage API. 3202 * @property {string} storageKey Key on which to set in persistent storage. 3203 * 3204 */ 3205 3206 /** 3207 * Default plugin storage. 3208 * 3209 * @type {Storage} 3210 */ 3211 3212 var DEFAULT_STORAGE = storage_default; 3213 /** 3214 * Default plugin storage key. 3215 * 3216 * @type {string} 3217 */ 3218 3219 var DEFAULT_STORAGE_KEY = 'WP_DATA'; 3220 /** 3221 * Higher-order reducer which invokes the original reducer only if state is 3222 * inequal from that of the action's `nextState` property, otherwise returning 3223 * the original state reference. 3224 * 3225 * @param {Function} reducer Original reducer. 3226 * 3227 * @return {Function} Enhanced reducer. 3228 */ 3229 3230 var withLazySameState = function withLazySameState(reducer) { 3231 return function (state, action) { 3232 if (action.nextState === state) { 3233 return state; 3234 } 3235 3236 return reducer(state, action); 3237 }; 3238 }; 3239 /** 3240 * Creates a persistence interface, exposing getter and setter methods (`get` 3241 * and `set` respectively). 3242 * 3243 * @param {WPDataPersistencePluginOptions} options Plugin options. 3244 * 3245 * @return {Object} Persistence interface. 3246 */ 3247 3248 function createPersistenceInterface(options) { 3249 var _options$storage = options.storage, 3250 storage = _options$storage === void 0 ? DEFAULT_STORAGE : _options$storage, 3251 _options$storageKey = options.storageKey, 3252 storageKey = _options$storageKey === void 0 ? DEFAULT_STORAGE_KEY : _options$storageKey; 3253 var data; 3254 /** 3255 * Returns the persisted data as an object, defaulting to an empty object. 3256 * 3257 * @return {Object} Persisted data. 3258 */ 3259 3260 function getData() { 3261 if (data === undefined) { 3262 // If unset, getItem is expected to return null. Fall back to 3263 // empty object. 3264 var persisted = storage.getItem(storageKey); 3265 3266 if (persisted === null) { 3267 data = {}; 3268 } else { 3269 try { 3270 data = JSON.parse(persisted); 3271 } catch (error) { 3272 // Similarly, should any error be thrown during parse of 3273 // the string (malformed JSON), fall back to empty object. 3274 data = {}; 3275 } 3276 } 3277 } 3278 3279 return data; 3280 } 3281 /** 3282 * Merges an updated reducer state into the persisted data. 3283 * 3284 * @param {string} key Key to update. 3285 * @param {*} value Updated value. 3286 */ 3287 3288 3289 function setData(key, value) { 3290 data = persistence_objectSpread(persistence_objectSpread({}, data), {}, Object(defineProperty["a" /* default */])({}, key, value)); 3291 storage.setItem(storageKey, JSON.stringify(data)); 3292 } 3293 3294 return { 3295 get: getData, 3296 set: setData 3297 }; 3298 } 3299 /** 3300 * Data plugin to persist store state into a single storage key. 3301 * 3302 * @param {WPDataRegistry} registry Data registry. 3303 * @param {?WPDataPersistencePluginOptions} pluginOptions Plugin options. 3304 * 3305 * @return {WPDataPlugin} Data plugin. 3306 */ 3307 3308 function persistencePlugin(registry, pluginOptions) { 3309 var persistence = createPersistenceInterface(pluginOptions); 3310 /** 3311 * Creates an enhanced store dispatch function, triggering the state of the 3312 * given store name to be persisted when changed. 3313 * 3314 * @param {Function} getState Function which returns current state. 3315 * @param {string} storeName Store name. 3316 * @param {?Array<string>} keys Optional subset of keys to save. 3317 * 3318 * @return {Function} Enhanced dispatch function. 3319 */ 3320 3321 function createPersistOnChange(getState, storeName, keys) { 3322 var getPersistedState; 3323 3324 if (Array.isArray(keys)) { 3325 // Given keys, the persisted state should by produced as an object 3326 // of the subset of keys. This implementation uses combineReducers 3327 // to leverage its behavior of returning the same object when none 3328 // of the property values changes. This allows a strict reference 3329 // equality to bypass a persistence set on an unchanging state. 3330 var reducers = keys.reduce(function (accumulator, key) { 3331 return Object.assign(accumulator, Object(defineProperty["a" /* default */])({}, key, function (state, action) { 3332 return action.nextState[key]; 3333 })); 3334 }, {}); 3335 getPersistedState = withLazySameState(turbo_combine_reducers_default()(reducers)); 3336 } else { 3337 getPersistedState = function getPersistedState(state, action) { 3338 return action.nextState; 3339 }; 3340 } 3341 3342 var lastState = getPersistedState(undefined, { 3343 nextState: getState() 3344 }); 3345 return function () { 3346 var state = getPersistedState(lastState, { 3347 nextState: getState() 3348 }); 3349 3350 if (state !== lastState) { 3351 persistence.set(storeName, state); 3352 lastState = state; 3353 } 3354 }; 3355 } 3356 3357 return { 3358 registerStore: function registerStore(storeName, options) { 3359 if (!options.persist) { 3360 return registry.registerStore(storeName, options); 3361 } // Load from persistence to use as initial state. 3362 3363 3364 var persistedState = persistence.get()[storeName]; 3365 3366 if (persistedState !== undefined) { 3367 var initialState = options.reducer(options.initialState, { 3368 type: '@@WP/PERSISTENCE_RESTORE' 3369 }); 3370 3371 if (Object(external_lodash_["isPlainObject"])(initialState) && Object(external_lodash_["isPlainObject"])(persistedState)) { 3372 // If state is an object, ensure that: 3373 // - Other keys are left intact when persisting only a 3374 // subset of keys. 3375 // - New keys in what would otherwise be used as initial 3376 // state are deeply merged as base for persisted value. 3377 initialState = Object(external_lodash_["merge"])({}, initialState, persistedState); 3378 } else { 3379 // If there is a mismatch in object-likeness of default 3380 // initial or persisted state, defer to persisted value. 3381 initialState = persistedState; 3382 } 3383 3384 options = persistence_objectSpread(persistence_objectSpread({}, options), {}, { 3385 initialState: initialState 3386 }); 3387 } 3388 3389 var store = registry.registerStore(storeName, options); 3390 store.subscribe(createPersistOnChange(store.getState, storeName, options.persist)); 3391 return store; 3392 } 3393 }; 3394 } 3395 /** 3396 * Deprecated: Remove this function and the code in WordPress Core that calls 3397 * it once WordPress 5.4 is released. 3398 */ 3399 3400 3401 persistencePlugin.__unstableMigrate = function (pluginOptions) { 3402 var _state$coreEditor, _state$coreEditor$pre; 3403 3404 var persistence = createPersistenceInterface(pluginOptions); 3405 var state = persistence.get(); // Migrate 'insertUsage' from 'core/editor' to 'core/block-editor' 3406 3407 var editorInsertUsage = (_state$coreEditor = state['core/editor']) === null || _state$coreEditor === void 0 ? void 0 : (_state$coreEditor$pre = _state$coreEditor.preferences) === null || _state$coreEditor$pre === void 0 ? void 0 : _state$coreEditor$pre.insertUsage; 3408 3409 if (editorInsertUsage) { 3410 var _state$coreBlockEdi, _state$coreBlockEdi$p; 3411 3412 var blockEditorInsertUsage = (_state$coreBlockEdi = state['core/block-editor']) === null || _state$coreBlockEdi === void 0 ? void 0 : (_state$coreBlockEdi$p = _state$coreBlockEdi.preferences) === null || _state$coreBlockEdi$p === void 0 ? void 0 : _state$coreBlockEdi$p.insertUsage; 3413 persistence.set('core/block-editor', { 3414 preferences: { 3415 insertUsage: persistence_objectSpread(persistence_objectSpread({}, editorInsertUsage), blockEditorInsertUsage) 3416 } 3417 }); 3418 } 3419 3420 var editPostState = state['core/edit-post']; // Default `fullscreenMode` to `false` if any persisted state had existed 3421 // and the user hadn't made an explicit choice about fullscreen mode. This 3422 // is needed since `fullscreenMode` previously did not have a default value 3423 // and was implicitly false by its absence. It is now `true` by default, but 3424 // this change is not intended to affect upgrades from earlier versions. 3425 3426 var hadPersistedState = Object.keys(state).length > 0; 3427 var hadFullscreenModePreference = Object(external_lodash_["has"])(state, ['core/edit-post', 'preferences', 'features', 'fullscreenMode']); 3428 3429 if (hadPersistedState && !hadFullscreenModePreference) { 3430 editPostState = Object(external_lodash_["merge"])({}, editPostState, { 3431 preferences: { 3432 features: { 3433 fullscreenMode: false 3434 } 3435 } 3436 }); 3437 } // Migrate 'areTipsEnabled' from 'core/nux' to 'showWelcomeGuide' in 'core/edit-post' 3438 3439 3440 var areTipsEnabled = Object(external_lodash_["get"])(state, ['core/nux', 'preferences', 'areTipsEnabled']); 3441 var hasWelcomeGuide = Object(external_lodash_["has"])(state, ['core/edit-post', 'preferences', 'features', 'welcomeGuide']); 3442 3443 if (areTipsEnabled !== undefined && !hasWelcomeGuide) { 3444 editPostState = Object(external_lodash_["merge"])({}, editPostState, { 3445 preferences: { 3446 features: { 3447 welcomeGuide: areTipsEnabled 3448 } 3449 } 3450 }); 3451 } 3452 3453 if (editPostState !== state['core/edit-post']) { 3454 persistence.set('core/edit-post', editPostState); 3455 } 3456 }; 3457 3458 /* harmony default export */ var plugins_persistence = (persistencePlugin); 3459 3460 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/plugins/index.js 3461 3462 3463 3464 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js 3465 var esm_extends = __webpack_require__(8); 3466 3467 // EXTERNAL MODULE: external ["wp","element"] 3468 var external_wp_element_ = __webpack_require__(0); 3469 3470 // EXTERNAL MODULE: external ["wp","compose"] 3471 var external_wp_compose_ = __webpack_require__(12); 3472 3473 // EXTERNAL MODULE: ./node_modules/use-memo-one/dist/use-memo-one.esm.js 3474 var use_memo_one_esm = __webpack_require__(127); 3475 3476 // EXTERNAL MODULE: external ["wp","priorityQueue"] 3477 var external_wp_priorityQueue_ = __webpack_require__(152); 3478 3479 // EXTERNAL MODULE: external ["wp","isShallowEqual"] 3480 var external_wp_isShallowEqual_ = __webpack_require__(63); 3481 var external_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_wp_isShallowEqual_); 3482 3483 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/components/registry-provider/context.js 3484 /** 3485 * WordPress dependencies 3486 */ 3487 3488 /** 3489 * Internal dependencies 3490 */ 3491 3492 3493 var Context = Object(external_wp_element_["createContext"])(default_registry); 3494 var Consumer = Context.Consumer, 3495 Provider = Context.Provider; 3496 /** 3497 * A custom react Context consumer exposing the provided `registry` to 3498 * children components. Used along with the RegistryProvider. 3499 * 3500 * You can read more about the react context api here: 3501 * https://reactjs.org/docs/context.html#contextprovider 3502 * 3503 * @example 3504 * ```js 3505 * import { 3506 * RegistryProvider, 3507 * RegistryConsumer, 3508 * createRegistry 3509 * } from '@wordpress/data'; 3510 * 3511 * const registry = createRegistry( {} ); 3512 * 3513 * const App = ( { props } ) => { 3514 * return <RegistryProvider value={ registry }> 3515 * <div>Hello There</div> 3516 * <RegistryConsumer> 3517 * { ( registry ) => ( 3518 * <ComponentUsingRegistry 3519 * { ...props } 3520 * registry={ registry } 3521 * ) } 3522 * </RegistryConsumer> 3523 * </RegistryProvider> 3524 * } 3525 * ``` 3526 */ 3527 3528 var RegistryConsumer = Consumer; 3529 /** 3530 * A custom Context provider for exposing the provided `registry` to children 3531 * components via a consumer. 3532 * 3533 * See <a name="#RegistryConsumer">RegistryConsumer</a> documentation for 3534 * example. 3535 */ 3536 3537 /* harmony default export */ var context = (Provider); 3538 3539 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/components/registry-provider/use-registry.js 3540 /** 3541 * WordPress dependencies 3542 */ 3543 3544 /** 3545 * Internal dependencies 3546 */ 3547 3548 3549 /** 3550 * A custom react hook exposing the registry context for use. 3551 * 3552 * This exposes the `registry` value provided via the 3553 * <a href="#RegistryProvider">Registry Provider</a> to a component implementing 3554 * this hook. 3555 * 3556 * It acts similarly to the `useContext` react hook. 3557 * 3558 * Note: Generally speaking, `useRegistry` is a low level hook that in most cases 3559 * won't be needed for implementation. Most interactions with the `@wordpress/data` 3560 * API can be performed via the `useSelect` hook, or the `withSelect` and 3561 * `withDispatch` higher order components. 3562 * 3563 * @example 3564 * ```js 3565 * import { 3566 * RegistryProvider, 3567 * createRegistry, 3568 * useRegistry, 3569 * } from '@wordpress/data'; 3570 * 3571 * const registry = createRegistry( {} ); 3572 * 3573 * const SomeChildUsingRegistry = ( props ) => { 3574 * const registry = useRegistry( registry ); 3575 * // ...logic implementing the registry in other react hooks. 3576 * }; 3577 * 3578 * 3579 * const ParentProvidingRegistry = ( props ) => { 3580 * return <RegistryProvider value={ registry }> 3581 * <SomeChildUsingRegistry { ...props } /> 3582 * </RegistryProvider> 3583 * }; 3584 * ``` 3585 * 3586 * @return {Function} A custom react hook exposing the registry context value. 3587 */ 3588 3589 function useRegistry() { 3590 return Object(external_wp_element_["useContext"])(Context); 3591 } 3592 3593 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/components/async-mode-provider/context.js 3594 /** 3595 * WordPress dependencies 3596 */ 3597 3598 var context_Context = Object(external_wp_element_["createContext"])(false); 3599 var context_Consumer = context_Context.Consumer, 3600 context_Provider = context_Context.Provider; 3601 var AsyncModeConsumer = context_Consumer; 3602 /** 3603 * Context Provider Component used to switch the data module component rerendering 3604 * between Sync and Async modes. 3605 * 3606 * @example 3607 * 3608 * ```js 3609 * import { useSelect, AsyncModeProvider } from '@wordpress/data'; 3610 * 3611 * function BlockCount() { 3612 * const count = useSelect( ( select ) => { 3613 * return select( 'core/block-editor' ).getBlockCount() 3614 * }, [] ); 3615 * 3616 * return count; 3617 * } 3618 * 3619 * function App() { 3620 * return ( 3621 * <AsyncModeProvider value={ true }> 3622 * <BlockCount /> 3623 * </AsyncModeProvider> 3624 * ); 3625 * } 3626 * ``` 3627 * 3628 * In this example, the BlockCount component is rerendered asynchronously. 3629 * It means if a more critical task is being performed (like typing in an input), 3630 * the rerendering is delayed until the browser becomes IDLE. 3631 * It is possible to nest multiple levels of AsyncModeProvider to fine-tune the rendering behavior. 3632 * 3633 * @param {boolean} props.value Enable Async Mode. 3634 * @return {WPComponent} The component to be rendered. 3635 */ 3636 3637 /* harmony default export */ var async_mode_provider_context = (context_Provider); 3638 3639 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/components/async-mode-provider/use-async-mode.js 3640 /** 3641 * WordPress dependencies 3642 */ 3643 3644 /** 3645 * Internal dependencies 3646 */ 3647 3648 3649 function useAsyncMode() { 3650 return Object(external_wp_element_["useContext"])(context_Context); 3651 } 3652 3653 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/components/use-select/index.js 3654 3655 3656 /** 3657 * External dependencies 3658 */ 3659 3660 /** 3661 * WordPress dependencies 3662 */ 3663 3664 3665 3666 3667 3668 /** 3669 * Internal dependencies 3670 */ 3671 3672 3673 3674 var renderQueue = Object(external_wp_priorityQueue_["createQueue"])(); 3675 /** 3676 * Custom react hook for retrieving props from registered selectors. 3677 * 3678 * In general, this custom React hook follows the 3679 * [rules of hooks](https://reactjs.org/docs/hooks-rules.html). 3680 * 3681 * @param {Function} _mapSelect Function called on every state change. The 3682 * returned value is exposed to the component 3683 * implementing this hook. The function receives 3684 * the `registry.select` method on the first 3685 * argument and the `registry` on the second 3686 * argument. 3687 * @param {Array} deps If provided, this memoizes the mapSelect so the 3688 * same `mapSelect` is invoked on every state 3689 * change unless the dependencies change. 3690 * 3691 * @example 3692 * ```js 3693 * import { useSelect } from '@wordpress/data'; 3694 * 3695 * function HammerPriceDisplay( { currency } ) { 3696 * const price = useSelect( ( select ) => { 3697 * return select( 'my-shop' ).getPrice( 'hammer', currency ) 3698 * }, [ currency ] ); 3699 * return new Intl.NumberFormat( 'en-US', { 3700 * style: 'currency', 3701 * currency, 3702 * } ).format( price ); 3703 * } 3704 * 3705 * // Rendered in the application: 3706 * // <HammerPriceDisplay currency="USD" /> 3707 * ``` 3708 * 3709 * In the above example, when `HammerPriceDisplay` is rendered into an 3710 * application, the price will be retrieved from the store state using the 3711 * `mapSelect` callback on `useSelect`. If the currency prop changes then 3712 * any price in the state for that currency is retrieved. If the currency prop 3713 * doesn't change and other props are passed in that do change, the price will 3714 * not change because the dependency is just the currency. 3715 * 3716 * @return {Function} A custom react hook. 3717 */ 3718 3719 function useSelect(_mapSelect, deps) { 3720 var mapSelect = Object(external_wp_element_["useCallback"])(_mapSelect, deps); 3721 var registry = useRegistry(); 3722 var isAsync = useAsyncMode(); // React can sometimes clear the `useMemo` cache. 3723 // We use the cache-stable `useMemoOne` to avoid 3724 // losing queues. 3725 3726 var queueContext = Object(use_memo_one_esm["a" /* useMemoOne */])(function () { 3727 return { 3728 queue: true 3729 }; 3730 }, [registry]); 3731 3732 var _useReducer = Object(external_wp_element_["useReducer"])(function (s) { 3733 return s + 1; 3734 }, 0), 3735 _useReducer2 = Object(slicedToArray["a" /* default */])(_useReducer, 2), 3736 forceRender = _useReducer2[1]; 3737 3738 var latestMapSelect = Object(external_wp_element_["useRef"])(); 3739 var latestIsAsync = Object(external_wp_element_["useRef"])(isAsync); 3740 var latestMapOutput = Object(external_wp_element_["useRef"])(); 3741 var latestMapOutputError = Object(external_wp_element_["useRef"])(); 3742 var isMountedAndNotUnsubscribing = Object(external_wp_element_["useRef"])(); // Keep track of the stores being selected in the mapSelect function, 3743 // and only subscribe to those stores later. 3744 3745 var listeningStores = Object(external_wp_element_["useRef"])([]); 3746 var trapSelect = Object(external_wp_element_["useCallback"])(function (callback) { 3747 return registry.__experimentalMarkListeningStores(callback, listeningStores); 3748 }, [registry]); // Generate a "flag" for used in the effect dependency array. 3749 // It's different than just using `mapSelect` since deps could be undefined, 3750 // in that case, we would still want to memoize it. 3751 3752 var depsChangedFlag = Object(external_wp_element_["useMemo"])(function () { 3753 return {}; 3754 }, deps || []); 3755 var mapOutput; 3756 3757 try { 3758 if (latestMapSelect.current !== mapSelect || latestMapOutputError.current) { 3759 mapOutput = trapSelect(function () { 3760 return mapSelect(registry.select, registry); 3761 }); 3762 } else { 3763 mapOutput = latestMapOutput.current; 3764 } 3765 } catch (error) { 3766 var errorMessage = "An error occurred while running 'mapSelect': ".concat(error.message); 3767 3768 if (latestMapOutputError.current) { 3769 errorMessage += "\nThe error may be correlated with this previous error:\n"; 3770 errorMessage += "".concat(latestMapOutputError.current.stack, "\n\n"); 3771 errorMessage += 'Original stack trace:'; 3772 throw new Error(errorMessage); 3773 } else { 3774 // eslint-disable-next-line no-console 3775 console.error(errorMessage); 3776 } 3777 } 3778 3779 Object(external_wp_compose_["useIsomorphicLayoutEffect"])(function () { 3780 latestMapSelect.current = mapSelect; 3781 latestMapOutput.current = mapOutput; 3782 latestMapOutputError.current = undefined; 3783 isMountedAndNotUnsubscribing.current = true; // This has to run after the other ref updates 3784 // to avoid using stale values in the flushed 3785 // callbacks or potentially overwriting a 3786 // changed `latestMapOutput.current`. 3787 3788 if (latestIsAsync.current !== isAsync) { 3789 latestIsAsync.current = isAsync; 3790 renderQueue.flush(queueContext); 3791 } 3792 }); 3793 Object(external_wp_compose_["useIsomorphicLayoutEffect"])(function () { 3794 var onStoreChange = function onStoreChange() { 3795 if (isMountedAndNotUnsubscribing.current) { 3796 try { 3797 var newMapOutput = trapSelect(function () { 3798 return latestMapSelect.current(registry.select, registry); 3799 }); 3800 3801 if (external_wp_isShallowEqual_default()(latestMapOutput.current, newMapOutput)) { 3802 return; 3803 } 3804 3805 latestMapOutput.current = newMapOutput; 3806 } catch (error) { 3807 latestMapOutputError.current = error; 3808 } 3809 3810 forceRender(); 3811 } 3812 }; // catch any possible state changes during mount before the subscription 3813 // could be set. 3814 3815 3816 if (latestIsAsync.current) { 3817 renderQueue.add(queueContext, onStoreChange); 3818 } else { 3819 onStoreChange(); 3820 } 3821 3822 var onChange = function onChange() { 3823 if (latestIsAsync.current) { 3824 renderQueue.add(queueContext, onStoreChange); 3825 } else { 3826 onStoreChange(); 3827 } 3828 }; 3829 3830 var unsubscribers = listeningStores.current.map(function (storeName) { 3831 return registry.__experimentalSubscribeStore(storeName, onChange); 3832 }); 3833 return function () { 3834 isMountedAndNotUnsubscribing.current = false; // The return value of the subscribe function could be undefined if the store is a custom generic store. 3835 3836 unsubscribers.forEach(function (unsubscribe) { 3837 return unsubscribe === null || unsubscribe === void 0 ? void 0 : unsubscribe(); 3838 }); 3839 renderQueue.flush(queueContext); 3840 }; 3841 }, [registry, trapSelect, depsChangedFlag]); 3842 return mapOutput; 3843 } 3844 3845 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/components/with-select/index.js 3846 3847 3848 3849 /** 3850 * WordPress dependencies 3851 */ 3852 3853 /** 3854 * Internal dependencies 3855 */ 3856 3857 3858 /** 3859 * Higher-order component used to inject state-derived props using registered 3860 * selectors. 3861 * 3862 * @param {Function} mapSelectToProps Function called on every state change, 3863 * expected to return object of props to 3864 * merge with the component's own props. 3865 * 3866 * @example 3867 * ```js 3868 * import { withSelect } from '@wordpress/data'; 3869 * 3870 * function PriceDisplay( { price, currency } ) { 3871 * return new Intl.NumberFormat( 'en-US', { 3872 * style: 'currency', 3873 * currency, 3874 * } ).format( price ); 3875 * } 3876 * 3877 * const HammerPriceDisplay = withSelect( ( select, ownProps ) => { 3878 * const { getPrice } = select( 'my-shop' ); 3879 * const { currency } = ownProps; 3880 * 3881 * return { 3882 * price: getPrice( 'hammer', currency ), 3883 * }; 3884 * } )( PriceDisplay ); 3885 * 3886 * // Rendered in the application: 3887 * // 3888 * // <HammerPriceDisplay currency="USD" /> 3889 * ``` 3890 * In the above example, when `HammerPriceDisplay` is rendered into an 3891 * application, it will pass the price into the underlying `PriceDisplay` 3892 * component and update automatically if the price of a hammer ever changes in 3893 * the store. 3894 * 3895 * @return {WPComponent} Enhanced component with merged state data props. 3896 */ 3897 3898 var with_select_withSelect = function withSelect(mapSelectToProps) { 3899 return Object(external_wp_compose_["createHigherOrderComponent"])(function (WrappedComponent) { 3900 return Object(external_wp_compose_["pure"])(function (ownProps) { 3901 var mapSelect = function mapSelect(select, registry) { 3902 return mapSelectToProps(select, ownProps, registry); 3903 }; 3904 3905 var mergeProps = useSelect(mapSelect); 3906 return Object(external_wp_element_["createElement"])(WrappedComponent, Object(esm_extends["a" /* default */])({}, ownProps, mergeProps)); 3907 }); 3908 }, 'withSelect'); 3909 }; 3910 3911 /* harmony default export */ var with_select = (with_select_withSelect); 3912 3913 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/components/use-dispatch/use-dispatch-with-map.js 3914 3915 3916 /** 3917 * External dependencies 3918 */ 3919 3920 /** 3921 * WordPress dependencies 3922 */ 3923 3924 3925 3926 /** 3927 * Internal dependencies 3928 */ 3929 3930 3931 /** 3932 * Custom react hook for returning aggregate dispatch actions using the provided 3933 * dispatchMap. 3934 * 3935 * Currently this is an internal api only and is implemented by `withDispatch` 3936 * 3937 * @param {Function} dispatchMap Receives the `registry.dispatch` function as 3938 * the first argument and the `registry` object 3939 * as the second argument. Should return an 3940 * object mapping props to functions. 3941 * @param {Array} deps An array of dependencies for the hook. 3942 * @return {Object} An object mapping props to functions created by the passed 3943 * in dispatchMap. 3944 */ 3945 3946 var use_dispatch_with_map_useDispatchWithMap = function useDispatchWithMap(dispatchMap, deps) { 3947 var registry = useRegistry(); 3948 var currentDispatchMap = Object(external_wp_element_["useRef"])(dispatchMap); 3949 Object(external_wp_compose_["useIsomorphicLayoutEffect"])(function () { 3950 currentDispatchMap.current = dispatchMap; 3951 }); 3952 return Object(external_wp_element_["useMemo"])(function () { 3953 var currentDispatchProps = currentDispatchMap.current(registry.dispatch, registry); 3954 return Object(external_lodash_["mapValues"])(currentDispatchProps, function (dispatcher, propName) { 3955 if (typeof dispatcher !== 'function') { 3956 // eslint-disable-next-line no-console 3957 console.warn("Property ".concat(propName, " returned from dispatchMap in useDispatchWithMap must be a function.")); 3958 } 3959 3960 return function () { 3961 var _currentDispatchMap$c; 3962 3963 return (_currentDispatchMap$c = currentDispatchMap.current(registry.dispatch, registry))[propName].apply(_currentDispatchMap$c, arguments); 3964 }; 3965 }); 3966 }, [registry].concat(Object(toConsumableArray["a" /* default */])(deps))); 3967 }; 3968 3969 /* harmony default export */ var use_dispatch_with_map = (use_dispatch_with_map_useDispatchWithMap); 3970 3971 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/components/with-dispatch/index.js 3972 3973 3974 3975 /** 3976 * WordPress dependencies 3977 */ 3978 3979 /** 3980 * Internal dependencies 3981 */ 3982 3983 3984 /** 3985 * Higher-order component used to add dispatch props using registered action 3986 * creators. 3987 * 3988 * @param {Function} mapDispatchToProps A function of returning an object of 3989 * prop names where value is a 3990 * dispatch-bound action creator, or a 3991 * function to be called with the 3992 * component's props and returning an 3993 * action creator. 3994 * 3995 * @example 3996 * ```jsx 3997 * function Button( { onClick, children } ) { 3998 * return <button type="button" onClick={ onClick }>{ children }</button>; 3999 * } 4000 * 4001 * import { withDispatch } from '@wordpress/data'; 4002 * 4003 * const SaleButton = withDispatch( ( dispatch, ownProps ) => { 4004 * const { startSale } = dispatch( 'my-shop' ); 4005 * const { discountPercent } = ownProps; 4006 * 4007 * return { 4008 * onClick() { 4009 * startSale( discountPercent ); 4010 * }, 4011 * }; 4012 * } )( Button ); 4013 * 4014 * // Rendered in the application: 4015 * // 4016 * // <SaleButton discountPercent="20">Start Sale!</SaleButton> 4017 * ``` 4018 * 4019 * @example 4020 * In the majority of cases, it will be sufficient to use only two first params 4021 * passed to `mapDispatchToProps` as illustrated in the previous example. 4022 * However, there might be some very advanced use cases where using the 4023 * `registry` object might be used as a tool to optimize the performance of 4024 * your component. Using `select` function from the registry might be useful 4025 * when you need to fetch some dynamic data from the store at the time when the 4026 * event is fired, but at the same time, you never use it to render your 4027 * component. In such scenario, you can avoid using the `withSelect` higher 4028 * order component to compute such prop, which might lead to unnecessary 4029 * re-renders of your component caused by its frequent value change. 4030 * Keep in mind, that `mapDispatchToProps` must return an object with functions 4031 * only. 4032 * 4033 * ```jsx 4034 * function Button( { onClick, children } ) { 4035 * return <button type="button" onClick={ onClick }>{ children }</button>; 4036 * } 4037 * 4038 * import { withDispatch } from '@wordpress/data'; 4039 * 4040 * const SaleButton = withDispatch( ( dispatch, ownProps, { select } ) => { 4041 * // Stock number changes frequently. 4042 * const { getStockNumber } = select( 'my-shop' ); 4043 * const { startSale } = dispatch( 'my-shop' ); 4044 * return { 4045 * onClick() { 4046 * const discountPercent = getStockNumber() > 50 ? 10 : 20; 4047 * startSale( discountPercent ); 4048 * }, 4049 * }; 4050 * } )( Button ); 4051 * 4052 * // Rendered in the application: 4053 * // 4054 * // <SaleButton>Start Sale!</SaleButton> 4055 * ``` 4056 * 4057 * _Note:_ It is important that the `mapDispatchToProps` function always 4058 * returns an object with the same keys. For example, it should not contain 4059 * conditions under which a different value would be returned. 4060 * 4061 * @return {WPComponent} Enhanced component with merged dispatcher props. 4062 */ 4063 4064 var with_dispatch_withDispatch = function withDispatch(mapDispatchToProps) { 4065 return Object(external_wp_compose_["createHigherOrderComponent"])(function (WrappedComponent) { 4066 return function (ownProps) { 4067 var mapDispatch = function mapDispatch(dispatch, registry) { 4068 return mapDispatchToProps(dispatch, ownProps, registry); 4069 }; 4070 4071 var dispatchProps = use_dispatch_with_map(mapDispatch, []); 4072 return Object(external_wp_element_["createElement"])(WrappedComponent, Object(esm_extends["a" /* default */])({}, ownProps, dispatchProps)); 4073 }; 4074 }, 'withDispatch'); 4075 }; 4076 4077 /* harmony default export */ var with_dispatch = (with_dispatch_withDispatch); 4078 4079 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/components/with-registry/index.js 4080 4081 4082 4083 /** 4084 * WordPress dependencies 4085 */ 4086 4087 /** 4088 * Internal dependencies 4089 */ 4090 4091 4092 /** 4093 * Higher-order component which renders the original component with the current 4094 * registry context passed as its `registry` prop. 4095 * 4096 * @param {WPComponent} OriginalComponent Original component. 4097 * 4098 * @return {WPComponent} Enhanced component. 4099 */ 4100 4101 var withRegistry = Object(external_wp_compose_["createHigherOrderComponent"])(function (OriginalComponent) { 4102 return function (props) { 4103 return Object(external_wp_element_["createElement"])(RegistryConsumer, null, function (registry) { 4104 return Object(external_wp_element_["createElement"])(OriginalComponent, Object(esm_extends["a" /* default */])({}, props, { 4105 registry: registry 4106 })); 4107 }); 4108 }; 4109 }, 'withRegistry'); 4110 /* harmony default export */ var with_registry = (withRegistry); 4111 4112 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/components/use-dispatch/use-dispatch.js 4113 /** 4114 * Internal dependencies 4115 */ 4116 4117 /** @typedef {import('./types').WPDataStore} WPDataStore */ 4118 4119 /** 4120 * A custom react hook returning the current registry dispatch actions creators. 4121 * 4122 * Note: The component using this hook must be within the context of a 4123 * RegistryProvider. 4124 * 4125 * @param {string|WPDataStore} [storeNameOrDefinition] Optionally provide the name of the 4126 * store or its definition from which to 4127 * retrieve action creators. If not 4128 * provided, the registry.dispatch 4129 * function is returned instead. 4130 * 4131 * @example 4132 * This illustrates a pattern where you may need to retrieve dynamic data from 4133 * the server via the `useSelect` hook to use in combination with the dispatch 4134 * action. 4135 * 4136 * ```jsx 4137 * import { useDispatch, useSelect } from '@wordpress/data'; 4138 * import { useCallback } from '@wordpress/element'; 4139 * 4140 * function Button( { onClick, children } ) { 4141 * return <button type="button" onClick={ onClick }>{ children }</button> 4142 * } 4143 * 4144 * const SaleButton = ( { children } ) => { 4145 * const { stockNumber } = useSelect( 4146 * ( select ) => select( 'my-shop' ).getStockNumber(), 4147 * [] 4148 * ); 4149 * const { startSale } = useDispatch( 'my-shop' ); 4150 * const onClick = useCallback( () => { 4151 * const discountPercent = stockNumber > 50 ? 10: 20; 4152 * startSale( discountPercent ); 4153 * }, [ stockNumber ] ); 4154 * return <Button onClick={ onClick }>{ children }</Button> 4155 * } 4156 * 4157 * // Rendered somewhere in the application: 4158 * // 4159 * // <SaleButton>Start Sale!</SaleButton> 4160 * ``` 4161 * @return {Function} A custom react hook. 4162 */ 4163 4164 var use_dispatch_useDispatch = function useDispatch(storeNameOrDefinition) { 4165 var _useRegistry = useRegistry(), 4166 dispatch = _useRegistry.dispatch; 4167 4168 return storeNameOrDefinition === void 0 ? dispatch : dispatch(storeNameOrDefinition); 4169 }; 4170 4171 /* harmony default export */ var use_dispatch = (use_dispatch_useDispatch); 4172 4173 // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/index.js 4174 /** 4175 * External dependencies 4176 */ 4177 4178 /** 4179 * Internal dependencies 4180 */ 4181 4182 4183 4184 /** @typedef {import('./types').WPDataStore} WPDataStore */ 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 /** 4198 * Object of available plugins to use with a registry. 4199 * 4200 * @see [use](#use) 4201 * 4202 * @type {Object} 4203 */ 4204 4205 4206 /** 4207 * The combineReducers helper function turns an object whose values are different 4208 * reducing functions into a single reducing function you can pass to registerReducer. 4209 * 4210 * @param {Object} reducers An object whose values correspond to different reducing 4211 * functions that need to be combined into one. 4212 * 4213 * @example 4214 * ```js 4215 * import { combineReducers, createReduxStore, register } from '@wordpress/data'; 4216 * 4217 * const prices = ( state = {}, action ) => { 4218 * return action.type === 'SET_PRICE' ? 4219 * { 4220 * ...state, 4221 * [ action.item ]: action.price, 4222 * } : 4223 * state; 4224 * }; 4225 * 4226 * const discountPercent = ( state = 0, action ) => { 4227 * return action.type === 'START_SALE' ? 4228 * action.discountPercent : 4229 * state; 4230 * }; 4231 * 4232 * const store = createReduxStore( 'my-shop', { 4233 * reducer: combineReducers( { 4234 * prices, 4235 * discountPercent, 4236 * } ), 4237 * } ); 4238 * register( store ); 4239 * ``` 4240 * 4241 * @return {Function} A reducer that invokes every reducer inside the reducers 4242 * object, and constructs a state object with the same shape. 4243 */ 4244 4245 4246 /** 4247 * Given the name or definition of a registered store, returns an object of the store's selectors. 4248 * The selector functions are been pre-bound to pass the current state automatically. 4249 * As a consumer, you need only pass arguments of the selector, if applicable. 4250 * 4251 * @param {string|WPDataStore} storeNameOrDefinition Unique namespace identifier for the store 4252 * or the store definition. 4253 * 4254 * @example 4255 * ```js 4256 * import { select } from '@wordpress/data'; 4257 * 4258 * select( 'my-shop' ).getPrice( 'hammer' ); 4259 * ``` 4260 * 4261 * @return {Object} Object containing the store's selectors. 4262 */ 4263 4264 var build_module_select = default_registry.select; 4265 /** 4266 * Given the name of a registered store, returns an object containing the store's 4267 * selectors pre-bound to state so that you only need to supply additional arguments, 4268 * and modified so that they return promises that resolve to their eventual values, 4269 * after any resolvers have ran. 4270 * 4271 * @param {string|WPDataStore} storeNameOrDefinition Unique namespace identifier for the store 4272 * or the store definition. 4273 * 4274 * @example 4275 * ```js 4276 * import { __experimentalResolveSelect } from '@wordpress/data'; 4277 * 4278 * __experimentalResolveSelect( 'my-shop' ).getPrice( 'hammer' ).then(console.log) 4279 * ``` 4280 * 4281 * @return {Object} Object containing the store's promise-wrapped selectors. 4282 */ 4283 4284 var build_module_experimentalResolveSelect = default_registry.__experimentalResolveSelect; 4285 /** 4286 * Given the name of a registered store, returns an object of the store's action creators. 4287 * Calling an action creator will cause it to be dispatched, updating the state value accordingly. 4288 * 4289 * Note: Action creators returned by the dispatch will return a promise when 4290 * they are called. 4291 * 4292 * @param {string|WPDataStore} storeNameOrDefinition Unique namespace identifier for the store 4293 * or the store definition. 4294 * 4295 * @example 4296 * ```js 4297 * import { dispatch } from '@wordpress/data'; 4298 * 4299 * dispatch( 'my-shop' ).setPrice( 'hammer', 9.75 ); 4300 * ``` 4301 * @return {Object} Object containing the action creators. 4302 */ 4303 4304 var build_module_dispatch = default_registry.dispatch; 4305 /** 4306 * Given a listener function, the function will be called any time the state value 4307 * of one of the registered stores has changed. This function returns a `unsubscribe` 4308 * function used to stop the subscription. 4309 * 4310 * @param {Function} listener Callback function. 4311 * 4312 * @example 4313 * ```js 4314 * import { subscribe } from '@wordpress/data'; 4315 * 4316 * const unsubscribe = subscribe( () => { 4317 * // You could use this opportunity to test whether the derived result of a 4318 * // selector has subsequently changed as the result of a state update. 4319 * } ); 4320 * 4321 * // Later, if necessary... 4322 * unsubscribe(); 4323 * ``` 4324 */ 4325 4326 var build_module_subscribe = default_registry.subscribe; 4327 /** 4328 * Registers a generic store. 4329 * 4330 * @deprecated Use `register` instead. 4331 * 4332 * @param {string} key Store registry key. 4333 * @param {Object} config Configuration (getSelectors, getActions, subscribe). 4334 */ 4335 4336 var build_module_registerGenericStore = default_registry.registerGenericStore; 4337 /** 4338 * Registers a standard `@wordpress/data` store. 4339 * 4340 * @deprecated Use `register` instead. 4341 * 4342 * @param {string} storeName Unique namespace identifier for the store. 4343 * @param {Object} options Store description (reducer, actions, selectors, resolvers). 4344 * 4345 * @return {Object} Registered store object. 4346 */ 4347 4348 var build_module_registerStore = default_registry.registerStore; 4349 /** 4350 * Extends a registry to inherit functionality provided by a given plugin. A 4351 * plugin is an object with properties aligning to that of a registry, merged 4352 * to extend the default registry behavior. 4353 * 4354 * @param {Object} plugin Plugin object. 4355 */ 4356 4357 var build_module_use = default_registry.use; 4358 /** 4359 * Registers a standard `@wordpress/data` store definition. 4360 * 4361 * @example 4362 * ```js 4363 * import { createReduxStore, register } from '@wordpress/data'; 4364 * 4365 * const store = createReduxStore( 'demo', { 4366 * reducer: ( state = 'OK' ) => state, 4367 * selectors: { 4368 * getValue: ( state ) => state, 4369 * }, 4370 * } ); 4371 * register( store ); 4372 * ``` 4373 * 4374 * @param {WPDataStore} store Store definition. 4375 */ 4376 4377 var build_module_register = default_registry.register; 4378 4379 4380 /***/ }), 4381 4382 /***/ 47: 4383 /***/ (function(module, __webpack_exports__, __webpack_require__) { 4384 4385 "use strict"; 4386 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _asyncToGenerator; }); 4387 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { 4388 try { 4389 var info = gen[key](arg); 4390 var value = info.value; 4391 } catch (error) { 4392 reject(error); 4393 return; 4394 } 4395 4396 if (info.done) { 4397 resolve(value); 4398 } else { 4399 Promise.resolve(value).then(_next, _throw); 4400 } 4401 } 4402 4403 function _asyncToGenerator(fn) { 4404 return function () { 4405 var self = this, 4406 args = arguments; 4407 return new Promise(function (resolve, reject) { 4408 var gen = fn.apply(self, args); 4409 4410 function _next(value) { 4411 asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); 4412 } 4413 4414 function _throw(err) { 4415 asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); 4416 } 4417 4418 _next(undefined); 4419 }); 4420 }; 4421 } 4422 4423 /***/ }), 4424 4425 /***/ 5: 4426 /***/ (function(module, __webpack_exports__, __webpack_require__) { 4427 4428 "use strict"; 4429 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _defineProperty; }); 4430 function _defineProperty(obj, key, value) { 4431 if (key in obj) { 4432 Object.defineProperty(obj, key, { 4433 value: value, 4434 enumerable: true, 4435 configurable: true, 4436 writable: true 4437 }); 4438 } else { 4439 obj[key] = value; 4440 } 4441 4442 return obj; 4443 } 4444 4445 /***/ }), 4446 4447 /***/ 63: 4448 /***/ (function(module, exports) { 4449 4450 (function() { module.exports = window["wp"]["isShallowEqual"]; }()); 4451 4452 /***/ }), 4453 4454 /***/ 8: 4455 /***/ (function(module, __webpack_exports__, __webpack_require__) { 4456 4457 "use strict"; 4458 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _extends; }); 4459 function _extends() { 4460 _extends = Object.assign || function (target) { 4461 for (var i = 1; i < arguments.length; i++) { 4462 var source = arguments[i]; 4463 4464 for (var key in source) { 4465 if (Object.prototype.hasOwnProperty.call(source, key)) { 4466 target[key] = source[key]; 4467 } 4468 } 4469 } 4470 4471 return target; 4472 }; 4473 4474 return _extends.apply(this, arguments); 4475 } 4476 4477 /***/ }) 4478 4479 /******/ });
title
Description
Body
title
Description
Body
title
Description
Body
title
Body
| Generated: Thu Mar 4 01:00:04 2021 | Cross-referenced by PHPXref 0.7.1 |