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