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