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