| [ Index ] |
PHP Cross Reference of WordPress |
[Summary view] [Print] [Text view]
1 this["wp"] = this["wp"] || {}; this["wp"]["coreData"] = 2 /******/ (function(modules) { // webpackBootstrap 3 /******/ // The module cache 4 /******/ var installedModules = {}; 5 /******/ 6 /******/ // The require function 7 /******/ function __webpack_require__(moduleId) { 8 /******/ 9 /******/ // Check if module is in cache 10 /******/ if(installedModules[moduleId]) { 11 /******/ return installedModules[moduleId].exports; 12 /******/ } 13 /******/ // Create a new module (and put it into the cache) 14 /******/ var module = installedModules[moduleId] = { 15 /******/ i: moduleId, 16 /******/ l: false, 17 /******/ exports: {} 18 /******/ }; 19 /******/ 20 /******/ // Execute the module function 21 /******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); 22 /******/ 23 /******/ // Flag the module as loaded 24 /******/ module.l = true; 25 /******/ 26 /******/ // Return the exports of the module 27 /******/ return module.exports; 28 /******/ } 29 /******/ 30 /******/ 31 /******/ // expose the modules object (__webpack_modules__) 32 /******/ __webpack_require__.m = modules; 33 /******/ 34 /******/ // expose the module cache 35 /******/ __webpack_require__.c = installedModules; 36 /******/ 37 /******/ // define getter function for harmony exports 38 /******/ __webpack_require__.d = function(exports, name, getter) { 39 /******/ if(!__webpack_require__.o(exports, name)) { 40 /******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); 41 /******/ } 42 /******/ }; 43 /******/ 44 /******/ // define __esModule on exports 45 /******/ __webpack_require__.r = function(exports) { 46 /******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { 47 /******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); 48 /******/ } 49 /******/ Object.defineProperty(exports, '__esModule', { value: true }); 50 /******/ }; 51 /******/ 52 /******/ // create a fake namespace object 53 /******/ // mode & 1: value is a module id, require it 54 /******/ // mode & 2: merge all properties of value into the ns 55 /******/ // mode & 4: return value when already ns object 56 /******/ // mode & 8|1: behave like require 57 /******/ __webpack_require__.t = function(value, mode) { 58 /******/ if(mode & 1) value = __webpack_require__(value); 59 /******/ if(mode & 8) return value; 60 /******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; 61 /******/ var ns = Object.create(null); 62 /******/ __webpack_require__.r(ns); 63 /******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); 64 /******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); 65 /******/ return ns; 66 /******/ }; 67 /******/ 68 /******/ // getDefaultExport function for compatibility with non-harmony modules 69 /******/ __webpack_require__.n = function(module) { 70 /******/ var getter = module && module.__esModule ? 71 /******/ function getDefault() { return module['default']; } : 72 /******/ function getModuleExports() { return module; }; 73 /******/ __webpack_require__.d(getter, 'a', getter); 74 /******/ return getter; 75 /******/ }; 76 /******/ 77 /******/ // Object.prototype.hasOwnProperty.call 78 /******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; 79 /******/ 80 /******/ // __webpack_public_path__ 81 /******/ __webpack_require__.p = ""; 82 /******/ 83 /******/ 84 /******/ // Load entry module and return exports 85 /******/ return __webpack_require__(__webpack_require__.s = 444); 86 /******/ }) 87 /************************************************************************/ 88 /******/ ({ 89 90 /***/ 0: 91 /***/ (function(module, exports) { 92 93 (function() { module.exports = this["wp"]["element"]; }()); 94 95 /***/ }), 96 97 /***/ 1: 98 /***/ (function(module, exports) { 99 100 (function() { module.exports = this["wp"]["i18n"]; }()); 101 102 /***/ }), 103 104 /***/ 118: 105 /***/ (function(module, exports, __webpack_require__) { 106 107 "use strict"; 108 109 110 function _typeof(obj) { 111 if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { 112 _typeof = function (obj) { 113 return typeof obj; 114 }; 115 } else { 116 _typeof = function (obj) { 117 return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; 118 }; 119 } 120 121 return _typeof(obj); 122 } 123 124 function _classCallCheck(instance, Constructor) { 125 if (!(instance instanceof Constructor)) { 126 throw new TypeError("Cannot call a class as a function"); 127 } 128 } 129 130 function _defineProperties(target, props) { 131 for (var i = 0; i < props.length; i++) { 132 var descriptor = props[i]; 133 descriptor.enumerable = descriptor.enumerable || false; 134 descriptor.configurable = true; 135 if ("value" in descriptor) descriptor.writable = true; 136 Object.defineProperty(target, descriptor.key, descriptor); 137 } 138 } 139 140 function _createClass(Constructor, protoProps, staticProps) { 141 if (protoProps) _defineProperties(Constructor.prototype, protoProps); 142 if (staticProps) _defineProperties(Constructor, staticProps); 143 return Constructor; 144 } 145 146 /** 147 * Given an instance of EquivalentKeyMap, returns its internal value pair tuple 148 * for a key, if one exists. The tuple members consist of the last reference 149 * value for the key (used in efficient subsequent lookups) and the value 150 * assigned for the key at the leaf node. 151 * 152 * @param {EquivalentKeyMap} instance EquivalentKeyMap instance. 153 * @param {*} key The key for which to return value pair. 154 * 155 * @return {?Array} Value pair, if exists. 156 */ 157 function getValuePair(instance, key) { 158 var _map = instance._map, 159 _arrayTreeMap = instance._arrayTreeMap, 160 _objectTreeMap = instance._objectTreeMap; // Map keeps a reference to the last object-like key used to set the 161 // value, which can be used to shortcut immediately to the value. 162 163 if (_map.has(key)) { 164 return _map.get(key); 165 } // Sort keys to ensure stable retrieval from tree. 166 167 168 var properties = Object.keys(key).sort(); // Tree by type to avoid conflicts on numeric object keys, empty value. 169 170 var map = Array.isArray(key) ? _arrayTreeMap : _objectTreeMap; 171 172 for (var i = 0; i < properties.length; i++) { 173 var property = properties[i]; 174 map = map.get(property); 175 176 if (map === undefined) { 177 return; 178 } 179 180 var propertyValue = key[property]; 181 map = map.get(propertyValue); 182 183 if (map === undefined) { 184 return; 185 } 186 } 187 188 var valuePair = map.get('_ekm_value'); 189 190 if (!valuePair) { 191 return; 192 } // If reached, it implies that an object-like key was set with another 193 // reference, so delete the reference and replace with the current. 194 195 196 _map.delete(valuePair[0]); 197 198 valuePair[0] = key; 199 map.set('_ekm_value', valuePair); 200 201 _map.set(key, valuePair); 202 203 return valuePair; 204 } 205 /** 206 * Variant of a Map object which enables lookup by equivalent (deeply equal) 207 * object and array keys. 208 */ 209 210 211 var EquivalentKeyMap = 212 /*#__PURE__*/ 213 function () { 214 /** 215 * Constructs a new instance of EquivalentKeyMap. 216 * 217 * @param {Iterable.<*>} iterable Initial pair of key, value for map. 218 */ 219 function EquivalentKeyMap(iterable) { 220 _classCallCheck(this, EquivalentKeyMap); 221 222 this.clear(); 223 224 if (iterable instanceof EquivalentKeyMap) { 225 // Map#forEach is only means of iterating with support for IE11. 226 var iterablePairs = []; 227 iterable.forEach(function (value, key) { 228 iterablePairs.push([key, value]); 229 }); 230 iterable = iterablePairs; 231 } 232 233 if (iterable != null) { 234 for (var i = 0; i < iterable.length; i++) { 235 this.set(iterable[i][0], iterable[i][1]); 236 } 237 } 238 } 239 /** 240 * Accessor property returning the number of elements. 241 * 242 * @return {number} Number of elements. 243 */ 244 245 246 _createClass(EquivalentKeyMap, [{ 247 key: "set", 248 249 /** 250 * Add or update an element with a specified key and value. 251 * 252 * @param {*} key The key of the element to add. 253 * @param {*} value The value of the element to add. 254 * 255 * @return {EquivalentKeyMap} Map instance. 256 */ 257 value: function set(key, value) { 258 // Shortcut non-object-like to set on internal Map. 259 if (key === null || _typeof(key) !== 'object') { 260 this._map.set(key, value); 261 262 return this; 263 } // Sort keys to ensure stable assignment into tree. 264 265 266 var properties = Object.keys(key).sort(); 267 var valuePair = [key, value]; // Tree by type to avoid conflicts on numeric object keys, empty value. 268 269 var map = Array.isArray(key) ? this._arrayTreeMap : this._objectTreeMap; 270 271 for (var i = 0; i < properties.length; i++) { 272 var property = properties[i]; 273 274 if (!map.has(property)) { 275 map.set(property, new EquivalentKeyMap()); 276 } 277 278 map = map.get(property); 279 var propertyValue = key[property]; 280 281 if (!map.has(propertyValue)) { 282 map.set(propertyValue, new EquivalentKeyMap()); 283 } 284 285 map = map.get(propertyValue); 286 } // If an _ekm_value exists, there was already an equivalent key. Before 287 // overriding, ensure that the old key reference is removed from map to 288 // avoid memory leak of accumulating equivalent keys. This is, in a 289 // sense, a poor man's WeakMap, while still enabling iterability. 290 291 292 var previousValuePair = map.get('_ekm_value'); 293 294 if (previousValuePair) { 295 this._map.delete(previousValuePair[0]); 296 } 297 298 map.set('_ekm_value', valuePair); 299 300 this._map.set(key, valuePair); 301 302 return this; 303 } 304 /** 305 * Returns a specified element. 306 * 307 * @param {*} key The key of the element to return. 308 * 309 * @return {?*} The element associated with the specified key or undefined 310 * if the key can't be found. 311 */ 312 313 }, { 314 key: "get", 315 value: function get(key) { 316 // Shortcut non-object-like to get from internal Map. 317 if (key === null || _typeof(key) !== 'object') { 318 return this._map.get(key); 319 } 320 321 var valuePair = getValuePair(this, key); 322 323 if (valuePair) { 324 return valuePair[1]; 325 } 326 } 327 /** 328 * Returns a boolean indicating whether an element with the specified key 329 * exists or not. 330 * 331 * @param {*} key The key of the element to test for presence. 332 * 333 * @return {boolean} Whether an element with the specified key exists. 334 */ 335 336 }, { 337 key: "has", 338 value: function has(key) { 339 if (key === null || _typeof(key) !== 'object') { 340 return this._map.has(key); 341 } // Test on the _presence_ of the pair, not its value, as even undefined 342 // can be a valid member value for a key. 343 344 345 return getValuePair(this, key) !== undefined; 346 } 347 /** 348 * Removes the specified element. 349 * 350 * @param {*} key The key of the element to remove. 351 * 352 * @return {boolean} Returns true if an element existed and has been 353 * removed, or false if the element does not exist. 354 */ 355 356 }, { 357 key: "delete", 358 value: function _delete(key) { 359 if (!this.has(key)) { 360 return false; 361 } // This naive implementation will leave orphaned child trees. A better 362 // implementation should traverse and remove orphans. 363 364 365 this.set(key, undefined); 366 return true; 367 } 368 /** 369 * Executes a provided function once per each key/value pair, in insertion 370 * order. 371 * 372 * @param {Function} callback Function to execute for each element. 373 * @param {*} thisArg Value to use as `this` when executing 374 * `callback`. 375 */ 376 377 }, { 378 key: "forEach", 379 value: function forEach(callback) { 380 var _this = this; 381 382 var thisArg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this; 383 384 this._map.forEach(function (value, key) { 385 // Unwrap value from object-like value pair. 386 if (key !== null && _typeof(key) === 'object') { 387 value = value[1]; 388 } 389 390 callback.call(thisArg, value, key, _this); 391 }); 392 } 393 /** 394 * Removes all elements. 395 */ 396 397 }, { 398 key: "clear", 399 value: function clear() { 400 this._map = new Map(); 401 this._arrayTreeMap = new Map(); 402 this._objectTreeMap = new Map(); 403 } 404 }, { 405 key: "size", 406 get: function get() { 407 return this._map.size; 408 } 409 }]); 410 411 return EquivalentKeyMap; 412 }(); 413 414 module.exports = EquivalentKeyMap; 415 416 417 /***/ }), 418 419 /***/ 12: 420 /***/ (function(module, exports) { 421 422 (function() { module.exports = this["wp"]["blocks"]; }()); 423 424 /***/ }), 425 426 /***/ 15: 427 /***/ (function(module, __webpack_exports__, __webpack_require__) { 428 429 "use strict"; 430 431 // EXPORTS 432 __webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ _slicedToArray; }); 433 434 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js 435 var arrayWithHoles = __webpack_require__(38); 436 437 // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js 438 function _iterableToArrayLimit(arr, i) { 439 if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; 440 var _arr = []; 441 var _n = true; 442 var _d = false; 443 var _e = undefined; 444 445 try { 446 for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { 447 _arr.push(_s.value); 448 449 if (i && _arr.length === i) break; 450 } 451 } catch (err) { 452 _d = true; 453 _e = err; 454 } finally { 455 try { 456 if (!_n && _i["return"] != null) _i["return"](); 457 } finally { 458 if (_d) throw _e; 459 } 460 } 461 462 return _arr; 463 } 464 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js 465 var unsupportedIterableToArray = __webpack_require__(28); 466 467 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js 468 var nonIterableRest = __webpack_require__(39); 469 470 // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js 471 472 473 474 475 function _slicedToArray(arr, i) { 476 return Object(arrayWithHoles["a" /* default */])(arr) || _iterableToArrayLimit(arr, i) || Object(unsupportedIterableToArray["a" /* default */])(arr, i) || Object(nonIterableRest["a" /* default */])(); 477 } 478 479 /***/ }), 480 481 /***/ 16: 482 /***/ (function(module, __webpack_exports__, __webpack_require__) { 483 484 "use strict"; 485 486 // EXPORTS 487 __webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ _toConsumableArray; }); 488 489 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js 490 var arrayLikeToArray = __webpack_require__(26); 491 492 // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js 493 494 function _arrayWithoutHoles(arr) { 495 if (Array.isArray(arr)) return Object(arrayLikeToArray["a" /* default */])(arr); 496 } 497 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArray.js 498 var iterableToArray = __webpack_require__(35); 499 500 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js 501 var unsupportedIterableToArray = __webpack_require__(28); 502 503 // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js 504 function _nonIterableSpread() { 505 throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); 506 } 507 // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js 508 509 510 511 512 function _toConsumableArray(arr) { 513 return _arrayWithoutHoles(arr) || Object(iterableToArray["a" /* default */])(arr) || Object(unsupportedIterableToArray["a" /* default */])(arr) || _nonIterableSpread(); 514 } 515 516 /***/ }), 517 518 /***/ 2: 519 /***/ (function(module, exports) { 520 521 (function() { module.exports = this["lodash"]; }()); 522 523 /***/ }), 524 525 /***/ 23: 526 /***/ (function(module, exports) { 527 528 (function() { module.exports = this["regeneratorRuntime"]; }()); 529 530 /***/ }), 531 532 /***/ 26: 533 /***/ (function(module, __webpack_exports__, __webpack_require__) { 534 535 "use strict"; 536 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayLikeToArray; }); 537 function _arrayLikeToArray(arr, len) { 538 if (len == null || len > arr.length) len = arr.length; 539 540 for (var i = 0, arr2 = new Array(len); i < len; i++) { 541 arr2[i] = arr[i]; 542 } 543 544 return arr2; 545 } 546 547 /***/ }), 548 549 /***/ 28: 550 /***/ (function(module, __webpack_exports__, __webpack_require__) { 551 552 "use strict"; 553 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _unsupportedIterableToArray; }); 554 /* harmony import */ var _arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(26); 555 556 function _unsupportedIterableToArray(o, minLen) { 557 if (!o) return; 558 if (typeof o === "string") return Object(_arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(o, minLen); 559 var n = Object.prototype.toString.call(o).slice(8, -1); 560 if (n === "Object" && o.constructor) n = o.constructor.name; 561 if (n === "Map" || n === "Set") return Array.from(o); 562 if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return Object(_arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(o, minLen); 563 } 564 565 /***/ }), 566 567 /***/ 30: 568 /***/ (function(module, exports) { 569 570 (function() { module.exports = this["wp"]["url"]; }()); 571 572 /***/ }), 573 574 /***/ 35: 575 /***/ (function(module, __webpack_exports__, __webpack_require__) { 576 577 "use strict"; 578 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _iterableToArray; }); 579 function _iterableToArray(iter) { 580 if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); 581 } 582 583 /***/ }), 584 585 /***/ 36: 586 /***/ (function(module, exports) { 587 588 (function() { module.exports = this["wp"]["dataControls"]; }()); 589 590 /***/ }), 591 592 /***/ 37: 593 /***/ (function(module, exports) { 594 595 (function() { module.exports = this["wp"]["deprecated"]; }()); 596 597 /***/ }), 598 599 /***/ 38: 600 /***/ (function(module, __webpack_exports__, __webpack_require__) { 601 602 "use strict"; 603 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayWithHoles; }); 604 function _arrayWithHoles(arr) { 605 if (Array.isArray(arr)) return arr; 606 } 607 608 /***/ }), 609 610 /***/ 39: 611 /***/ (function(module, __webpack_exports__, __webpack_require__) { 612 613 "use strict"; 614 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _nonIterableRest; }); 615 function _nonIterableRest() { 616 throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); 617 } 618 619 /***/ }), 620 621 /***/ 4: 622 /***/ (function(module, exports) { 623 624 (function() { module.exports = this["wp"]["data"]; }()); 625 626 /***/ }), 627 628 /***/ 41: 629 /***/ (function(module, __webpack_exports__, __webpack_require__) { 630 631 "use strict"; 632 633 634 var LEAF_KEY, hasWeakMap; 635 636 /** 637 * Arbitrary value used as key for referencing cache object in WeakMap tree. 638 * 639 * @type {Object} 640 */ 641 LEAF_KEY = {}; 642 643 /** 644 * Whether environment supports WeakMap. 645 * 646 * @type {boolean} 647 */ 648 hasWeakMap = typeof WeakMap !== 'undefined'; 649 650 /** 651 * Returns the first argument as the sole entry in an array. 652 * 653 * @param {*} value Value to return. 654 * 655 * @return {Array} Value returned as entry in array. 656 */ 657 function arrayOf( value ) { 658 return [ value ]; 659 } 660 661 /** 662 * Returns true if the value passed is object-like, or false otherwise. A value 663 * is object-like if it can support property assignment, e.g. object or array. 664 * 665 * @param {*} value Value to test. 666 * 667 * @return {boolean} Whether value is object-like. 668 */ 669 function isObjectLike( value ) { 670 return !! value && 'object' === typeof value; 671 } 672 673 /** 674 * Creates and returns a new cache object. 675 * 676 * @return {Object} Cache object. 677 */ 678 function createCache() { 679 var cache = { 680 clear: function() { 681 cache.head = null; 682 }, 683 }; 684 685 return cache; 686 } 687 688 /** 689 * Returns true if entries within the two arrays are strictly equal by 690 * reference from a starting index. 691 * 692 * @param {Array} a First array. 693 * @param {Array} b Second array. 694 * @param {number} fromIndex Index from which to start comparison. 695 * 696 * @return {boolean} Whether arrays are shallowly equal. 697 */ 698 function isShallowEqual( a, b, fromIndex ) { 699 var i; 700 701 if ( a.length !== b.length ) { 702 return false; 703 } 704 705 for ( i = fromIndex; i < a.length; i++ ) { 706 if ( a[ i ] !== b[ i ] ) { 707 return false; 708 } 709 } 710 711 return true; 712 } 713 714 /** 715 * Returns a memoized selector function. The getDependants function argument is 716 * called before the memoized selector and is expected to return an immutable 717 * reference or array of references on which the selector depends for computing 718 * its own return value. The memoize cache is preserved only as long as those 719 * dependant references remain the same. If getDependants returns a different 720 * reference(s), the cache is cleared and the selector value regenerated. 721 * 722 * @param {Function} selector Selector function. 723 * @param {Function} getDependants Dependant getter returning an immutable 724 * reference or array of reference used in 725 * cache bust consideration. 726 * 727 * @return {Function} Memoized selector. 728 */ 729 /* harmony default export */ __webpack_exports__["a"] = (function( selector, getDependants ) { 730 var rootCache, getCache; 731 732 // Use object source as dependant if getter not provided 733 if ( ! getDependants ) { 734 getDependants = arrayOf; 735 } 736 737 /** 738 * Returns the root cache. If WeakMap is supported, this is assigned to the 739 * root WeakMap cache set, otherwise it is a shared instance of the default 740 * cache object. 741 * 742 * @return {(WeakMap|Object)} Root cache object. 743 */ 744 function getRootCache() { 745 return rootCache; 746 } 747 748 /** 749 * Returns the cache for a given dependants array. When possible, a WeakMap 750 * will be used to create a unique cache for each set of dependants. This 751 * is feasible due to the nature of WeakMap in allowing garbage collection 752 * to occur on entries where the key object is no longer referenced. Since 753 * WeakMap requires the key to be an object, this is only possible when the 754 * dependant is object-like. The root cache is created as a hierarchy where 755 * each top-level key is the first entry in a dependants set, the value a 756 * WeakMap where each key is the next dependant, and so on. This continues 757 * so long as the dependants are object-like. If no dependants are object- 758 * like, then the cache is shared across all invocations. 759 * 760 * @see isObjectLike 761 * 762 * @param {Array} dependants Selector dependants. 763 * 764 * @return {Object} Cache object. 765 */ 766 function getWeakMapCache( dependants ) { 767 var caches = rootCache, 768 isUniqueByDependants = true, 769 i, dependant, map, cache; 770 771 for ( i = 0; i < dependants.length; i++ ) { 772 dependant = dependants[ i ]; 773 774 // Can only compose WeakMap from object-like key. 775 if ( ! isObjectLike( dependant ) ) { 776 isUniqueByDependants = false; 777 break; 778 } 779 780 // Does current segment of cache already have a WeakMap? 781 if ( caches.has( dependant ) ) { 782 // Traverse into nested WeakMap. 783 caches = caches.get( dependant ); 784 } else { 785 // Create, set, and traverse into a new one. 786 map = new WeakMap(); 787 caches.set( dependant, map ); 788 caches = map; 789 } 790 } 791 792 // We use an arbitrary (but consistent) object as key for the last item 793 // in the WeakMap to serve as our running cache. 794 if ( ! caches.has( LEAF_KEY ) ) { 795 cache = createCache(); 796 cache.isUniqueByDependants = isUniqueByDependants; 797 caches.set( LEAF_KEY, cache ); 798 } 799 800 return caches.get( LEAF_KEY ); 801 } 802 803 // Assign cache handler by availability of WeakMap 804 getCache = hasWeakMap ? getWeakMapCache : getRootCache; 805 806 /** 807 * Resets root memoization cache. 808 */ 809 function clear() { 810 rootCache = hasWeakMap ? new WeakMap() : createCache(); 811 } 812 813 // eslint-disable-next-line jsdoc/check-param-names 814 /** 815 * The augmented selector call, considering first whether dependants have 816 * changed before passing it to underlying memoize function. 817 * 818 * @param {Object} source Source object for derivation. 819 * @param {...*} extraArgs Additional arguments to pass to selector. 820 * 821 * @return {*} Selector result. 822 */ 823 function callSelector( /* source, ...extraArgs */ ) { 824 var len = arguments.length, 825 cache, node, i, args, dependants; 826 827 // Create copy of arguments (avoid leaking deoptimization). 828 args = new Array( len ); 829 for ( i = 0; i < len; i++ ) { 830 args[ i ] = arguments[ i ]; 831 } 832 833 dependants = getDependants.apply( null, args ); 834 cache = getCache( dependants ); 835 836 // If not guaranteed uniqueness by dependants (primitive type or lack 837 // of WeakMap support), shallow compare against last dependants and, if 838 // references have changed, destroy cache to recalculate result. 839 if ( ! cache.isUniqueByDependants ) { 840 if ( cache.lastDependants && ! isShallowEqual( dependants, cache.lastDependants, 0 ) ) { 841 cache.clear(); 842 } 843 844 cache.lastDependants = dependants; 845 } 846 847 node = cache.head; 848 while ( node ) { 849 // Check whether node arguments match arguments 850 if ( ! isShallowEqual( node.args, args, 1 ) ) { 851 node = node.next; 852 continue; 853 } 854 855 // At this point we can assume we've found a match 856 857 // Surface matched node to head if not already 858 if ( node !== cache.head ) { 859 // Adjust siblings to point to each other. 860 node.prev.next = node.next; 861 if ( node.next ) { 862 node.next.prev = node.prev; 863 } 864 865 node.next = cache.head; 866 node.prev = null; 867 cache.head.prev = node; 868 cache.head = node; 869 } 870 871 // Return immediately 872 return node.val; 873 } 874 875 // No cached value found. Continue to insertion phase: 876 877 node = { 878 // Generate the result from original function 879 val: selector.apply( null, args ), 880 }; 881 882 // Avoid including the source object in the cache. 883 args[ 0 ] = null; 884 node.args = args; 885 886 // Don't need to check whether node is already head, since it would 887 // have been returned above already if it was 888 889 // Shift existing head down list 890 if ( cache.head ) { 891 cache.head.prev = node; 892 node.next = cache.head; 893 } 894 895 cache.head = node; 896 897 return node.val; 898 } 899 900 callSelector.getDependants = getDependants; 901 callSelector.clear = clear; 902 clear(); 903 904 return callSelector; 905 }); 906 907 908 /***/ }), 909 910 /***/ 444: 911 /***/ (function(module, __webpack_exports__, __webpack_require__) { 912 913 "use strict"; 914 // ESM COMPAT FLAG 915 __webpack_require__.r(__webpack_exports__); 916 917 // EXPORTS 918 __webpack_require__.d(__webpack_exports__, "EntityProvider", function() { return /* reexport */ EntityProvider; }); 919 __webpack_require__.d(__webpack_exports__, "useEntityId", function() { return /* reexport */ useEntityId; }); 920 __webpack_require__.d(__webpack_exports__, "useEntityProp", function() { return /* reexport */ useEntityProp; }); 921 __webpack_require__.d(__webpack_exports__, "useEntityBlockEditor", function() { return /* reexport */ useEntityBlockEditor; }); 922 923 // NAMESPACE OBJECT: ./node_modules/@wordpress/core-data/build-module/actions.js 924 var build_module_actions_namespaceObject = {}; 925 __webpack_require__.r(build_module_actions_namespaceObject); 926 __webpack_require__.d(build_module_actions_namespaceObject, "receiveUserQuery", function() { return receiveUserQuery; }); 927 __webpack_require__.d(build_module_actions_namespaceObject, "receiveCurrentUser", function() { return receiveCurrentUser; }); 928 __webpack_require__.d(build_module_actions_namespaceObject, "addEntities", function() { return addEntities; }); 929 __webpack_require__.d(build_module_actions_namespaceObject, "receiveEntityRecords", function() { return receiveEntityRecords; }); 930 __webpack_require__.d(build_module_actions_namespaceObject, "receiveCurrentTheme", function() { return receiveCurrentTheme; }); 931 __webpack_require__.d(build_module_actions_namespaceObject, "receiveThemeSupports", function() { return receiveThemeSupports; }); 932 __webpack_require__.d(build_module_actions_namespaceObject, "receiveEmbedPreview", function() { return receiveEmbedPreview; }); 933 __webpack_require__.d(build_module_actions_namespaceObject, "editEntityRecord", function() { return actions_editEntityRecord; }); 934 __webpack_require__.d(build_module_actions_namespaceObject, "undo", function() { return undo; }); 935 __webpack_require__.d(build_module_actions_namespaceObject, "redo", function() { return redo; }); 936 __webpack_require__.d(build_module_actions_namespaceObject, "__unstableCreateUndoLevel", function() { return __unstableCreateUndoLevel; }); 937 __webpack_require__.d(build_module_actions_namespaceObject, "saveEntityRecord", function() { return saveEntityRecord; }); 938 __webpack_require__.d(build_module_actions_namespaceObject, "saveEditedEntityRecord", function() { return saveEditedEntityRecord; }); 939 __webpack_require__.d(build_module_actions_namespaceObject, "receiveUploadPermissions", function() { return receiveUploadPermissions; }); 940 __webpack_require__.d(build_module_actions_namespaceObject, "receiveUserPermission", function() { return receiveUserPermission; }); 941 __webpack_require__.d(build_module_actions_namespaceObject, "receiveAutosaves", function() { return receiveAutosaves; }); 942 943 // NAMESPACE OBJECT: ./node_modules/@wordpress/core-data/build-module/selectors.js 944 var build_module_selectors_namespaceObject = {}; 945 __webpack_require__.r(build_module_selectors_namespaceObject); 946 __webpack_require__.d(build_module_selectors_namespaceObject, "isRequestingEmbedPreview", function() { return isRequestingEmbedPreview; }); 947 __webpack_require__.d(build_module_selectors_namespaceObject, "getAuthors", function() { return getAuthors; }); 948 __webpack_require__.d(build_module_selectors_namespaceObject, "getCurrentUser", function() { return getCurrentUser; }); 949 __webpack_require__.d(build_module_selectors_namespaceObject, "getUserQueryResults", function() { return getUserQueryResults; }); 950 __webpack_require__.d(build_module_selectors_namespaceObject, "getEntitiesByKind", function() { return getEntitiesByKind; }); 951 __webpack_require__.d(build_module_selectors_namespaceObject, "getEntity", function() { return selectors_getEntity; }); 952 __webpack_require__.d(build_module_selectors_namespaceObject, "getEntityRecord", function() { return getEntityRecord; }); 953 __webpack_require__.d(build_module_selectors_namespaceObject, "__experimentalGetEntityRecordNoResolver", function() { return __experimentalGetEntityRecordNoResolver; }); 954 __webpack_require__.d(build_module_selectors_namespaceObject, "getRawEntityRecord", function() { return getRawEntityRecord; }); 955 __webpack_require__.d(build_module_selectors_namespaceObject, "getEntityRecords", function() { return getEntityRecords; }); 956 __webpack_require__.d(build_module_selectors_namespaceObject, "__experimentalGetDirtyEntityRecords", function() { return __experimentalGetDirtyEntityRecords; }); 957 __webpack_require__.d(build_module_selectors_namespaceObject, "getEntityRecordEdits", function() { return getEntityRecordEdits; }); 958 __webpack_require__.d(build_module_selectors_namespaceObject, "getEntityRecordNonTransientEdits", function() { return getEntityRecordNonTransientEdits; }); 959 __webpack_require__.d(build_module_selectors_namespaceObject, "hasEditsForEntityRecord", function() { return hasEditsForEntityRecord; }); 960 __webpack_require__.d(build_module_selectors_namespaceObject, "getEditedEntityRecord", function() { return getEditedEntityRecord; }); 961 __webpack_require__.d(build_module_selectors_namespaceObject, "isAutosavingEntityRecord", function() { return isAutosavingEntityRecord; }); 962 __webpack_require__.d(build_module_selectors_namespaceObject, "isSavingEntityRecord", function() { return isSavingEntityRecord; }); 963 __webpack_require__.d(build_module_selectors_namespaceObject, "getLastEntitySaveError", function() { return getLastEntitySaveError; }); 964 __webpack_require__.d(build_module_selectors_namespaceObject, "getUndoEdit", function() { return getUndoEdit; }); 965 __webpack_require__.d(build_module_selectors_namespaceObject, "getRedoEdit", function() { return getRedoEdit; }); 966 __webpack_require__.d(build_module_selectors_namespaceObject, "hasUndo", function() { return hasUndo; }); 967 __webpack_require__.d(build_module_selectors_namespaceObject, "hasRedo", function() { return hasRedo; }); 968 __webpack_require__.d(build_module_selectors_namespaceObject, "getCurrentTheme", function() { return getCurrentTheme; }); 969 __webpack_require__.d(build_module_selectors_namespaceObject, "getThemeSupports", function() { return getThemeSupports; }); 970 __webpack_require__.d(build_module_selectors_namespaceObject, "getEmbedPreview", function() { return getEmbedPreview; }); 971 __webpack_require__.d(build_module_selectors_namespaceObject, "isPreviewEmbedFallback", function() { return isPreviewEmbedFallback; }); 972 __webpack_require__.d(build_module_selectors_namespaceObject, "hasUploadPermissions", function() { return hasUploadPermissions; }); 973 __webpack_require__.d(build_module_selectors_namespaceObject, "canUser", function() { return canUser; }); 974 __webpack_require__.d(build_module_selectors_namespaceObject, "getAutosaves", function() { return getAutosaves; }); 975 __webpack_require__.d(build_module_selectors_namespaceObject, "getAutosave", function() { return getAutosave; }); 976 __webpack_require__.d(build_module_selectors_namespaceObject, "hasFetchedAutosaves", function() { return hasFetchedAutosaves; }); 977 __webpack_require__.d(build_module_selectors_namespaceObject, "getReferenceByDistinctEdits", function() { return getReferenceByDistinctEdits; }); 978 979 // NAMESPACE OBJECT: ./node_modules/@wordpress/core-data/build-module/resolvers.js 980 var resolvers_namespaceObject = {}; 981 __webpack_require__.r(resolvers_namespaceObject); 982 __webpack_require__.d(resolvers_namespaceObject, "getAuthors", function() { return resolvers_getAuthors; }); 983 __webpack_require__.d(resolvers_namespaceObject, "getCurrentUser", function() { return resolvers_getCurrentUser; }); 984 __webpack_require__.d(resolvers_namespaceObject, "getEntityRecord", function() { return resolvers_getEntityRecord; }); 985 __webpack_require__.d(resolvers_namespaceObject, "getRawEntityRecord", function() { return resolvers_getRawEntityRecord; }); 986 __webpack_require__.d(resolvers_namespaceObject, "getEditedEntityRecord", function() { return resolvers_getEditedEntityRecord; }); 987 __webpack_require__.d(resolvers_namespaceObject, "getEntityRecords", function() { return resolvers_getEntityRecords; }); 988 __webpack_require__.d(resolvers_namespaceObject, "getCurrentTheme", function() { return resolvers_getCurrentTheme; }); 989 __webpack_require__.d(resolvers_namespaceObject, "getThemeSupports", function() { return resolvers_getThemeSupports; }); 990 __webpack_require__.d(resolvers_namespaceObject, "getEmbedPreview", function() { return resolvers_getEmbedPreview; }); 991 __webpack_require__.d(resolvers_namespaceObject, "hasUploadPermissions", function() { return resolvers_hasUploadPermissions; }); 992 __webpack_require__.d(resolvers_namespaceObject, "canUser", function() { return resolvers_canUser; }); 993 __webpack_require__.d(resolvers_namespaceObject, "getAutosaves", function() { return resolvers_getAutosaves; }); 994 __webpack_require__.d(resolvers_namespaceObject, "getAutosave", function() { return resolvers_getAutosave; }); 995 996 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js 997 var defineProperty = __webpack_require__(5); 998 999 // EXTERNAL MODULE: external {"this":["wp","data"]} 1000 var external_this_wp_data_ = __webpack_require__(4); 1001 1002 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules 1003 var slicedToArray = __webpack_require__(15); 1004 1005 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + 2 modules 1006 var toConsumableArray = __webpack_require__(16); 1007 1008 // EXTERNAL MODULE: external {"this":"lodash"} 1009 var external_this_lodash_ = __webpack_require__(2); 1010 1011 // EXTERNAL MODULE: external {"this":["wp","isShallowEqual"]} 1012 var external_this_wp_isShallowEqual_ = __webpack_require__(55); 1013 var external_this_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_this_wp_isShallowEqual_); 1014 1015 // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/if-matching-action.js 1016 /** 1017 * A higher-order reducer creator which invokes the original reducer only if 1018 * the dispatching action matches the given predicate, **OR** if state is 1019 * initializing (undefined). 1020 * 1021 * @param {Function} isMatch Function predicate for allowing reducer call. 1022 * 1023 * @return {Function} Higher-order reducer. 1024 */ 1025 var ifMatchingAction = function ifMatchingAction(isMatch) { 1026 return function (reducer) { 1027 return function (state, action) { 1028 if (state === undefined || isMatch(action)) { 1029 return reducer(state, action); 1030 } 1031 1032 return state; 1033 }; 1034 }; 1035 }; 1036 1037 /* harmony default export */ var if_matching_action = (ifMatchingAction); 1038 1039 // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/replace-action.js 1040 /** 1041 * Higher-order reducer creator which substitutes the action object before 1042 * passing to the original reducer. 1043 * 1044 * @param {Function} replacer Function mapping original action to replacement. 1045 * 1046 * @return {Function} Higher-order reducer. 1047 */ 1048 var replaceAction = function replaceAction(replacer) { 1049 return function (reducer) { 1050 return function (state, action) { 1051 return reducer(state, replacer(action)); 1052 }; 1053 }; 1054 }; 1055 1056 /* harmony default export */ var replace_action = (replaceAction); 1057 1058 // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/conservative-map-item.js 1059 /** 1060 * External dependencies 1061 */ 1062 1063 /** 1064 * Given the current and next item entity, returns the minimally "modified" 1065 * result of the next item, preferring value references from the original item 1066 * if equal. If all values match, the original item is returned. 1067 * 1068 * @param {Object} item Original item. 1069 * @param {Object} nextItem Next item. 1070 * 1071 * @return {Object} Minimally modified merged item. 1072 */ 1073 1074 function conservativeMapItem(item, nextItem) { 1075 // Return next item in its entirety if there is no original item. 1076 if (!item) { 1077 return nextItem; 1078 } 1079 1080 var hasChanges = false; 1081 var result = {}; 1082 1083 for (var key in nextItem) { 1084 if (Object(external_this_lodash_["isEqual"])(item[key], nextItem[key])) { 1085 result[key] = item[key]; 1086 } else { 1087 hasChanges = true; 1088 result[key] = nextItem[key]; 1089 } 1090 } 1091 1092 if (!hasChanges) { 1093 return item; 1094 } 1095 1096 return result; 1097 } 1098 1099 // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/on-sub-key.js 1100 1101 1102 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } 1103 1104 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } 1105 1106 /** 1107 * Higher-order reducer creator which creates a combined reducer object, keyed 1108 * by a property on the action object. 1109 * 1110 * @param {string} actionProperty Action property by which to key object. 1111 * 1112 * @return {Function} Higher-order reducer. 1113 */ 1114 var on_sub_key_onSubKey = function onSubKey(actionProperty) { 1115 return function (reducer) { 1116 return function () { 1117 var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 1118 var action = arguments.length > 1 ? arguments[1] : undefined; 1119 // Retrieve subkey from action. Do not track if undefined; useful for cases 1120 // where reducer is scoped by action shape. 1121 var key = action[actionProperty]; 1122 1123 if (key === undefined) { 1124 return state; 1125 } // Avoid updating state if unchanged. Note that this also accounts for a 1126 // reducer which returns undefined on a key which is not yet tracked. 1127 1128 1129 var nextKeyState = reducer(state[key], action); 1130 1131 if (nextKeyState === state[key]) { 1132 return state; 1133 } 1134 1135 return _objectSpread({}, state, Object(defineProperty["a" /* default */])({}, key, nextKeyState)); 1136 }; 1137 }; 1138 }; 1139 /* harmony default export */ var on_sub_key = (on_sub_key_onSubKey); 1140 1141 // EXTERNAL MODULE: external {"this":"regeneratorRuntime"} 1142 var external_this_regeneratorRuntime_ = __webpack_require__(23); 1143 var external_this_regeneratorRuntime_default = /*#__PURE__*/__webpack_require__.n(external_this_regeneratorRuntime_); 1144 1145 // EXTERNAL MODULE: external {"this":["wp","i18n"]} 1146 var external_this_wp_i18n_ = __webpack_require__(1); 1147 1148 // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/queried-data/actions.js 1149 1150 1151 function actions_ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } 1152 1153 function actions_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { actions_ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { actions_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } 1154 1155 /** 1156 * External dependencies 1157 */ 1158 1159 /** 1160 * Returns an action object used in signalling that items have been received. 1161 * 1162 * @param {Array} items Items received. 1163 * 1164 * @return {Object} Action object. 1165 */ 1166 1167 function receiveItems(items) { 1168 return { 1169 type: 'RECEIVE_ITEMS', 1170 items: Object(external_this_lodash_["castArray"])(items) 1171 }; 1172 } 1173 /** 1174 * Returns an action object used in signalling that queried data has been 1175 * received. 1176 * 1177 * @param {Array} items Queried items received. 1178 * @param {?Object} query Optional query object. 1179 * 1180 * @return {Object} Action object. 1181 */ 1182 1183 function receiveQueriedItems(items) { 1184 var query = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; 1185 return actions_objectSpread({}, receiveItems(items), { 1186 query: query 1187 }); 1188 } 1189 1190 // EXTERNAL MODULE: external {"this":["wp","apiFetch"]} 1191 var external_this_wp_apiFetch_ = __webpack_require__(45); 1192 var external_this_wp_apiFetch_default = /*#__PURE__*/__webpack_require__.n(external_this_wp_apiFetch_); 1193 1194 // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/controls.js 1195 1196 1197 /** 1198 * WordPress dependencies 1199 */ 1200 1201 1202 /** 1203 * Trigger an API Fetch request. 1204 * 1205 * @param {Object} request API Fetch Request Object. 1206 * @return {Object} control descriptor. 1207 */ 1208 1209 function apiFetch(request) { 1210 return { 1211 type: 'API_FETCH', 1212 request: request 1213 }; 1214 } 1215 /** 1216 * Calls a selector using the current state. 1217 * 1218 * @param {string} selectorName Selector name. 1219 * @param {Array} args Selector arguments. 1220 * 1221 * @return {Object} control descriptor. 1222 */ 1223 1224 function controls_select(selectorName) { 1225 for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { 1226 args[_key - 1] = arguments[_key]; 1227 } 1228 1229 return { 1230 type: 'SELECT', 1231 selectorName: selectorName, 1232 args: args 1233 }; 1234 } 1235 /** 1236 * Dispatches a control action for triggering a registry select that has a 1237 * resolver. 1238 * 1239 * @param {string} selectorName 1240 * @param {Array} args Arguments for the select. 1241 * 1242 * @return {Object} control descriptor. 1243 */ 1244 1245 function resolveSelect(selectorName) { 1246 for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { 1247 args[_key2 - 1] = arguments[_key2]; 1248 } 1249 1250 return { 1251 type: 'RESOLVE_SELECT', 1252 selectorName: selectorName, 1253 args: args 1254 }; 1255 } 1256 var controls = { 1257 API_FETCH: function API_FETCH(_ref) { 1258 var request = _ref.request; 1259 return external_this_wp_apiFetch_default()(request); 1260 }, 1261 SELECT: Object(external_this_wp_data_["createRegistryControl"])(function (registry) { 1262 return function (_ref2) { 1263 var _registry$select; 1264 1265 var selectorName = _ref2.selectorName, 1266 args = _ref2.args; 1267 return (_registry$select = registry.select('core'))[selectorName].apply(_registry$select, Object(toConsumableArray["a" /* default */])(args)); 1268 }; 1269 }), 1270 RESOLVE_SELECT: Object(external_this_wp_data_["createRegistryControl"])(function (registry) { 1271 return function (_ref3) { 1272 var _registry$__experimen; 1273 1274 var selectorName = _ref3.selectorName, 1275 args = _ref3.args; 1276 return (_registry$__experimen = registry.__experimentalResolveSelect('core'))[selectorName].apply(_registry$__experimen, Object(toConsumableArray["a" /* default */])(args)); 1277 }; 1278 }) 1279 }; 1280 /* harmony default export */ var build_module_controls = (controls); 1281 1282 // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/actions.js 1283 1284 1285 1286 1287 var _marked = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(actions_editEntityRecord), 1288 _marked2 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(undo), 1289 _marked3 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(redo), 1290 _marked4 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(saveEntityRecord), 1291 _marked5 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(saveEditedEntityRecord); 1292 1293 function build_module_actions_ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } 1294 1295 function build_module_actions_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { build_module_actions_ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { build_module_actions_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } 1296 1297 /** 1298 * External dependencies 1299 */ 1300 1301 /** 1302 * Internal dependencies 1303 */ 1304 1305 1306 1307 1308 /** 1309 * Returns an action object used in signalling that authors have been received. 1310 * 1311 * @param {string} queryID Query ID. 1312 * @param {Array|Object} users Users received. 1313 * 1314 * @return {Object} Action object. 1315 */ 1316 1317 function receiveUserQuery(queryID, users) { 1318 return { 1319 type: 'RECEIVE_USER_QUERY', 1320 users: Object(external_this_lodash_["castArray"])(users), 1321 queryID: queryID 1322 }; 1323 } 1324 /** 1325 * Returns an action used in signalling that the current user has been received. 1326 * 1327 * @param {Object} currentUser Current user object. 1328 * 1329 * @return {Object} Action object. 1330 */ 1331 1332 function receiveCurrentUser(currentUser) { 1333 return { 1334 type: 'RECEIVE_CURRENT_USER', 1335 currentUser: currentUser 1336 }; 1337 } 1338 /** 1339 * Returns an action object used in adding new entities. 1340 * 1341 * @param {Array} entities Entities received. 1342 * 1343 * @return {Object} Action object. 1344 */ 1345 1346 function addEntities(entities) { 1347 return { 1348 type: 'ADD_ENTITIES', 1349 entities: entities 1350 }; 1351 } 1352 /** 1353 * Returns an action object used in signalling that entity records have been received. 1354 * 1355 * @param {string} kind Kind of the received entity. 1356 * @param {string} name Name of the received entity. 1357 * @param {Array|Object} records Records received. 1358 * @param {?Object} query Query Object. 1359 * @param {?boolean} invalidateCache Should invalidate query caches 1360 * 1361 * @return {Object} Action object. 1362 */ 1363 1364 function receiveEntityRecords(kind, name, records, query) { 1365 var invalidateCache = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false; 1366 1367 // Auto drafts should not have titles, but some plugins rely on them so we can't filter this 1368 // on the server. 1369 if (kind === 'postType') { 1370 records = Object(external_this_lodash_["castArray"])(records).map(function (record) { 1371 return record.status === 'auto-draft' ? build_module_actions_objectSpread({}, record, { 1372 title: '' 1373 }) : record; 1374 }); 1375 } 1376 1377 var action; 1378 1379 if (query) { 1380 action = receiveQueriedItems(records, query); 1381 } else { 1382 action = receiveItems(records); 1383 } 1384 1385 return build_module_actions_objectSpread({}, action, { 1386 kind: kind, 1387 name: name, 1388 invalidateCache: invalidateCache 1389 }); 1390 } 1391 /** 1392 * Returns an action object used in signalling that the current theme has been received. 1393 * 1394 * @param {Object} currentTheme The current theme. 1395 * 1396 * @return {Object} Action object. 1397 */ 1398 1399 function receiveCurrentTheme(currentTheme) { 1400 return { 1401 type: 'RECEIVE_CURRENT_THEME', 1402 currentTheme: currentTheme 1403 }; 1404 } 1405 /** 1406 * Returns an action object used in signalling that the index has been received. 1407 * 1408 * @param {Object} themeSupports Theme support for the current theme. 1409 * 1410 * @return {Object} Action object. 1411 */ 1412 1413 function receiveThemeSupports(themeSupports) { 1414 return { 1415 type: 'RECEIVE_THEME_SUPPORTS', 1416 themeSupports: themeSupports 1417 }; 1418 } 1419 /** 1420 * Returns an action object used in signalling that the preview data for 1421 * a given URl has been received. 1422 * 1423 * @param {string} url URL to preview the embed for. 1424 * @param {*} preview Preview data. 1425 * 1426 * @return {Object} Action object. 1427 */ 1428 1429 function receiveEmbedPreview(url, preview) { 1430 return { 1431 type: 'RECEIVE_EMBED_PREVIEW', 1432 url: url, 1433 preview: preview 1434 }; 1435 } 1436 /** 1437 * Returns an action object that triggers an 1438 * edit to an entity record. 1439 * 1440 * @param {string} kind Kind of the edited entity record. 1441 * @param {string} name Name of the edited entity record. 1442 * @param {number} recordId Record ID of the edited entity record. 1443 * @param {Object} edits The edits. 1444 * @param {Object} options Options for the edit. 1445 * @param {boolean} options.undoIgnore Whether to ignore the edit in undo history or not. 1446 * 1447 * @return {Object} Action object. 1448 */ 1449 1450 function actions_editEntityRecord(kind, name, recordId, edits) { 1451 var options, 1452 entity, 1453 _entity$transientEdit, 1454 transientEdits, 1455 _entity$mergedEdits, 1456 mergedEdits, 1457 record, 1458 editedRecord, 1459 edit, 1460 _args = arguments; 1461 1462 return external_this_regeneratorRuntime_default.a.wrap(function editEntityRecord$(_context) { 1463 while (1) { 1464 switch (_context.prev = _context.next) { 1465 case 0: 1466 options = _args.length > 4 && _args[4] !== undefined ? _args[4] : {}; 1467 _context.next = 3; 1468 return controls_select('getEntity', kind, name); 1469 1470 case 3: 1471 entity = _context.sent; 1472 1473 if (entity) { 1474 _context.next = 6; 1475 break; 1476 } 1477 1478 throw new Error("The entity being edited (".concat(kind, ", ").concat(name, ") does not have a loaded config.")); 1479 1480 case 6: 1481 _entity$transientEdit = entity.transientEdits, transientEdits = _entity$transientEdit === void 0 ? {} : _entity$transientEdit, _entity$mergedEdits = entity.mergedEdits, mergedEdits = _entity$mergedEdits === void 0 ? {} : _entity$mergedEdits; 1482 _context.next = 9; 1483 return controls_select('getRawEntityRecord', kind, name, recordId); 1484 1485 case 9: 1486 record = _context.sent; 1487 _context.next = 12; 1488 return controls_select('getEditedEntityRecord', kind, name, recordId); 1489 1490 case 12: 1491 editedRecord = _context.sent; 1492 edit = { 1493 kind: kind, 1494 name: name, 1495 recordId: recordId, 1496 // Clear edits when they are equal to their persisted counterparts 1497 // so that the property is not considered dirty. 1498 edits: Object.keys(edits).reduce(function (acc, key) { 1499 var recordValue = record[key]; 1500 var editedRecordValue = editedRecord[key]; 1501 var value = mergedEdits[key] ? build_module_actions_objectSpread({}, editedRecordValue, {}, edits[key]) : edits[key]; 1502 acc[key] = Object(external_this_lodash_["isEqual"])(recordValue, value) ? undefined : value; 1503 return acc; 1504 }, {}), 1505 transientEdits: transientEdits 1506 }; 1507 return _context.abrupt("return", build_module_actions_objectSpread({ 1508 type: 'EDIT_ENTITY_RECORD' 1509 }, edit, { 1510 meta: { 1511 undo: !options.undoIgnore && build_module_actions_objectSpread({}, edit, { 1512 // Send the current values for things like the first undo stack entry. 1513 edits: Object.keys(edits).reduce(function (acc, key) { 1514 acc[key] = editedRecord[key]; 1515 return acc; 1516 }, {}) 1517 }) 1518 } 1519 })); 1520 1521 case 15: 1522 case "end": 1523 return _context.stop(); 1524 } 1525 } 1526 }, _marked); 1527 } 1528 /** 1529 * Action triggered to undo the last edit to 1530 * an entity record, if any. 1531 */ 1532 1533 function undo() { 1534 var undoEdit; 1535 return external_this_regeneratorRuntime_default.a.wrap(function undo$(_context2) { 1536 while (1) { 1537 switch (_context2.prev = _context2.next) { 1538 case 0: 1539 _context2.next = 2; 1540 return controls_select('getUndoEdit'); 1541 1542 case 2: 1543 undoEdit = _context2.sent; 1544 1545 if (undoEdit) { 1546 _context2.next = 5; 1547 break; 1548 } 1549 1550 return _context2.abrupt("return"); 1551 1552 case 5: 1553 _context2.next = 7; 1554 return build_module_actions_objectSpread({ 1555 type: 'EDIT_ENTITY_RECORD' 1556 }, undoEdit, { 1557 meta: { 1558 isUndo: true 1559 } 1560 }); 1561 1562 case 7: 1563 case "end": 1564 return _context2.stop(); 1565 } 1566 } 1567 }, _marked2); 1568 } 1569 /** 1570 * Action triggered to redo the last undoed 1571 * edit to an entity record, if any. 1572 */ 1573 1574 function redo() { 1575 var redoEdit; 1576 return external_this_regeneratorRuntime_default.a.wrap(function redo$(_context3) { 1577 while (1) { 1578 switch (_context3.prev = _context3.next) { 1579 case 0: 1580 _context3.next = 2; 1581 return controls_select('getRedoEdit'); 1582 1583 case 2: 1584 redoEdit = _context3.sent; 1585 1586 if (redoEdit) { 1587 _context3.next = 5; 1588 break; 1589 } 1590 1591 return _context3.abrupt("return"); 1592 1593 case 5: 1594 _context3.next = 7; 1595 return build_module_actions_objectSpread({ 1596 type: 'EDIT_ENTITY_RECORD' 1597 }, redoEdit, { 1598 meta: { 1599 isRedo: true 1600 } 1601 }); 1602 1603 case 7: 1604 case "end": 1605 return _context3.stop(); 1606 } 1607 } 1608 }, _marked3); 1609 } 1610 /** 1611 * Forces the creation of a new undo level. 1612 * 1613 * @return {Object} Action object. 1614 */ 1615 1616 function __unstableCreateUndoLevel() { 1617 return { 1618 type: 'CREATE_UNDO_LEVEL' 1619 }; 1620 } 1621 /** 1622 * Action triggered to save an entity record. 1623 * 1624 * @param {string} kind Kind of the received entity. 1625 * @param {string} name Name of the received entity. 1626 * @param {Object} record Record to be saved. 1627 * @param {Object} options Saving options. 1628 * @param {boolean} [options.isAutosave=false] Whether this is an autosave. 1629 */ 1630 1631 function saveEntityRecord(kind, name, record) { 1632 var _ref, 1633 _ref$isAutosave, 1634 isAutosave, 1635 entities, 1636 entity, 1637 entityIdKey, 1638 recordId, 1639 _i, 1640 _Object$entries, 1641 _Object$entries$_i, 1642 key, 1643 value, 1644 evaluatedValue, 1645 updatedRecord, 1646 error, 1647 persistedEntity, 1648 currentEdits, 1649 path, 1650 persistedRecord, 1651 currentUser, 1652 currentUserId, 1653 autosavePost, 1654 data, 1655 newRecord, 1656 _data, 1657 _args4 = arguments; 1658 1659 return external_this_regeneratorRuntime_default.a.wrap(function saveEntityRecord$(_context4) { 1660 while (1) { 1661 switch (_context4.prev = _context4.next) { 1662 case 0: 1663 _ref = _args4.length > 3 && _args4[3] !== undefined ? _args4[3] : { 1664 isAutosave: false 1665 }, _ref$isAutosave = _ref.isAutosave, isAutosave = _ref$isAutosave === void 0 ? false : _ref$isAutosave; 1666 _context4.next = 3; 1667 return getKindEntities(kind); 1668 1669 case 3: 1670 entities = _context4.sent; 1671 entity = Object(external_this_lodash_["find"])(entities, { 1672 kind: kind, 1673 name: name 1674 }); 1675 1676 if (entity) { 1677 _context4.next = 7; 1678 break; 1679 } 1680 1681 return _context4.abrupt("return"); 1682 1683 case 7: 1684 entityIdKey = entity.key || DEFAULT_ENTITY_KEY; 1685 recordId = record[entityIdKey]; // Evaluate optimized edits. 1686 // (Function edits that should be evaluated on save to avoid expensive computations on every edit.) 1687 1688 _i = 0, _Object$entries = Object.entries(record); 1689 1690 case 10: 1691 if (!(_i < _Object$entries.length)) { 1692 _context4.next = 24; 1693 break; 1694 } 1695 1696 _Object$entries$_i = Object(slicedToArray["a" /* default */])(_Object$entries[_i], 2), key = _Object$entries$_i[0], value = _Object$entries$_i[1]; 1697 1698 if (!(typeof value === 'function')) { 1699 _context4.next = 21; 1700 break; 1701 } 1702 1703 _context4.t0 = value; 1704 _context4.next = 16; 1705 return controls_select('getEditedEntityRecord', kind, name, recordId); 1706 1707 case 16: 1708 _context4.t1 = _context4.sent; 1709 evaluatedValue = (0, _context4.t0)(_context4.t1); 1710 _context4.next = 20; 1711 return actions_editEntityRecord(kind, name, recordId, Object(defineProperty["a" /* default */])({}, key, evaluatedValue), { 1712 undoIgnore: true 1713 }); 1714 1715 case 20: 1716 record[key] = evaluatedValue; 1717 1718 case 21: 1719 _i++; 1720 _context4.next = 10; 1721 break; 1722 1723 case 24: 1724 _context4.next = 26; 1725 return { 1726 type: 'SAVE_ENTITY_RECORD_START', 1727 kind: kind, 1728 name: name, 1729 recordId: recordId, 1730 isAutosave: isAutosave 1731 }; 1732 1733 case 26: 1734 _context4.prev = 26; 1735 path = "".concat(entity.baseURL).concat(recordId ? '/' + recordId : ''); 1736 _context4.next = 30; 1737 return controls_select('getRawEntityRecord', kind, name, recordId); 1738 1739 case 30: 1740 persistedRecord = _context4.sent; 1741 1742 if (!isAutosave) { 1743 _context4.next = 55; 1744 break; 1745 } 1746 1747 _context4.next = 34; 1748 return controls_select('getCurrentUser'); 1749 1750 case 34: 1751 currentUser = _context4.sent; 1752 currentUserId = currentUser ? currentUser.id : undefined; 1753 _context4.next = 38; 1754 return controls_select('getAutosave', persistedRecord.type, persistedRecord.id, currentUserId); 1755 1756 case 38: 1757 autosavePost = _context4.sent; 1758 // Autosaves need all expected fields to be present. 1759 // So we fallback to the previous autosave and then 1760 // to the actual persisted entity if the edits don't 1761 // have a value. 1762 data = build_module_actions_objectSpread({}, persistedRecord, {}, autosavePost, {}, record); 1763 data = Object.keys(data).reduce(function (acc, key) { 1764 if (['title', 'excerpt', 'content'].includes(key)) { 1765 // Edits should be the "raw" attribute values. 1766 acc[key] = Object(external_this_lodash_["get"])(data[key], 'raw', data[key]); 1767 } 1768 1769 return acc; 1770 }, { 1771 status: data.status === 'auto-draft' ? 'draft' : data.status 1772 }); 1773 _context4.next = 43; 1774 return apiFetch({ 1775 path: "".concat(path, "/autosaves"), 1776 method: 'POST', 1777 data: data 1778 }); 1779 1780 case 43: 1781 updatedRecord = _context4.sent; 1782 1783 if (!(persistedRecord.id === updatedRecord.id)) { 1784 _context4.next = 51; 1785 break; 1786 } 1787 1788 newRecord = build_module_actions_objectSpread({}, persistedRecord, {}, data, {}, updatedRecord); 1789 newRecord = Object.keys(newRecord).reduce(function (acc, key) { 1790 // These properties are persisted in autosaves. 1791 if (['title', 'excerpt', 'content'].includes(key)) { 1792 // Edits should be the "raw" attribute values. 1793 acc[key] = Object(external_this_lodash_["get"])(newRecord[key], 'raw', newRecord[key]); 1794 } else if (key === 'status') { 1795 // Status is only persisted in autosaves when going from 1796 // "auto-draft" to "draft". 1797 acc[key] = persistedRecord.status === 'auto-draft' && newRecord.status === 'draft' ? newRecord.status : persistedRecord.status; 1798 } else { 1799 // These properties are not persisted in autosaves. 1800 acc[key] = Object(external_this_lodash_["get"])(persistedRecord[key], 'raw', persistedRecord[key]); 1801 } 1802 1803 return acc; 1804 }, {}); 1805 _context4.next = 49; 1806 return receiveEntityRecords(kind, name, newRecord, undefined, true); 1807 1808 case 49: 1809 _context4.next = 53; 1810 break; 1811 1812 case 51: 1813 _context4.next = 53; 1814 return receiveAutosaves(persistedRecord.id, updatedRecord); 1815 1816 case 53: 1817 _context4.next = 70; 1818 break; 1819 1820 case 55: 1821 // Auto drafts should be converted to drafts on explicit saves and we should not respect their default title, 1822 // but some plugins break with this behavior so we can't filter it on the server. 1823 _data = record; 1824 1825 if (kind === 'postType' && persistedRecord && persistedRecord.status === 'auto-draft') { 1826 if (!_data.status) { 1827 _data = build_module_actions_objectSpread({}, _data, { 1828 status: 'draft' 1829 }); 1830 } 1831 1832 if (!_data.title || _data.title === 'Auto Draft') { 1833 _data = build_module_actions_objectSpread({}, _data, { 1834 title: '' 1835 }); 1836 } 1837 } // Get the full local version of the record before the update, 1838 // to merge it with the edits and then propagate it to subscribers 1839 1840 1841 _context4.next = 59; 1842 return controls_select('__experimentalGetEntityRecordNoResolver', kind, name, recordId); 1843 1844 case 59: 1845 persistedEntity = _context4.sent; 1846 _context4.next = 62; 1847 return controls_select('getEntityRecordEdits', kind, name, recordId); 1848 1849 case 62: 1850 currentEdits = _context4.sent; 1851 _context4.next = 65; 1852 return receiveEntityRecords(kind, name, build_module_actions_objectSpread({}, persistedEntity, {}, _data), undefined, true); 1853 1854 case 65: 1855 _context4.next = 67; 1856 return apiFetch({ 1857 path: path, 1858 method: recordId ? 'PUT' : 'POST', 1859 data: _data 1860 }); 1861 1862 case 67: 1863 updatedRecord = _context4.sent; 1864 _context4.next = 70; 1865 return receiveEntityRecords(kind, name, updatedRecord, undefined, true); 1866 1867 case 70: 1868 _context4.next = 93; 1869 break; 1870 1871 case 72: 1872 _context4.prev = 72; 1873 _context4.t2 = _context4["catch"](26); 1874 error = _context4.t2; // If we got to the point in the try block where we made an optimistic update, 1875 // we need to roll it back here. 1876 1877 if (!(persistedEntity && currentEdits)) { 1878 _context4.next = 93; 1879 break; 1880 } 1881 1882 _context4.next = 78; 1883 return receiveEntityRecords(kind, name, persistedEntity, undefined, true); 1884 1885 case 78: 1886 _context4.t3 = actions_editEntityRecord; 1887 _context4.t4 = kind; 1888 _context4.t5 = name; 1889 _context4.t6 = recordId; 1890 _context4.t7 = build_module_actions_objectSpread; 1891 _context4.t8 = {}; 1892 _context4.t9 = currentEdits; 1893 _context4.t10 = {}; 1894 _context4.next = 88; 1895 return controls_select('getEntityRecordEdits', kind, name, recordId); 1896 1897 case 88: 1898 _context4.t11 = _context4.sent; 1899 _context4.t12 = (0, _context4.t7)(_context4.t8, _context4.t9, _context4.t10, _context4.t11); 1900 _context4.t13 = { 1901 undoIgnore: true 1902 }; 1903 _context4.next = 93; 1904 return (0, _context4.t3)(_context4.t4, _context4.t5, _context4.t6, _context4.t12, _context4.t13); 1905 1906 case 93: 1907 _context4.next = 95; 1908 return { 1909 type: 'SAVE_ENTITY_RECORD_FINISH', 1910 kind: kind, 1911 name: name, 1912 recordId: recordId, 1913 error: error, 1914 isAutosave: isAutosave 1915 }; 1916 1917 case 95: 1918 return _context4.abrupt("return", updatedRecord); 1919 1920 case 96: 1921 case "end": 1922 return _context4.stop(); 1923 } 1924 } 1925 }, _marked4, null, [[26, 72]]); 1926 } 1927 /** 1928 * Action triggered to save an entity record's edits. 1929 * 1930 * @param {string} kind Kind of the entity. 1931 * @param {string} name Name of the entity. 1932 * @param {Object} recordId ID of the record. 1933 * @param {Object} options Saving options. 1934 */ 1935 1936 function saveEditedEntityRecord(kind, name, recordId, options) { 1937 var edits, record; 1938 return external_this_regeneratorRuntime_default.a.wrap(function saveEditedEntityRecord$(_context5) { 1939 while (1) { 1940 switch (_context5.prev = _context5.next) { 1941 case 0: 1942 _context5.next = 2; 1943 return controls_select('hasEditsForEntityRecord', kind, name, recordId); 1944 1945 case 2: 1946 if (_context5.sent) { 1947 _context5.next = 4; 1948 break; 1949 } 1950 1951 return _context5.abrupt("return"); 1952 1953 case 4: 1954 _context5.next = 6; 1955 return controls_select('getEntityRecordNonTransientEdits', kind, name, recordId); 1956 1957 case 6: 1958 edits = _context5.sent; 1959 record = build_module_actions_objectSpread({ 1960 id: recordId 1961 }, edits); 1962 return _context5.delegateYield(saveEntityRecord(kind, name, record, options), "t0", 9); 1963 1964 case 9: 1965 case "end": 1966 return _context5.stop(); 1967 } 1968 } 1969 }, _marked5); 1970 } 1971 /** 1972 * Returns an action object used in signalling that Upload permissions have been received. 1973 * 1974 * @param {boolean} hasUploadPermissions Does the user have permission to upload files? 1975 * 1976 * @return {Object} Action object. 1977 */ 1978 1979 function receiveUploadPermissions(hasUploadPermissions) { 1980 return { 1981 type: 'RECEIVE_USER_PERMISSION', 1982 key: 'create/media', 1983 isAllowed: hasUploadPermissions 1984 }; 1985 } 1986 /** 1987 * Returns an action object used in signalling that the current user has 1988 * permission to perform an action on a REST resource. 1989 * 1990 * @param {string} key A key that represents the action and REST resource. 1991 * @param {boolean} isAllowed Whether or not the user can perform the action. 1992 * 1993 * @return {Object} Action object. 1994 */ 1995 1996 function receiveUserPermission(key, isAllowed) { 1997 return { 1998 type: 'RECEIVE_USER_PERMISSION', 1999 key: key, 2000 isAllowed: isAllowed 2001 }; 2002 } 2003 /** 2004 * Returns an action object used in signalling that the autosaves for a 2005 * post have been received. 2006 * 2007 * @param {number} postId The id of the post that is parent to the autosave. 2008 * @param {Array|Object} autosaves An array of autosaves or singular autosave object. 2009 * 2010 * @return {Object} Action object. 2011 */ 2012 2013 function receiveAutosaves(postId, autosaves) { 2014 return { 2015 type: 'RECEIVE_AUTOSAVES', 2016 postId: postId, 2017 autosaves: Object(external_this_lodash_["castArray"])(autosaves) 2018 }; 2019 } 2020 2021 // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/entities.js 2022 2023 2024 var entities_marked = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(loadPostTypeEntities), 2025 entities_marked2 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(loadTaxonomyEntities), 2026 entities_marked3 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(getKindEntities); 2027 2028 /** 2029 * External dependencies 2030 */ 2031 2032 /** 2033 * WordPress dependencies 2034 */ 2035 2036 2037 /** 2038 * Internal dependencies 2039 */ 2040 2041 2042 2043 var DEFAULT_ENTITY_KEY = 'id'; 2044 var defaultEntities = [{ 2045 label: Object(external_this_wp_i18n_["__"])('Site'), 2046 name: 'site', 2047 kind: 'root', 2048 baseURL: '/wp/v2/settings', 2049 getTitle: function getTitle(record) { 2050 return Object(external_this_lodash_["get"])(record, ['title'], Object(external_this_wp_i18n_["__"])('Site Title')); 2051 } 2052 }, { 2053 label: Object(external_this_wp_i18n_["__"])('Post Type'), 2054 name: 'postType', 2055 kind: 'root', 2056 key: 'slug', 2057 baseURL: '/wp/v2/types' 2058 }, { 2059 name: 'media', 2060 kind: 'root', 2061 baseURL: '/wp/v2/media', 2062 plural: 'mediaItems', 2063 label: Object(external_this_wp_i18n_["__"])('Media') 2064 }, { 2065 name: 'taxonomy', 2066 kind: 'root', 2067 key: 'slug', 2068 baseURL: '/wp/v2/taxonomies', 2069 plural: 'taxonomies', 2070 label: Object(external_this_wp_i18n_["__"])('Taxonomy') 2071 }, { 2072 name: 'widgetArea', 2073 kind: 'root', 2074 baseURL: '/__experimental/widget-areas', 2075 plural: 'widgetAreas', 2076 transientEdits: { 2077 blocks: true 2078 }, 2079 label: Object(external_this_wp_i18n_["__"])('Widget area') 2080 }, { 2081 label: Object(external_this_wp_i18n_["__"])('User'), 2082 name: 'user', 2083 kind: 'root', 2084 baseURL: '/wp/v2/users', 2085 plural: 'users' 2086 }, { 2087 name: 'comment', 2088 kind: 'root', 2089 baseURL: '/wp/v2/comments', 2090 plural: 'comments', 2091 label: Object(external_this_wp_i18n_["__"])('Comment') 2092 }, { 2093 name: 'menu', 2094 kind: 'root', 2095 baseURL: '/__experimental/menus', 2096 plural: 'menus', 2097 label: Object(external_this_wp_i18n_["__"])('Menu') 2098 }, { 2099 name: 'menuItem', 2100 kind: 'root', 2101 baseURL: '/__experimental/menu-items', 2102 plural: 'menuItems', 2103 label: Object(external_this_wp_i18n_["__"])('Menu Item') 2104 }, { 2105 name: 'menuLocation', 2106 kind: 'root', 2107 baseURL: '/__experimental/menu-locations', 2108 plural: 'menuLocations', 2109 label: Object(external_this_wp_i18n_["__"])('Menu Location'), 2110 key: 'name' 2111 }]; 2112 var kinds = [{ 2113 name: 'postType', 2114 loadEntities: loadPostTypeEntities 2115 }, { 2116 name: 'taxonomy', 2117 loadEntities: loadTaxonomyEntities 2118 }]; 2119 /** 2120 * Returns the list of post type entities. 2121 * 2122 * @return {Promise} Entities promise 2123 */ 2124 2125 function loadPostTypeEntities() { 2126 var postTypes; 2127 return external_this_regeneratorRuntime_default.a.wrap(function loadPostTypeEntities$(_context) { 2128 while (1) { 2129 switch (_context.prev = _context.next) { 2130 case 0: 2131 _context.next = 2; 2132 return apiFetch({ 2133 path: '/wp/v2/types?context=edit' 2134 }); 2135 2136 case 2: 2137 postTypes = _context.sent; 2138 return _context.abrupt("return", Object(external_this_lodash_["map"])(postTypes, function (postType, name) { 2139 return { 2140 kind: 'postType', 2141 baseURL: '/wp/v2/' + postType.rest_base, 2142 name: name, 2143 label: postType.labels.singular_name, 2144 transientEdits: { 2145 blocks: true, 2146 selectionStart: true, 2147 selectionEnd: true 2148 }, 2149 mergedEdits: { 2150 meta: true 2151 }, 2152 getTitle: function getTitle(record) { 2153 if (name === 'wp_template_part' || name === 'wp_template') { 2154 return Object(external_this_lodash_["startCase"])(record.slug); 2155 } 2156 2157 return Object(external_this_lodash_["get"])(record, ['title', 'rendered'], record.id); 2158 } 2159 }; 2160 })); 2161 2162 case 4: 2163 case "end": 2164 return _context.stop(); 2165 } 2166 } 2167 }, entities_marked); 2168 } 2169 /** 2170 * Returns the list of the taxonomies entities. 2171 * 2172 * @return {Promise} Entities promise 2173 */ 2174 2175 2176 function loadTaxonomyEntities() { 2177 var taxonomies; 2178 return external_this_regeneratorRuntime_default.a.wrap(function loadTaxonomyEntities$(_context2) { 2179 while (1) { 2180 switch (_context2.prev = _context2.next) { 2181 case 0: 2182 _context2.next = 2; 2183 return apiFetch({ 2184 path: '/wp/v2/taxonomies?context=edit' 2185 }); 2186 2187 case 2: 2188 taxonomies = _context2.sent; 2189 return _context2.abrupt("return", Object(external_this_lodash_["map"])(taxonomies, function (taxonomy, name) { 2190 return { 2191 kind: 'taxonomy', 2192 baseURL: '/wp/v2/' + taxonomy.rest_base, 2193 name: name, 2194 label: taxonomy.labels.singular_name 2195 }; 2196 })); 2197 2198 case 4: 2199 case "end": 2200 return _context2.stop(); 2201 } 2202 } 2203 }, entities_marked2); 2204 } 2205 /** 2206 * Returns the entity's getter method name given its kind and name. 2207 * 2208 * @param {string} kind Entity kind. 2209 * @param {string} name Entity name. 2210 * @param {string} prefix Function prefix. 2211 * @param {boolean} usePlural Whether to use the plural form or not. 2212 * 2213 * @return {string} Method name 2214 */ 2215 2216 2217 var entities_getMethodName = function getMethodName(kind, name) { 2218 var prefix = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'get'; 2219 var usePlural = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; 2220 var entity = Object(external_this_lodash_["find"])(defaultEntities, { 2221 kind: kind, 2222 name: name 2223 }); 2224 var kindPrefix = kind === 'root' ? '' : Object(external_this_lodash_["upperFirst"])(Object(external_this_lodash_["camelCase"])(kind)); 2225 var nameSuffix = Object(external_this_lodash_["upperFirst"])(Object(external_this_lodash_["camelCase"])(name)) + (usePlural ? 's' : ''); 2226 var suffix = usePlural && entity.plural ? Object(external_this_lodash_["upperFirst"])(Object(external_this_lodash_["camelCase"])(entity.plural)) : nameSuffix; 2227 return "".concat(prefix).concat(kindPrefix).concat(suffix); 2228 }; 2229 /** 2230 * Loads the kind entities into the store. 2231 * 2232 * @param {string} kind Kind 2233 * 2234 * @return {Array} Entities 2235 */ 2236 2237 function getKindEntities(kind) { 2238 var entities, kindConfig; 2239 return external_this_regeneratorRuntime_default.a.wrap(function getKindEntities$(_context3) { 2240 while (1) { 2241 switch (_context3.prev = _context3.next) { 2242 case 0: 2243 _context3.next = 2; 2244 return controls_select('getEntitiesByKind', kind); 2245 2246 case 2: 2247 entities = _context3.sent; 2248 2249 if (!(entities && entities.length !== 0)) { 2250 _context3.next = 5; 2251 break; 2252 } 2253 2254 return _context3.abrupt("return", entities); 2255 2256 case 5: 2257 kindConfig = Object(external_this_lodash_["find"])(kinds, { 2258 name: kind 2259 }); 2260 2261 if (kindConfig) { 2262 _context3.next = 8; 2263 break; 2264 } 2265 2266 return _context3.abrupt("return", []); 2267 2268 case 8: 2269 _context3.next = 10; 2270 return kindConfig.loadEntities(); 2271 2272 case 10: 2273 entities = _context3.sent; 2274 _context3.next = 13; 2275 return addEntities(entities); 2276 2277 case 13: 2278 return _context3.abrupt("return", entities); 2279 2280 case 14: 2281 case "end": 2282 return _context3.stop(); 2283 } 2284 } 2285 }, entities_marked3); 2286 } 2287 2288 // EXTERNAL MODULE: external {"this":["wp","url"]} 2289 var external_this_wp_url_ = __webpack_require__(30); 2290 2291 // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/with-weak-map-cache.js 2292 /** 2293 * External dependencies 2294 */ 2295 2296 /** 2297 * Given a function, returns an enhanced function which caches the result and 2298 * tracks in WeakMap. The result is only cached if the original function is 2299 * passed a valid object-like argument (requirement for WeakMap key). 2300 * 2301 * @param {Function} fn Original function. 2302 * 2303 * @return {Function} Enhanced caching function. 2304 */ 2305 2306 function withWeakMapCache(fn) { 2307 var cache = new WeakMap(); 2308 return function (key) { 2309 var value; 2310 2311 if (cache.has(key)) { 2312 value = cache.get(key); 2313 } else { 2314 value = fn(key); // Can reach here if key is not valid for WeakMap, since `has` 2315 // will return false for invalid key. Since `set` will throw, 2316 // ensure that key is valid before setting into cache. 2317 2318 if (Object(external_this_lodash_["isObjectLike"])(key)) { 2319 cache.set(key, value); 2320 } 2321 } 2322 2323 return value; 2324 }; 2325 } 2326 2327 /* harmony default export */ var with_weak_map_cache = (withWeakMapCache); 2328 2329 // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/queried-data/get-query-parts.js 2330 2331 2332 /** 2333 * WordPress dependencies 2334 */ 2335 2336 /** 2337 * Internal dependencies 2338 */ 2339 2340 2341 /** 2342 * An object of properties describing a specific query. 2343 * 2344 * @typedef {Object} WPQueriedDataQueryParts 2345 * 2346 * @property {number} page The query page (1-based index, default 1). 2347 * @property {number} perPage Items per page for query (default 10). 2348 * @property {string} stableKey An encoded stable string of all non-pagination 2349 * query parameters. 2350 */ 2351 2352 /** 2353 * Given a query object, returns an object of parts, including pagination 2354 * details (`page` and `perPage`, or default values). All other properties are 2355 * encoded into a stable (idempotent) `stableKey` value. 2356 * 2357 * @param {Object} query Optional query object. 2358 * 2359 * @return {WPQueriedDataQueryParts} Query parts. 2360 */ 2361 2362 function getQueryParts(query) { 2363 /** 2364 * @type {WPQueriedDataQueryParts} 2365 */ 2366 var parts = { 2367 stableKey: '', 2368 page: 1, 2369 perPage: 10 2370 }; // Ensure stable key by sorting keys. Also more efficient for iterating. 2371 2372 var keys = Object.keys(query).sort(); 2373 2374 for (var i = 0; i < keys.length; i++) { 2375 var key = keys[i]; 2376 var value = query[key]; 2377 2378 switch (key) { 2379 case 'page': 2380 parts[key] = Number(value); 2381 break; 2382 2383 case 'per_page': 2384 parts.perPage = Number(value); 2385 break; 2386 2387 default: 2388 // While it could be any deterministic string, for simplicity's 2389 // sake mimic querystring encoding for stable key. 2390 // 2391 // TODO: For consistency with PHP implementation, addQueryArgs 2392 // should accept a key value pair, which may optimize its 2393 // implementation for our use here, vs. iterating an object 2394 // with only a single key. 2395 parts.stableKey += (parts.stableKey ? '&' : '') + Object(external_this_wp_url_["addQueryArgs"])('', Object(defineProperty["a" /* default */])({}, key, value)).slice(1); 2396 } 2397 } 2398 2399 return parts; 2400 } 2401 /* harmony default export */ var get_query_parts = (with_weak_map_cache(getQueryParts)); 2402 2403 // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/queried-data/reducer.js 2404 2405 2406 function reducer_ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } 2407 2408 function reducer_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { reducer_ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { reducer_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } 2409 2410 /** 2411 * External dependencies 2412 */ 2413 2414 /** 2415 * WordPress dependencies 2416 */ 2417 2418 2419 /** 2420 * Internal dependencies 2421 */ 2422 2423 2424 2425 2426 /** 2427 * Returns a merged array of item IDs, given details of the received paginated 2428 * items. The array is sparse-like with `undefined` entries where holes exist. 2429 * 2430 * @param {?Array<number>} itemIds Original item IDs (default empty array). 2431 * @param {number[]} nextItemIds Item IDs to merge. 2432 * @param {number} page Page of items merged. 2433 * @param {number} perPage Number of items per page. 2434 * 2435 * @return {number[]} Merged array of item IDs. 2436 */ 2437 2438 function getMergedItemIds(itemIds, nextItemIds, page, perPage) { 2439 var receivedAllIds = page === 1 && perPage === -1; 2440 2441 if (receivedAllIds) { 2442 return nextItemIds; 2443 } 2444 2445 var nextItemIdsStartIndex = (page - 1) * perPage; // If later page has already been received, default to the larger known 2446 // size of the existing array, else calculate as extending the existing. 2447 2448 var size = Math.max(itemIds.length, nextItemIdsStartIndex + nextItemIds.length); // Preallocate array since size is known. 2449 2450 var mergedItemIds = new Array(size); 2451 2452 for (var i = 0; i < size; i++) { 2453 // Preserve existing item ID except for subset of range of next items. 2454 var isInNextItemsRange = i >= nextItemIdsStartIndex && i < nextItemIdsStartIndex + nextItemIds.length; 2455 mergedItemIds[i] = isInNextItemsRange ? nextItemIds[i - nextItemIdsStartIndex] : itemIds[i]; 2456 } 2457 2458 return mergedItemIds; 2459 } 2460 /** 2461 * Reducer tracking items state, keyed by ID. Items are assumed to be normal, 2462 * where identifiers are common across all queries. 2463 * 2464 * @param {Object} state Current state. 2465 * @param {Object} action Dispatched action. 2466 * 2467 * @return {Object} Next state. 2468 */ 2469 2470 function reducer_items() { 2471 var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 2472 var action = arguments.length > 1 ? arguments[1] : undefined; 2473 2474 switch (action.type) { 2475 case 'RECEIVE_ITEMS': 2476 var key = action.key || DEFAULT_ENTITY_KEY; 2477 return reducer_objectSpread({}, state, {}, action.items.reduce(function (accumulator, value) { 2478 var itemId = value[key]; 2479 accumulator[itemId] = conservativeMapItem(state[itemId], value); 2480 return accumulator; 2481 }, {})); 2482 } 2483 2484 return state; 2485 } 2486 /** 2487 * Reducer tracking queries state, keyed by stable query key. Each reducer 2488 * query object includes `itemIds` and `requestingPageByPerPage`. 2489 * 2490 * @param {Object} state Current state. 2491 * @param {Object} action Dispatched action. 2492 * 2493 * @return {Object} Next state. 2494 */ 2495 2496 2497 var queries = Object(external_this_lodash_["flowRight"])([// Limit to matching action type so we don't attempt to replace action on 2498 // an unhandled action. 2499 if_matching_action(function (action) { 2500 return 'query' in action; 2501 }), // Inject query parts into action for use both in `onSubKey` and reducer. 2502 replace_action(function (action) { 2503 // `ifMatchingAction` still passes on initialization, where state is 2504 // undefined and a query is not assigned. Avoid attempting to parse 2505 // parts. `onSubKey` will omit by lack of `stableKey`. 2506 if (action.query) { 2507 return reducer_objectSpread({}, action, {}, get_query_parts(action.query)); 2508 } 2509 2510 return action; 2511 }), // Queries shape is shared, but keyed by query `stableKey` part. Original 2512 // reducer tracks only a single query object. 2513 on_sub_key('stableKey')])(function () { 2514 var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; 2515 var action = arguments.length > 1 ? arguments[1] : undefined; 2516 var type = action.type, 2517 page = action.page, 2518 perPage = action.perPage, 2519 _action$key = action.key, 2520 key = _action$key === void 0 ? DEFAULT_ENTITY_KEY : _action$key; 2521 2522 if (type !== 'RECEIVE_ITEMS') { 2523 return state; 2524 } 2525 2526 return getMergedItemIds(state || [], Object(external_this_lodash_["map"])(action.items, key), page, perPage); 2527 }); 2528 /* harmony default export */ var queried_data_reducer = (Object(external_this_wp_data_["combineReducers"])({ 2529 items: reducer_items, 2530 queries: queries 2531 })); 2532 2533 // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/reducer.js 2534 2535 2536 2537 2538 function _createForOfIteratorHelper(o) { if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (o = _unsupportedIterableToArray(o))) { var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var it, normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; } 2539 2540 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } 2541 2542 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } 2543 2544 function build_module_reducer_ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } 2545 2546 function build_module_reducer_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { build_module_reducer_ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { build_module_reducer_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } 2547 2548 /** 2549 * External dependencies 2550 */ 2551 2552 /** 2553 * WordPress dependencies 2554 */ 2555 2556 2557 2558 /** 2559 * Internal dependencies 2560 */ 2561 2562 2563 2564 2565 /** 2566 * Reducer managing terms state. Keyed by taxonomy slug, the value is either 2567 * undefined (if no request has been made for given taxonomy), null (if a 2568 * request is in-flight for given taxonomy), or the array of terms for the 2569 * taxonomy. 2570 * 2571 * @param {Object} state Current state. 2572 * @param {Object} action Dispatched action. 2573 * 2574 * @return {Object} Updated state. 2575 */ 2576 2577 function terms() { 2578 var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 2579 var action = arguments.length > 1 ? arguments[1] : undefined; 2580 2581 switch (action.type) { 2582 case 'RECEIVE_TERMS': 2583 return build_module_reducer_objectSpread({}, state, Object(defineProperty["a" /* default */])({}, action.taxonomy, action.terms)); 2584 } 2585 2586 return state; 2587 } 2588 /** 2589 * Reducer managing authors state. Keyed by id. 2590 * 2591 * @param {Object} state Current state. 2592 * @param {Object} action Dispatched action. 2593 * 2594 * @return {Object} Updated state. 2595 */ 2596 2597 function reducer_users() { 2598 var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : { 2599 byId: {}, 2600 queries: {} 2601 }; 2602 var action = arguments.length > 1 ? arguments[1] : undefined; 2603 2604 switch (action.type) { 2605 case 'RECEIVE_USER_QUERY': 2606 return { 2607 byId: build_module_reducer_objectSpread({}, state.byId, {}, Object(external_this_lodash_["keyBy"])(action.users, 'id')), 2608 queries: build_module_reducer_objectSpread({}, state.queries, Object(defineProperty["a" /* default */])({}, action.queryID, Object(external_this_lodash_["map"])(action.users, function (user) { 2609 return user.id; 2610 }))) 2611 }; 2612 } 2613 2614 return state; 2615 } 2616 /** 2617 * Reducer managing current user state. 2618 * 2619 * @param {Object} state Current state. 2620 * @param {Object} action Dispatched action. 2621 * 2622 * @return {Object} Updated state. 2623 */ 2624 2625 function reducer_currentUser() { 2626 var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 2627 var action = arguments.length > 1 ? arguments[1] : undefined; 2628 2629 switch (action.type) { 2630 case 'RECEIVE_CURRENT_USER': 2631 return action.currentUser; 2632 } 2633 2634 return state; 2635 } 2636 /** 2637 * Reducer managing taxonomies. 2638 * 2639 * @param {Object} state Current state. 2640 * @param {Object} action Dispatched action. 2641 * 2642 * @return {Object} Updated state. 2643 */ 2644 2645 function reducer_taxonomies() { 2646 var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []; 2647 var action = arguments.length > 1 ? arguments[1] : undefined; 2648 2649 switch (action.type) { 2650 case 'RECEIVE_TAXONOMIES': 2651 return action.taxonomies; 2652 } 2653 2654 return state; 2655 } 2656 /** 2657 * Reducer managing the current theme. 2658 * 2659 * @param {string} state Current state. 2660 * @param {Object} action Dispatched action. 2661 * 2662 * @return {string} Updated state. 2663 */ 2664 2665 function currentTheme() { 2666 var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined; 2667 var action = arguments.length > 1 ? arguments[1] : undefined; 2668 2669 switch (action.type) { 2670 case 'RECEIVE_CURRENT_THEME': 2671 return action.currentTheme.stylesheet; 2672 } 2673 2674 return state; 2675 } 2676 /** 2677 * Reducer managing installed themes. 2678 * 2679 * @param {Object} state Current state. 2680 * @param {Object} action Dispatched action. 2681 * 2682 * @return {Object} Updated state. 2683 */ 2684 2685 function themes() { 2686 var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 2687 var action = arguments.length > 1 ? arguments[1] : undefined; 2688 2689 switch (action.type) { 2690 case 'RECEIVE_CURRENT_THEME': 2691 return build_module_reducer_objectSpread({}, state, Object(defineProperty["a" /* default */])({}, action.currentTheme.stylesheet, action.currentTheme)); 2692 } 2693 2694 return state; 2695 } 2696 /** 2697 * Reducer managing theme supports data. 2698 * 2699 * @param {Object} state Current state. 2700 * @param {Object} action Dispatched action. 2701 * 2702 * @return {Object} Updated state. 2703 */ 2704 2705 function themeSupports() { 2706 var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 2707 var action = arguments.length > 1 ? arguments[1] : undefined; 2708 2709 switch (action.type) { 2710 case 'RECEIVE_THEME_SUPPORTS': 2711 return build_module_reducer_objectSpread({}, state, {}, action.themeSupports); 2712 } 2713 2714 return state; 2715 } 2716 /** 2717 * Higher Order Reducer for a given entity config. It supports: 2718 * 2719 * - Fetching 2720 * - Editing 2721 * - Saving 2722 * 2723 * @param {Object} entityConfig Entity config. 2724 * 2725 * @return {Function} Reducer. 2726 */ 2727 2728 function reducer_entity(entityConfig) { 2729 return Object(external_this_lodash_["flowRight"])([// Limit to matching action type so we don't attempt to replace action on 2730 // an unhandled action. 2731 if_matching_action(function (action) { 2732 return action.name && action.kind && action.name === entityConfig.name && action.kind === entityConfig.kind; 2733 }), // Inject the entity config into the action. 2734 replace_action(function (action) { 2735 return build_module_reducer_objectSpread({}, action, { 2736 key: entityConfig.key || DEFAULT_ENTITY_KEY 2737 }); 2738 })])(Object(external_this_wp_data_["combineReducers"])({ 2739 queriedData: queried_data_reducer, 2740 edits: function edits() { 2741 var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 2742 var action = arguments.length > 1 ? arguments[1] : undefined; 2743 2744 switch (action.type) { 2745 case 'RECEIVE_ITEMS': 2746 var nextState = build_module_reducer_objectSpread({}, state); 2747 2748 var _iterator = _createForOfIteratorHelper(action.items), 2749 _step; 2750 2751 try { 2752 var _loop = function _loop() { 2753 var record = _step.value; 2754 var recordId = record[action.key]; 2755 var edits = nextState[recordId]; 2756 2757 if (!edits) { 2758 return "continue"; 2759 } 2760 2761 var nextEdits = Object.keys(edits).reduce(function (acc, key) { 2762 // If the edited value is still different to the persisted value, 2763 // keep the edited value in edits. 2764 if ( // Edits are the "raw" attribute values, but records may have 2765 // objects with more properties, so we use `get` here for the 2766 // comparison. 2767 !Object(external_this_lodash_["isEqual"])(edits[key], Object(external_this_lodash_["get"])(record[key], 'raw', record[key]))) { 2768 acc[key] = edits[key]; 2769 } 2770 2771 return acc; 2772 }, {}); 2773 2774 if (Object.keys(nextEdits).length) { 2775 nextState[recordId] = nextEdits; 2776 } else { 2777 delete nextState[recordId]; 2778 } 2779 }; 2780 2781 for (_iterator.s(); !(_step = _iterator.n()).done;) { 2782 var _ret = _loop(); 2783 2784 if (_ret === "continue") continue; 2785 } 2786 } catch (err) { 2787 _iterator.e(err); 2788 } finally { 2789 _iterator.f(); 2790 } 2791 2792 return nextState; 2793 2794 case 'EDIT_ENTITY_RECORD': 2795 var nextEdits = build_module_reducer_objectSpread({}, state[action.recordId], {}, action.edits); 2796 2797 Object.keys(nextEdits).forEach(function (key) { 2798 // Delete cleared edits so that the properties 2799 // are not considered dirty. 2800 if (nextEdits[key] === undefined) { 2801 delete nextEdits[key]; 2802 } 2803 }); 2804 return build_module_reducer_objectSpread({}, state, Object(defineProperty["a" /* default */])({}, action.recordId, nextEdits)); 2805 } 2806 2807 return state; 2808 }, 2809 saving: function saving() { 2810 var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 2811 var action = arguments.length > 1 ? arguments[1] : undefined; 2812 2813 switch (action.type) { 2814 case 'SAVE_ENTITY_RECORD_START': 2815 case 'SAVE_ENTITY_RECORD_FINISH': 2816 return build_module_reducer_objectSpread({}, state, Object(defineProperty["a" /* default */])({}, action.recordId, { 2817 pending: action.type === 'SAVE_ENTITY_RECORD_START', 2818 error: action.error, 2819 isAutosave: action.isAutosave 2820 })); 2821 } 2822 2823 return state; 2824 } 2825 })); 2826 } 2827 /** 2828 * Reducer keeping track of the registered entities. 2829 * 2830 * @param {Object} state Current state. 2831 * @param {Object} action Dispatched action. 2832 * 2833 * @return {Object} Updated state. 2834 */ 2835 2836 2837 function entitiesConfig() { 2838 var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultEntities; 2839 var action = arguments.length > 1 ? arguments[1] : undefined; 2840 2841 switch (action.type) { 2842 case 'ADD_ENTITIES': 2843 return [].concat(Object(toConsumableArray["a" /* default */])(state), Object(toConsumableArray["a" /* default */])(action.entities)); 2844 } 2845 2846 return state; 2847 } 2848 /** 2849 * Reducer keeping track of the registered entities config and data. 2850 * 2851 * @param {Object} state Current state. 2852 * @param {Object} action Dispatched action. 2853 * 2854 * @return {Object} Updated state. 2855 */ 2856 2857 var reducer_entities = function entities() { 2858 var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 2859 var action = arguments.length > 1 ? arguments[1] : undefined; 2860 var newConfig = entitiesConfig(state.config, action); // Generates a dynamic reducer for the entities 2861 2862 var entitiesDataReducer = state.reducer; 2863 2864 if (!entitiesDataReducer || newConfig !== state.config) { 2865 var entitiesByKind = Object(external_this_lodash_["groupBy"])(newConfig, 'kind'); 2866 entitiesDataReducer = Object(external_this_wp_data_["combineReducers"])(Object.entries(entitiesByKind).reduce(function (memo, _ref) { 2867 var _ref2 = Object(slicedToArray["a" /* default */])(_ref, 2), 2868 kind = _ref2[0], 2869 subEntities = _ref2[1]; 2870 2871 var kindReducer = Object(external_this_wp_data_["combineReducers"])(subEntities.reduce(function (kindMemo, entityConfig) { 2872 return build_module_reducer_objectSpread({}, kindMemo, Object(defineProperty["a" /* default */])({}, entityConfig.name, reducer_entity(entityConfig))); 2873 }, {})); 2874 memo[kind] = kindReducer; 2875 return memo; 2876 }, {})); 2877 } 2878 2879 var newData = entitiesDataReducer(state.data, action); 2880 2881 if (newData === state.data && newConfig === state.config && entitiesDataReducer === state.reducer) { 2882 return state; 2883 } 2884 2885 return { 2886 reducer: entitiesDataReducer, 2887 data: newData, 2888 config: newConfig 2889 }; 2890 }; 2891 /** 2892 * Reducer keeping track of entity edit undo history. 2893 * 2894 * @param {Object} state Current state. 2895 * @param {Object} action Dispatched action. 2896 * 2897 * @return {Object} Updated state. 2898 */ 2899 2900 var UNDO_INITIAL_STATE = []; 2901 UNDO_INITIAL_STATE.offset = 0; 2902 var lastEditAction; 2903 function reducer_undo() { 2904 var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : UNDO_INITIAL_STATE; 2905 var action = arguments.length > 1 ? arguments[1] : undefined; 2906 2907 switch (action.type) { 2908 case 'EDIT_ENTITY_RECORD': 2909 case 'CREATE_UNDO_LEVEL': 2910 var isCreateUndoLevel = action.type === 'CREATE_UNDO_LEVEL'; 2911 var isUndoOrRedo = !isCreateUndoLevel && (action.meta.isUndo || action.meta.isRedo); 2912 2913 if (isCreateUndoLevel) { 2914 action = lastEditAction; 2915 } else if (!isUndoOrRedo) { 2916 // Don't lose the last edit cache if the new one only has transient edits. 2917 // Transient edits don't create new levels so updating the cache would make 2918 // us skip an edit later when creating levels explicitly. 2919 if (Object.keys(action.edits).some(function (key) { 2920 return !action.transientEdits[key]; 2921 })) { 2922 lastEditAction = action; 2923 } else { 2924 lastEditAction = build_module_reducer_objectSpread({}, action, { 2925 edits: build_module_reducer_objectSpread({}, lastEditAction && lastEditAction.edits, {}, action.edits) 2926 }); 2927 } 2928 } 2929 2930 var nextState; 2931 2932 if (isUndoOrRedo) { 2933 nextState = Object(toConsumableArray["a" /* default */])(state); 2934 nextState.offset = state.offset + (action.meta.isUndo ? -1 : 1); 2935 2936 if (state.flattenedUndo) { 2937 // The first undo in a sequence of undos might happen while we have 2938 // flattened undos in state. If this is the case, we want execution 2939 // to continue as if we were creating an explicit undo level. This 2940 // will result in an extra undo level being appended with the flattened 2941 // undo values. 2942 isCreateUndoLevel = true; 2943 action = lastEditAction; 2944 } else { 2945 return nextState; 2946 } 2947 } 2948 2949 if (!action.meta.undo) { 2950 return state; 2951 } // Transient edits don't create an undo level, but are 2952 // reachable in the next meaningful edit to which they 2953 // are merged. They are defined in the entity's config. 2954 2955 2956 if (!isCreateUndoLevel && !Object.keys(action.edits).some(function (key) { 2957 return !action.transientEdits[key]; 2958 })) { 2959 nextState = Object(toConsumableArray["a" /* default */])(state); 2960 nextState.flattenedUndo = build_module_reducer_objectSpread({}, state.flattenedUndo, {}, action.edits); 2961 nextState.offset = state.offset; 2962 return nextState; 2963 } // Clear potential redos, because this only supports linear history. 2964 2965 2966 nextState = nextState || state.slice(0, state.offset || undefined); 2967 nextState.offset = nextState.offset || 0; 2968 nextState.pop(); 2969 2970 if (!isCreateUndoLevel) { 2971 nextState.push({ 2972 kind: action.meta.undo.kind, 2973 name: action.meta.undo.name, 2974 recordId: action.meta.undo.recordId, 2975 edits: build_module_reducer_objectSpread({}, state.flattenedUndo, {}, action.meta.undo.edits) 2976 }); 2977 } // When an edit is a function it's an optimization to avoid running some expensive operation. 2978 // We can't rely on the function references being the same so we opt out of comparing them here. 2979 2980 2981 var comparisonUndoEdits = Object.values(action.meta.undo.edits).filter(function (edit) { 2982 return typeof edit !== 'function'; 2983 }); 2984 var comparisonEdits = Object.values(action.edits).filter(function (edit) { 2985 return typeof edit !== 'function'; 2986 }); 2987 2988 if (!external_this_wp_isShallowEqual_default()(comparisonUndoEdits, comparisonEdits)) { 2989 nextState.push({ 2990 kind: action.kind, 2991 name: action.name, 2992 recordId: action.recordId, 2993 edits: isCreateUndoLevel ? build_module_reducer_objectSpread({}, state.flattenedUndo, {}, action.edits) : action.edits 2994 }); 2995 } 2996 2997 return nextState; 2998 } 2999 3000 return state; 3001 } 3002 /** 3003 * Reducer managing embed preview data. 3004 * 3005 * @param {Object} state Current state. 3006 * @param {Object} action Dispatched action. 3007 * 3008 * @return {Object} Updated state. 3009 */ 3010 3011 function embedPreviews() { 3012 var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 3013 var action = arguments.length > 1 ? arguments[1] : undefined; 3014 3015 switch (action.type) { 3016 case 'RECEIVE_EMBED_PREVIEW': 3017 var url = action.url, 3018 preview = action.preview; 3019 return build_module_reducer_objectSpread({}, state, Object(defineProperty["a" /* default */])({}, url, preview)); 3020 } 3021 3022 return state; 3023 } 3024 /** 3025 * State which tracks whether the user can perform an action on a REST 3026 * resource. 3027 * 3028 * @param {Object} state Current state. 3029 * @param {Object} action Dispatched action. 3030 * 3031 * @return {Object} Updated state. 3032 */ 3033 3034 function userPermissions() { 3035 var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 3036 var action = arguments.length > 1 ? arguments[1] : undefined; 3037 3038 switch (action.type) { 3039 case 'RECEIVE_USER_PERMISSION': 3040 return build_module_reducer_objectSpread({}, state, Object(defineProperty["a" /* default */])({}, action.key, action.isAllowed)); 3041 } 3042 3043 return state; 3044 } 3045 /** 3046 * Reducer returning autosaves keyed by their parent's post id. 3047 * 3048 * @param {Object} state Current state. 3049 * @param {Object} action Dispatched action. 3050 * 3051 * @return {Object} Updated state. 3052 */ 3053 3054 function reducer_autosaves() { 3055 var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 3056 var action = arguments.length > 1 ? arguments[1] : undefined; 3057 3058 switch (action.type) { 3059 case 'RECEIVE_AUTOSAVES': 3060 var postId = action.postId, 3061 autosavesData = action.autosaves; 3062 return build_module_reducer_objectSpread({}, state, Object(defineProperty["a" /* default */])({}, postId, autosavesData)); 3063 } 3064 3065 return state; 3066 } 3067 /* harmony default export */ var build_module_reducer = (Object(external_this_wp_data_["combineReducers"])({ 3068 terms: terms, 3069 users: reducer_users, 3070 currentTheme: currentTheme, 3071 currentUser: reducer_currentUser, 3072 taxonomies: reducer_taxonomies, 3073 themes: themes, 3074 themeSupports: themeSupports, 3075 entities: reducer_entities, 3076 undo: reducer_undo, 3077 embedPreviews: embedPreviews, 3078 userPermissions: userPermissions, 3079 autosaves: reducer_autosaves 3080 })); 3081 3082 // EXTERNAL MODULE: ./node_modules/rememo/es/rememo.js 3083 var rememo = __webpack_require__(41); 3084 3085 // EXTERNAL MODULE: external {"this":["wp","deprecated"]} 3086 var external_this_wp_deprecated_ = __webpack_require__(37); 3087 var external_this_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_this_wp_deprecated_); 3088 3089 // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/name.js 3090 /** 3091 * The reducer key used by core data in store registration. 3092 * This is defined in a separate file to avoid cycle-dependency 3093 * 3094 * @type {string} 3095 */ 3096 var REDUCER_KEY = 'core'; 3097 3098 // EXTERNAL MODULE: ./node_modules/equivalent-key-map/equivalent-key-map.js 3099 var equivalent_key_map = __webpack_require__(118); 3100 var equivalent_key_map_default = /*#__PURE__*/__webpack_require__.n(equivalent_key_map); 3101 3102 // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/queried-data/selectors.js 3103 /** 3104 * External dependencies 3105 */ 3106 3107 3108 /** 3109 * Internal dependencies 3110 */ 3111 3112 3113 /** 3114 * Cache of state keys to EquivalentKeyMap where the inner map tracks queries 3115 * to their resulting items set. WeakMap allows garbage collection on expired 3116 * state references. 3117 * 3118 * @type {WeakMap<Object,EquivalentKeyMap>} 3119 */ 3120 3121 var queriedItemsCacheByState = new WeakMap(); 3122 /** 3123 * Returns items for a given query, or null if the items are not known. 3124 * 3125 * @param {Object} state State object. 3126 * @param {?Object} query Optional query. 3127 * 3128 * @return {?Array} Query items. 3129 */ 3130 3131 function getQueriedItemsUncached(state, query) { 3132 var _getQueryParts = get_query_parts(query), 3133 stableKey = _getQueryParts.stableKey, 3134 page = _getQueryParts.page, 3135 perPage = _getQueryParts.perPage; 3136 3137 if (!state.queries[stableKey]) { 3138 return null; 3139 } 3140 3141 var itemIds = state.queries[stableKey]; 3142 3143 if (!itemIds) { 3144 return null; 3145 } 3146 3147 var startOffset = perPage === -1 ? 0 : (page - 1) * perPage; 3148 var endOffset = perPage === -1 ? itemIds.length : Math.min(startOffset + perPage, itemIds.length); 3149 var items = []; 3150 3151 for (var i = startOffset; i < endOffset; i++) { 3152 var itemId = itemIds[i]; 3153 items.push(state.items[itemId]); 3154 } 3155 3156 return items; 3157 } 3158 /** 3159 * Returns items for a given query, or null if the items are not known. Caches 3160 * result both per state (by reference) and per query (by deep equality). 3161 * The caching approach is intended to be durable to query objects which are 3162 * deeply but not referentially equal, since otherwise: 3163 * 3164 * `getQueriedItems( state, {} ) !== getQueriedItems( state, {} )` 3165 * 3166 * @param {Object} state State object. 3167 * @param {?Object} query Optional query. 3168 * 3169 * @return {?Array} Query items. 3170 */ 3171 3172 3173 var getQueriedItems = Object(rememo["a" /* default */])(function (state) { 3174 var query = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; 3175 var queriedItemsCache = queriedItemsCacheByState.get(state); 3176 3177 if (queriedItemsCache) { 3178 var queriedItems = queriedItemsCache.get(query); 3179 3180 if (queriedItems !== undefined) { 3181 return queriedItems; 3182 } 3183 } else { 3184 queriedItemsCache = new equivalent_key_map_default.a(); 3185 queriedItemsCacheByState.set(state, queriedItemsCache); 3186 } 3187 3188 var items = getQueriedItemsUncached(state, query); 3189 queriedItemsCache.set(query, items); 3190 return items; 3191 }); 3192 3193 // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/selectors.js 3194 3195 3196 function selectors_ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } 3197 3198 function selectors_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { selectors_ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { selectors_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } 3199 3200 /** 3201 * External dependencies 3202 */ 3203 3204 3205 /** 3206 * WordPress dependencies 3207 */ 3208 3209 3210 3211 /** 3212 * Internal dependencies 3213 */ 3214 3215 3216 3217 3218 /** 3219 * Returns true if a request is in progress for embed preview data, or false 3220 * otherwise. 3221 * 3222 * @param {Object} state Data state. 3223 * @param {string} url URL the preview would be for. 3224 * 3225 * @return {boolean} Whether a request is in progress for an embed preview. 3226 */ 3227 3228 var isRequestingEmbedPreview = Object(external_this_wp_data_["createRegistrySelector"])(function (select) { 3229 return function (state, url) { 3230 return select('core/data').isResolving(REDUCER_KEY, 'getEmbedPreview', [url]); 3231 }; 3232 }); 3233 /** 3234 * Returns all available authors. 3235 * 3236 * @param {Object} state Data state. 3237 * 3238 * @return {Array} Authors list. 3239 */ 3240 3241 function getAuthors(state) { 3242 return getUserQueryResults(state, 'authors'); 3243 } 3244 /** 3245 * Returns the current user. 3246 * 3247 * @param {Object} state Data state. 3248 * 3249 * @return {Object} Current user object. 3250 */ 3251 3252 function getCurrentUser(state) { 3253 return state.currentUser; 3254 } 3255 /** 3256 * Returns all the users returned by a query ID. 3257 * 3258 * @param {Object} state Data state. 3259 * @param {string} queryID Query ID. 3260 * 3261 * @return {Array} Users list. 3262 */ 3263 3264 var getUserQueryResults = Object(rememo["a" /* default */])(function (state, queryID) { 3265 var queryResults = state.users.queries[queryID]; 3266 return Object(external_this_lodash_["map"])(queryResults, function (id) { 3267 return state.users.byId[id]; 3268 }); 3269 }, function (state, queryID) { 3270 return [state.users.queries[queryID], state.users.byId]; 3271 }); 3272 /** 3273 * Returns whether the entities for the give kind are loaded. 3274 * 3275 * @param {Object} state Data state. 3276 * @param {string} kind Entity kind. 3277 * 3278 * @return {boolean} Whether the entities are loaded 3279 */ 3280 3281 function getEntitiesByKind(state, kind) { 3282 return Object(external_this_lodash_["filter"])(state.entities.config, { 3283 kind: kind 3284 }); 3285 } 3286 /** 3287 * Returns the entity object given its kind and name. 3288 * 3289 * @param {Object} state Data state. 3290 * @param {string} kind Entity kind. 3291 * @param {string} name Entity name. 3292 * 3293 * @return {Object} Entity 3294 */ 3295 3296 function selectors_getEntity(state, kind, name) { 3297 return Object(external_this_lodash_["find"])(state.entities.config, { 3298 kind: kind, 3299 name: name 3300 }); 3301 } 3302 /** 3303 * Returns the Entity's record object by key. 3304 * 3305 * @param {Object} state State tree 3306 * @param {string} kind Entity kind. 3307 * @param {string} name Entity name. 3308 * @param {number} key Record's key 3309 * 3310 * @return {Object?} Record. 3311 */ 3312 3313 function getEntityRecord(state, kind, name, key) { 3314 return Object(external_this_lodash_["get"])(state.entities.data, [kind, name, 'queriedData', 'items', key]); 3315 } 3316 /** 3317 * Returns the Entity's record object by key. Doesn't trigger a resolver nor requests the entity from the API if the entity record isn't available in the local state. 3318 * 3319 * @param {Object} state State tree 3320 * @param {string} kind Entity kind. 3321 * @param {string} name Entity name. 3322 * @param {number} key Record's key 3323 * 3324 * @return {Object?} Record. 3325 */ 3326 3327 function __experimentalGetEntityRecordNoResolver(state, kind, name, key) { 3328 return getEntityRecord(state, kind, name, key); 3329 } 3330 /** 3331 * Returns the entity's record object by key, 3332 * with its attributes mapped to their raw values. 3333 * 3334 * @param {Object} state State tree. 3335 * @param {string} kind Entity kind. 3336 * @param {string} name Entity name. 3337 * @param {number} key Record's key. 3338 * 3339 * @return {Object?} Object with the entity's raw attributes. 3340 */ 3341 3342 var getRawEntityRecord = Object(rememo["a" /* default */])(function (state, kind, name, key) { 3343 var record = getEntityRecord(state, kind, name, key); 3344 return record && Object.keys(record).reduce(function (accumulator, _key) { 3345 // Because edits are the "raw" attribute values, 3346 // we return those from record selectors to make rendering, 3347 // comparisons, and joins with edits easier. 3348 accumulator[_key] = Object(external_this_lodash_["get"])(record[_key], 'raw', record[_key]); 3349 return accumulator; 3350 }, {}); 3351 }, function (state) { 3352 return [state.entities.data]; 3353 }); 3354 /** 3355 * Returns the Entity's records. 3356 * 3357 * @param {Object} state State tree 3358 * @param {string} kind Entity kind. 3359 * @param {string} name Entity name. 3360 * @param {?Object} query Optional terms query. 3361 * 3362 * @return {?Array} Records. 3363 */ 3364 3365 function getEntityRecords(state, kind, name, query) { 3366 var queriedState = Object(external_this_lodash_["get"])(state.entities.data, [kind, name, 'queriedData']); 3367 3368 if (!queriedState) { 3369 return []; 3370 } 3371 3372 return getQueriedItems(queriedState, query); 3373 } 3374 /** 3375 * Returns the list of dirty entity records. 3376 * 3377 * @param {Object} state State tree. 3378 * 3379 * @return {[{ title: string, key: string, name: string, kind: string }]} The list of updated records 3380 */ 3381 3382 var __experimentalGetDirtyEntityRecords = Object(rememo["a" /* default */])(function (state) { 3383 var data = state.entities.data; 3384 var dirtyRecords = []; 3385 Object.keys(data).forEach(function (kind) { 3386 Object.keys(data[kind]).forEach(function (name) { 3387 var primaryKeys = Object.keys(data[kind][name].edits).filter(function (primaryKey) { 3388 return hasEditsForEntityRecord(state, kind, name, primaryKey); 3389 }); 3390 3391 if (primaryKeys.length) { 3392 var entity = selectors_getEntity(state, kind, name); 3393 primaryKeys.forEach(function (primaryKey) { 3394 var entityRecord = getEntityRecord(state, kind, name, primaryKey); 3395 dirtyRecords.push({ 3396 // We avoid using primaryKey because it's transformed into a string 3397 // when it's used as an object key. 3398 key: entityRecord[entity.key || DEFAULT_ENTITY_KEY], 3399 title: !entity.getTitle ? '' : entity.getTitle(entityRecord), 3400 name: name, 3401 kind: kind 3402 }); 3403 }); 3404 } 3405 }); 3406 }); 3407 return dirtyRecords; 3408 }, function (state) { 3409 return [state.entities.data]; 3410 }); 3411 /** 3412 * Returns the specified entity record's edits. 3413 * 3414 * @param {Object} state State tree. 3415 * @param {string} kind Entity kind. 3416 * @param {string} name Entity name. 3417 * @param {number} recordId Record ID. 3418 * 3419 * @return {Object?} The entity record's edits. 3420 */ 3421 3422 function getEntityRecordEdits(state, kind, name, recordId) { 3423 return Object(external_this_lodash_["get"])(state.entities.data, [kind, name, 'edits', recordId]); 3424 } 3425 /** 3426 * Returns the specified entity record's non transient edits. 3427 * 3428 * Transient edits don't create an undo level, and 3429 * are not considered for change detection. 3430 * They are defined in the entity's config. 3431 * 3432 * @param {Object} state State tree. 3433 * @param {string} kind Entity kind. 3434 * @param {string} name Entity name. 3435 * @param {number} recordId Record ID. 3436 * 3437 * @return {Object?} The entity record's non transient edits. 3438 */ 3439 3440 var getEntityRecordNonTransientEdits = Object(rememo["a" /* default */])(function (state, kind, name, recordId) { 3441 var _ref = selectors_getEntity(state, kind, name) || {}, 3442 transientEdits = _ref.transientEdits; 3443 3444 var edits = getEntityRecordEdits(state, kind, name, recordId) || {}; 3445 3446 if (!transientEdits) { 3447 return edits; 3448 } 3449 3450 return Object.keys(edits).reduce(function (acc, key) { 3451 if (!transientEdits[key]) { 3452 acc[key] = edits[key]; 3453 } 3454 3455 return acc; 3456 }, {}); 3457 }, function (state) { 3458 return [state.entities.config, state.entities.data]; 3459 }); 3460 /** 3461 * Returns true if the specified entity record has edits, 3462 * and false otherwise. 3463 * 3464 * @param {Object} state State tree. 3465 * @param {string} kind Entity kind. 3466 * @param {string} name Entity name. 3467 * @param {number} recordId Record ID. 3468 * 3469 * @return {boolean} Whether the entity record has edits or not. 3470 */ 3471 3472 function hasEditsForEntityRecord(state, kind, name, recordId) { 3473 return isSavingEntityRecord(state, kind, name, recordId) || Object.keys(getEntityRecordNonTransientEdits(state, kind, name, recordId)).length > 0; 3474 } 3475 /** 3476 * Returns the specified entity record, merged with its edits. 3477 * 3478 * @param {Object} state State tree. 3479 * @param {string} kind Entity kind. 3480 * @param {string} name Entity name. 3481 * @param {number} recordId Record ID. 3482 * 3483 * @return {Object?} The entity record, merged with its edits. 3484 */ 3485 3486 var getEditedEntityRecord = Object(rememo["a" /* default */])(function (state, kind, name, recordId) { 3487 return selectors_objectSpread({}, getRawEntityRecord(state, kind, name, recordId), {}, getEntityRecordEdits(state, kind, name, recordId)); 3488 }, function (state) { 3489 return [state.entities.data]; 3490 }); 3491 /** 3492 * Returns true if the specified entity record is autosaving, and false otherwise. 3493 * 3494 * @param {Object} state State tree. 3495 * @param {string} kind Entity kind. 3496 * @param {string} name Entity name. 3497 * @param {number} recordId Record ID. 3498 * 3499 * @return {boolean} Whether the entity record is autosaving or not. 3500 */ 3501 3502 function isAutosavingEntityRecord(state, kind, name, recordId) { 3503 var _get = Object(external_this_lodash_["get"])(state.entities.data, [kind, name, 'saving', recordId], {}), 3504 pending = _get.pending, 3505 isAutosave = _get.isAutosave; 3506 3507 return Boolean(pending && isAutosave); 3508 } 3509 /** 3510 * Returns true if the specified entity record is saving, and false otherwise. 3511 * 3512 * @param {Object} state State tree. 3513 * @param {string} kind Entity kind. 3514 * @param {string} name Entity name. 3515 * @param {number} recordId Record ID. 3516 * 3517 * @return {boolean} Whether the entity record is saving or not. 3518 */ 3519 3520 function isSavingEntityRecord(state, kind, name, recordId) { 3521 return Object(external_this_lodash_["get"])(state.entities.data, [kind, name, 'saving', recordId, 'pending'], false); 3522 } 3523 /** 3524 * Returns the specified entity record's last save error. 3525 * 3526 * @param {Object} state State tree. 3527 * @param {string} kind Entity kind. 3528 * @param {string} name Entity name. 3529 * @param {number} recordId Record ID. 3530 * 3531 * @return {Object?} The entity record's save error. 3532 */ 3533 3534 function getLastEntitySaveError(state, kind, name, recordId) { 3535 return Object(external_this_lodash_["get"])(state.entities.data, [kind, name, 'saving', recordId, 'error']); 3536 } 3537 /** 3538 * Returns the current undo offset for the 3539 * entity records edits history. The offset 3540 * represents how many items from the end 3541 * of the history stack we are at. 0 is the 3542 * last edit, -1 is the second last, and so on. 3543 * 3544 * @param {Object} state State tree. 3545 * 3546 * @return {number} The current undo offset. 3547 */ 3548 3549 function getCurrentUndoOffset(state) { 3550 return state.undo.offset; 3551 } 3552 /** 3553 * Returns the previous edit from the current undo offset 3554 * for the entity records edits history, if any. 3555 * 3556 * @param {Object} state State tree. 3557 * 3558 * @return {Object?} The edit. 3559 */ 3560 3561 3562 function getUndoEdit(state) { 3563 return state.undo[state.undo.length - 2 + getCurrentUndoOffset(state)]; 3564 } 3565 /** 3566 * Returns the next edit from the current undo offset 3567 * for the entity records edits history, if any. 3568 * 3569 * @param {Object} state State tree. 3570 * 3571 * @return {Object?} The edit. 3572 */ 3573 3574 function getRedoEdit(state) { 3575 return state.undo[state.undo.length + getCurrentUndoOffset(state)]; 3576 } 3577 /** 3578 * Returns true if there is a previous edit from the current undo offset 3579 * for the entity records edits history, and false otherwise. 3580 * 3581 * @param {Object} state State tree. 3582 * 3583 * @return {boolean} Whether there is a previous edit or not. 3584 */ 3585 3586 function hasUndo(state) { 3587 return Boolean(getUndoEdit(state)); 3588 } 3589 /** 3590 * Returns true if there is a next edit from the current undo offset 3591 * for the entity records edits history, and false otherwise. 3592 * 3593 * @param {Object} state State tree. 3594 * 3595 * @return {boolean} Whether there is a next edit or not. 3596 */ 3597 3598 function hasRedo(state) { 3599 return Boolean(getRedoEdit(state)); 3600 } 3601 /** 3602 * Return the current theme. 3603 * 3604 * @param {Object} state Data state. 3605 * 3606 * @return {Object} The current theme. 3607 */ 3608 3609 function getCurrentTheme(state) { 3610 return state.themes[state.currentTheme]; 3611 } 3612 /** 3613 * Return theme supports data in the index. 3614 * 3615 * @param {Object} state Data state. 3616 * 3617 * @return {*} Index data. 3618 */ 3619 3620 function getThemeSupports(state) { 3621 return state.themeSupports; 3622 } 3623 /** 3624 * Returns the embed preview for the given URL. 3625 * 3626 * @param {Object} state Data state. 3627 * @param {string} url Embedded URL. 3628 * 3629 * @return {*} Undefined if the preview has not been fetched, otherwise, the preview fetched from the embed preview API. 3630 */ 3631 3632 function getEmbedPreview(state, url) { 3633 return state.embedPreviews[url]; 3634 } 3635 /** 3636 * Determines if the returned preview is an oEmbed link fallback. 3637 * 3638 * WordPress can be configured to return a simple link to a URL if it is not embeddable. 3639 * We need to be able to determine if a URL is embeddable or not, based on what we 3640 * get back from the oEmbed preview API. 3641 * 3642 * @param {Object} state Data state. 3643 * @param {string} url Embedded URL. 3644 * 3645 * @return {boolean} Is the preview for the URL an oEmbed link fallback. 3646 */ 3647 3648 function isPreviewEmbedFallback(state, url) { 3649 var preview = state.embedPreviews[url]; 3650 var oEmbedLinkCheck = '<a href="' + url + '">' + url + '</a>'; 3651 3652 if (!preview) { 3653 return false; 3654 } 3655 3656 return preview.html === oEmbedLinkCheck; 3657 } 3658 /** 3659 * Returns whether the current user can upload media. 3660 * 3661 * Calling this may trigger an OPTIONS request to the REST API via the 3662 * `canUser()` resolver. 3663 * 3664 * https://developer.wordpress.org/rest-api/reference/ 3665 * 3666 * @deprecated since 5.0. Callers should use the more generic `canUser()` selector instead of 3667 * `hasUploadPermissions()`, e.g. `canUser( 'create', 'media' )`. 3668 * 3669 * @param {Object} state Data state. 3670 * 3671 * @return {boolean} Whether or not the user can upload media. Defaults to `true` if the OPTIONS 3672 * request is being made. 3673 */ 3674 3675 function hasUploadPermissions(state) { 3676 external_this_wp_deprecated_default()("select( 'core' ).hasUploadPermissions()", { 3677 alternative: "select( 'core' ).canUser( 'create', 'media' )" 3678 }); 3679 return Object(external_this_lodash_["defaultTo"])(canUser(state, 'create', 'media'), true); 3680 } 3681 /** 3682 * Returns whether the current user can perform the given action on the given 3683 * REST resource. 3684 * 3685 * Calling this may trigger an OPTIONS request to the REST API via the 3686 * `canUser()` resolver. 3687 * 3688 * https://developer.wordpress.org/rest-api/reference/ 3689 * 3690 * @param {Object} state Data state. 3691 * @param {string} action Action to check. One of: 'create', 'read', 'update', 'delete'. 3692 * @param {string} resource REST resource to check, e.g. 'media' or 'posts'. 3693 * @param {string=} id Optional ID of the rest resource to check. 3694 * 3695 * @return {boolean|undefined} Whether or not the user can perform the action, 3696 * or `undefined` if the OPTIONS request is still being made. 3697 */ 3698 3699 function canUser(state, action, resource, id) { 3700 var key = Object(external_this_lodash_["compact"])([action, resource, id]).join('/'); 3701 return Object(external_this_lodash_["get"])(state, ['userPermissions', key]); 3702 } 3703 /** 3704 * Returns the latest autosaves for the post. 3705 * 3706 * May return multiple autosaves since the backend stores one autosave per 3707 * author for each post. 3708 * 3709 * @param {Object} state State tree. 3710 * @param {string} postType The type of the parent post. 3711 * @param {number} postId The id of the parent post. 3712 * 3713 * @return {?Array} An array of autosaves for the post, or undefined if there is none. 3714 */ 3715 3716 function getAutosaves(state, postType, postId) { 3717 return state.autosaves[postId]; 3718 } 3719 /** 3720 * Returns the autosave for the post and author. 3721 * 3722 * @param {Object} state State tree. 3723 * @param {string} postType The type of the parent post. 3724 * @param {number} postId The id of the parent post. 3725 * @param {number} authorId The id of the author. 3726 * 3727 * @return {?Object} The autosave for the post and author. 3728 */ 3729 3730 function getAutosave(state, postType, postId, authorId) { 3731 if (authorId === undefined) { 3732 return; 3733 } 3734 3735 var autosaves = state.autosaves[postId]; 3736 return Object(external_this_lodash_["find"])(autosaves, { 3737 author: authorId 3738 }); 3739 } 3740 /** 3741 * Returns true if the REST request for autosaves has completed. 3742 * 3743 * @param {Object} state State tree. 3744 * @param {string} postType The type of the parent post. 3745 * @param {number} postId The id of the parent post. 3746 * 3747 * @return {boolean} True if the REST request was completed. False otherwise. 3748 */ 3749 3750 var hasFetchedAutosaves = Object(external_this_wp_data_["createRegistrySelector"])(function (select) { 3751 return function (state, postType, postId) { 3752 return select(REDUCER_KEY).hasFinishedResolution('getAutosaves', [postType, postId]); 3753 }; 3754 }); 3755 /** 3756 * Returns a new reference when edited values have changed. This is useful in 3757 * inferring where an edit has been made between states by comparison of the 3758 * return values using strict equality. 3759 * 3760 * @example 3761 * 3762 * ``` 3763 * const hasEditOccurred = ( 3764 * getReferenceByDistinctEdits( beforeState ) !== 3765 * getReferenceByDistinctEdits( afterState ) 3766 * ); 3767 * ``` 3768 * 3769 * @param {Object} state Editor state. 3770 * 3771 * @return {*} A value whose reference will change only when an edit occurs. 3772 */ 3773 3774 var getReferenceByDistinctEdits = Object(rememo["a" /* default */])(function () { 3775 return []; 3776 }, function (state) { 3777 return [state.undo.length, state.undo.offset]; 3778 }); 3779 3780 // EXTERNAL MODULE: external {"this":["wp","dataControls"]} 3781 var external_this_wp_dataControls_ = __webpack_require__(36); 3782 3783 // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/if-not-resolved.js 3784 3785 3786 /** 3787 * WordPress dependencies 3788 */ 3789 3790 /** 3791 * Higher-order function which invokes the given resolver only if it has not 3792 * already been resolved with the arguments passed to the enhanced function. 3793 * 3794 * This only considers resolution state, and notably does not support resolver 3795 * custom `isFulfilled` behavior. 3796 * 3797 * @param {Function} resolver Original resolver. 3798 * @param {string} selectorName Selector name associated with resolver. 3799 * 3800 * @return {Function} Enhanced resolver. 3801 */ 3802 3803 var if_not_resolved_ifNotResolved = function ifNotResolved(resolver, selectorName) { 3804 return ( 3805 /*#__PURE__*/ 3806 3807 /** 3808 * @param {...any} args Original resolver arguments. 3809 */ 3810 external_this_regeneratorRuntime_default.a.mark(function resolveIfNotResolved() { 3811 var _len, 3812 args, 3813 _key, 3814 hasStartedResolution, 3815 _args = arguments; 3816 3817 return external_this_regeneratorRuntime_default.a.wrap(function resolveIfNotResolved$(_context) { 3818 while (1) { 3819 switch (_context.prev = _context.next) { 3820 case 0: 3821 for (_len = _args.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 3822 args[_key] = _args[_key]; 3823 } 3824 3825 _context.next = 3; 3826 return Object(external_this_wp_dataControls_["select"])('core', 'hasStartedResolution', selectorName, args); 3827 3828 case 3: 3829 hasStartedResolution = _context.sent; 3830 3831 if (hasStartedResolution) { 3832 _context.next = 6; 3833 break; 3834 } 3835 3836 return _context.delegateYield(resolver.apply(void 0, args), "t0", 6); 3837 3838 case 6: 3839 case "end": 3840 return _context.stop(); 3841 } 3842 } 3843 }, resolveIfNotResolved); 3844 }) 3845 ); 3846 }; 3847 3848 /* harmony default export */ var if_not_resolved = (if_not_resolved_ifNotResolved); 3849 3850 // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/resolvers.js 3851 3852 3853 3854 function resolvers_ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } 3855 3856 function resolvers_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { resolvers_ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { resolvers_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } 3857 3858 var resolvers_marked = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(resolvers_getAuthors), 3859 resolvers_marked2 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(resolvers_getCurrentUser), 3860 resolvers_marked3 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(resolvers_getEntityRecord), 3861 resolvers_marked4 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(resolvers_getEntityRecords), 3862 resolvers_marked5 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(resolvers_getCurrentTheme), 3863 _marked6 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(resolvers_getThemeSupports), 3864 _marked7 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(resolvers_getEmbedPreview), 3865 _marked8 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(resolvers_hasUploadPermissions), 3866 _marked9 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(resolvers_canUser), 3867 _marked10 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(resolvers_getAutosaves), 3868 _marked11 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(resolvers_getAutosave); 3869 3870 /** 3871 * External dependencies 3872 */ 3873 3874 /** 3875 * WordPress dependencies 3876 */ 3877 3878 3879 3880 /** 3881 * Internal dependencies 3882 */ 3883 3884 3885 3886 3887 3888 /** 3889 * Requests authors from the REST API. 3890 */ 3891 3892 function resolvers_getAuthors() { 3893 var users; 3894 return external_this_regeneratorRuntime_default.a.wrap(function getAuthors$(_context) { 3895 while (1) { 3896 switch (_context.prev = _context.next) { 3897 case 0: 3898 _context.next = 2; 3899 return apiFetch({ 3900 path: '/wp/v2/users/?who=authors&per_page=-1' 3901 }); 3902 3903 case 2: 3904 users = _context.sent; 3905 _context.next = 5; 3906 return receiveUserQuery('authors', users); 3907 3908 case 5: 3909 case "end": 3910 return _context.stop(); 3911 } 3912 } 3913 }, resolvers_marked); 3914 } 3915 /** 3916 * Requests the current user from the REST API. 3917 */ 3918 3919 function resolvers_getCurrentUser() { 3920 var currentUser; 3921 return external_this_regeneratorRuntime_default.a.wrap(function getCurrentUser$(_context2) { 3922 while (1) { 3923 switch (_context2.prev = _context2.next) { 3924 case 0: 3925 _context2.next = 2; 3926 return apiFetch({ 3927 path: '/wp/v2/users/me' 3928 }); 3929 3930 case 2: 3931 currentUser = _context2.sent; 3932 _context2.next = 5; 3933 return receiveCurrentUser(currentUser); 3934 3935 case 5: 3936 case "end": 3937 return _context2.stop(); 3938 } 3939 } 3940 }, resolvers_marked2); 3941 } 3942 /** 3943 * Requests an entity's record from the REST API. 3944 * 3945 * @param {string} kind Entity kind. 3946 * @param {string} name Entity name. 3947 * @param {number} key Record's key 3948 */ 3949 3950 function resolvers_getEntityRecord(kind, name) { 3951 var key, 3952 entities, 3953 entity, 3954 record, 3955 _args3 = arguments; 3956 return external_this_regeneratorRuntime_default.a.wrap(function getEntityRecord$(_context3) { 3957 while (1) { 3958 switch (_context3.prev = _context3.next) { 3959 case 0: 3960 key = _args3.length > 2 && _args3[2] !== undefined ? _args3[2] : ''; 3961 _context3.next = 3; 3962 return getKindEntities(kind); 3963 3964 case 3: 3965 entities = _context3.sent; 3966 entity = Object(external_this_lodash_["find"])(entities, { 3967 kind: kind, 3968 name: name 3969 }); 3970 3971 if (entity) { 3972 _context3.next = 7; 3973 break; 3974 } 3975 3976 return _context3.abrupt("return"); 3977 3978 case 7: 3979 _context3.next = 9; 3980 return apiFetch({ 3981 path: "".concat(entity.baseURL, "/").concat(key, "?context=edit") 3982 }); 3983 3984 case 9: 3985 record = _context3.sent; 3986 _context3.next = 12; 3987 return receiveEntityRecords(kind, name, record); 3988 3989 case 12: 3990 case "end": 3991 return _context3.stop(); 3992 } 3993 } 3994 }, resolvers_marked3); 3995 } 3996 /** 3997 * Requests an entity's record from the REST API. 3998 */ 3999 4000 var resolvers_getRawEntityRecord = if_not_resolved(resolvers_getEntityRecord, 'getEntityRecord'); 4001 /** 4002 * Requests an entity's record from the REST API. 4003 */ 4004 4005 var resolvers_getEditedEntityRecord = if_not_resolved(resolvers_getRawEntityRecord, 'getRawEntityRecord'); 4006 /** 4007 * Requests the entity's records from the REST API. 4008 * 4009 * @param {string} kind Entity kind. 4010 * @param {string} name Entity name. 4011 * @param {Object?} query Query Object. 4012 */ 4013 4014 function resolvers_getEntityRecords(kind, name) { 4015 var query, 4016 entities, 4017 entity, 4018 path, 4019 records, 4020 _args4 = arguments; 4021 return external_this_regeneratorRuntime_default.a.wrap(function getEntityRecords$(_context4) { 4022 while (1) { 4023 switch (_context4.prev = _context4.next) { 4024 case 0: 4025 query = _args4.length > 2 && _args4[2] !== undefined ? _args4[2] : {}; 4026 _context4.next = 3; 4027 return getKindEntities(kind); 4028 4029 case 3: 4030 entities = _context4.sent; 4031 entity = Object(external_this_lodash_["find"])(entities, { 4032 kind: kind, 4033 name: name 4034 }); 4035 4036 if (entity) { 4037 _context4.next = 7; 4038 break; 4039 } 4040 4041 return _context4.abrupt("return"); 4042 4043 case 7: 4044 path = Object(external_this_wp_url_["addQueryArgs"])(entity.baseURL, resolvers_objectSpread({}, query, { 4045 context: 'edit' 4046 })); 4047 _context4.next = 10; 4048 return apiFetch({ 4049 path: path 4050 }); 4051 4052 case 10: 4053 records = _context4.sent; 4054 _context4.next = 13; 4055 return receiveEntityRecords(kind, name, Object.values(records), query); 4056 4057 case 13: 4058 case "end": 4059 return _context4.stop(); 4060 } 4061 } 4062 }, resolvers_marked4); 4063 } 4064 4065 resolvers_getEntityRecords.shouldInvalidate = function (action, kind, name) { 4066 return action.type === 'RECEIVE_ITEMS' && action.invalidateCache && kind === action.kind && name === action.name; 4067 }; 4068 /** 4069 * Requests the current theme. 4070 */ 4071 4072 4073 function resolvers_getCurrentTheme() { 4074 var activeThemes; 4075 return external_this_regeneratorRuntime_default.a.wrap(function getCurrentTheme$(_context5) { 4076 while (1) { 4077 switch (_context5.prev = _context5.next) { 4078 case 0: 4079 _context5.next = 2; 4080 return apiFetch({ 4081 path: '/wp/v2/themes?status=active' 4082 }); 4083 4084 case 2: 4085 activeThemes = _context5.sent; 4086 _context5.next = 5; 4087 return receiveCurrentTheme(activeThemes[0]); 4088 4089 case 5: 4090 case "end": 4091 return _context5.stop(); 4092 } 4093 } 4094 }, resolvers_marked5); 4095 } 4096 /** 4097 * Requests theme supports data from the index. 4098 */ 4099 4100 function resolvers_getThemeSupports() { 4101 var activeThemes; 4102 return external_this_regeneratorRuntime_default.a.wrap(function getThemeSupports$(_context6) { 4103 while (1) { 4104 switch (_context6.prev = _context6.next) { 4105 case 0: 4106 _context6.next = 2; 4107 return apiFetch({ 4108 path: '/wp/v2/themes?status=active' 4109 }); 4110 4111 case 2: 4112 activeThemes = _context6.sent; 4113 _context6.next = 5; 4114 return receiveThemeSupports(activeThemes[0].theme_supports); 4115 4116 case 5: 4117 case "end": 4118 return _context6.stop(); 4119 } 4120 } 4121 }, _marked6); 4122 } 4123 /** 4124 * Requests a preview from the from the Embed API. 4125 * 4126 * @param {string} url URL to get the preview for. 4127 */ 4128 4129 function resolvers_getEmbedPreview(url) { 4130 var embedProxyResponse; 4131 return external_this_regeneratorRuntime_default.a.wrap(function getEmbedPreview$(_context7) { 4132 while (1) { 4133 switch (_context7.prev = _context7.next) { 4134 case 0: 4135 _context7.prev = 0; 4136 _context7.next = 3; 4137 return apiFetch({ 4138 path: Object(external_this_wp_url_["addQueryArgs"])('/oembed/1.0/proxy', { 4139 url: url 4140 }) 4141 }); 4142 4143 case 3: 4144 embedProxyResponse = _context7.sent; 4145 _context7.next = 6; 4146 return receiveEmbedPreview(url, embedProxyResponse); 4147 4148 case 6: 4149 _context7.next = 12; 4150 break; 4151 4152 case 8: 4153 _context7.prev = 8; 4154 _context7.t0 = _context7["catch"](0); 4155 _context7.next = 12; 4156 return receiveEmbedPreview(url, false); 4157 4158 case 12: 4159 case "end": 4160 return _context7.stop(); 4161 } 4162 } 4163 }, _marked7, null, [[0, 8]]); 4164 } 4165 /** 4166 * Requests Upload Permissions from the REST API. 4167 * 4168 * @deprecated since 5.0. Callers should use the more generic `canUser()` selector instead of 4169 * `hasUploadPermissions()`, e.g. `canUser( 'create', 'media' )`. 4170 */ 4171 4172 function resolvers_hasUploadPermissions() { 4173 return external_this_regeneratorRuntime_default.a.wrap(function hasUploadPermissions$(_context8) { 4174 while (1) { 4175 switch (_context8.prev = _context8.next) { 4176 case 0: 4177 external_this_wp_deprecated_default()("select( 'core' ).hasUploadPermissions()", { 4178 alternative: "select( 'core' ).canUser( 'create', 'media' )" 4179 }); 4180 return _context8.delegateYield(resolvers_canUser('create', 'media'), "t0", 2); 4181 4182 case 2: 4183 case "end": 4184 return _context8.stop(); 4185 } 4186 } 4187 }, _marked8); 4188 } 4189 /** 4190 * Checks whether the current user can perform the given action on the given 4191 * REST resource. 4192 * 4193 * @param {string} action Action to check. One of: 'create', 'read', 'update', 4194 * 'delete'. 4195 * @param {string} resource REST resource to check, e.g. 'media' or 'posts'. 4196 * @param {?string} id ID of the rest resource to check. 4197 */ 4198 4199 function resolvers_canUser(action, resource, id) { 4200 var methods, method, path, response, allowHeader, key, isAllowed; 4201 return external_this_regeneratorRuntime_default.a.wrap(function canUser$(_context9) { 4202 while (1) { 4203 switch (_context9.prev = _context9.next) { 4204 case 0: 4205 methods = { 4206 create: 'POST', 4207 read: 'GET', 4208 update: 'PUT', 4209 delete: 'DELETE' 4210 }; 4211 method = methods[action]; 4212 4213 if (method) { 4214 _context9.next = 4; 4215 break; 4216 } 4217 4218 throw new Error("'".concat(action, "' is not a valid action.")); 4219 4220 case 4: 4221 path = id ? "/wp/v2/".concat(resource, "/").concat(id) : "/wp/v2/".concat(resource); 4222 _context9.prev = 5; 4223 _context9.next = 8; 4224 return apiFetch({ 4225 path: path, 4226 // Ideally this would always be an OPTIONS request, but unfortunately there's 4227 // a bug in the REST API which causes the Allow header to not be sent on 4228 // OPTIONS requests to /posts/:id routes. 4229 // https://core.trac.wordpress.org/ticket/45753 4230 method: id ? 'GET' : 'OPTIONS', 4231 parse: false 4232 }); 4233 4234 case 8: 4235 response = _context9.sent; 4236 _context9.next = 14; 4237 break; 4238 4239 case 11: 4240 _context9.prev = 11; 4241 _context9.t0 = _context9["catch"](5); 4242 return _context9.abrupt("return"); 4243 4244 case 14: 4245 if (Object(external_this_lodash_["hasIn"])(response, ['headers', 'get'])) { 4246 // If the request is fetched using the fetch api, the header can be 4247 // retrieved using the 'get' method. 4248 allowHeader = response.headers.get('allow'); 4249 } else { 4250 // If the request was preloaded server-side and is returned by the 4251 // preloading middleware, the header will be a simple property. 4252 allowHeader = Object(external_this_lodash_["get"])(response, ['headers', 'Allow'], ''); 4253 } 4254 4255 key = Object(external_this_lodash_["compact"])([action, resource, id]).join('/'); 4256 isAllowed = Object(external_this_lodash_["includes"])(allowHeader, method); 4257 _context9.next = 19; 4258 return receiveUserPermission(key, isAllowed); 4259 4260 case 19: 4261 case "end": 4262 return _context9.stop(); 4263 } 4264 } 4265 }, _marked9, null, [[5, 11]]); 4266 } 4267 /** 4268 * Request autosave data from the REST API. 4269 * 4270 * @param {string} postType The type of the parent post. 4271 * @param {number} postId The id of the parent post. 4272 */ 4273 4274 function resolvers_getAutosaves(postType, postId) { 4275 var _yield$resolveSelect, restBase, autosaves; 4276 4277 return external_this_regeneratorRuntime_default.a.wrap(function getAutosaves$(_context10) { 4278 while (1) { 4279 switch (_context10.prev = _context10.next) { 4280 case 0: 4281 _context10.next = 2; 4282 return resolveSelect('getPostType', postType); 4283 4284 case 2: 4285 _yield$resolveSelect = _context10.sent; 4286 restBase = _yield$resolveSelect.rest_base; 4287 _context10.next = 6; 4288 return apiFetch({ 4289 path: "/wp/v2/".concat(restBase, "/").concat(postId, "/autosaves?context=edit") 4290 }); 4291 4292 case 6: 4293 autosaves = _context10.sent; 4294 4295 if (!(autosaves && autosaves.length)) { 4296 _context10.next = 10; 4297 break; 4298 } 4299 4300 _context10.next = 10; 4301 return receiveAutosaves(postId, autosaves); 4302 4303 case 10: 4304 case "end": 4305 return _context10.stop(); 4306 } 4307 } 4308 }, _marked10); 4309 } 4310 /** 4311 * Request autosave data from the REST API. 4312 * 4313 * This resolver exists to ensure the underlying autosaves are fetched via 4314 * `getAutosaves` when a call to the `getAutosave` selector is made. 4315 * 4316 * @param {string} postType The type of the parent post. 4317 * @param {number} postId The id of the parent post. 4318 */ 4319 4320 function resolvers_getAutosave(postType, postId) { 4321 return external_this_regeneratorRuntime_default.a.wrap(function getAutosave$(_context11) { 4322 while (1) { 4323 switch (_context11.prev = _context11.next) { 4324 case 0: 4325 _context11.next = 2; 4326 return resolveSelect('getAutosaves', postType, postId); 4327 4328 case 2: 4329 case "end": 4330 return _context11.stop(); 4331 } 4332 } 4333 }, _marked11); 4334 } 4335 4336 // EXTERNAL MODULE: external {"this":["wp","element"]} 4337 var external_this_wp_element_ = __webpack_require__(0); 4338 4339 // EXTERNAL MODULE: external {"this":["wp","blocks"]} 4340 var external_this_wp_blocks_ = __webpack_require__(12); 4341 4342 // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/entity-provider.js 4343 4344 4345 4346 4347 function entity_provider_ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } 4348 4349 function entity_provider_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { entity_provider_ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { entity_provider_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } 4350 4351 /** 4352 * WordPress dependencies 4353 */ 4354 4355 4356 4357 /** 4358 * Internal dependencies 4359 */ 4360 4361 4362 4363 var entity_provider_entities = entity_provider_objectSpread({}, defaultEntities.reduce(function (acc, entity) { 4364 if (!acc[entity.kind]) { 4365 acc[entity.kind] = {}; 4366 } 4367 4368 acc[entity.kind][entity.name] = { 4369 context: Object(external_this_wp_element_["createContext"])() 4370 }; 4371 return acc; 4372 }, {}), {}, kinds.reduce(function (acc, kind) { 4373 acc[kind.name] = {}; 4374 return acc; 4375 }, {})); 4376 4377 var entity_provider_getEntity = function getEntity(kind, type) { 4378 if (!entity_provider_entities[kind]) { 4379 throw new Error("Missing entity config for kind: ".concat(kind, ".")); 4380 } 4381 4382 if (!entity_provider_entities[kind][type]) { 4383 entity_provider_entities[kind][type] = { 4384 context: Object(external_this_wp_element_["createContext"])() 4385 }; 4386 } 4387 4388 return entity_provider_entities[kind][type]; 4389 }; 4390 /** 4391 * Context provider component for providing 4392 * an entity for a specific entity type. 4393 * 4394 * @param {Object} props The component's props. 4395 * @param {string} props.kind The entity kind. 4396 * @param {string} props.type The entity type. 4397 * @param {number} props.id The entity ID. 4398 * @param {*} props.children The children to wrap. 4399 * 4400 * @return {Object} The provided children, wrapped with 4401 * the entity's context provider. 4402 */ 4403 4404 4405 function EntityProvider(_ref) { 4406 var kind = _ref.kind, 4407 type = _ref.type, 4408 id = _ref.id, 4409 children = _ref.children; 4410 var Provider = entity_provider_getEntity(kind, type).context.Provider; 4411 return Object(external_this_wp_element_["createElement"])(Provider, { 4412 value: id 4413 }, children); 4414 } 4415 /** 4416 * Hook that returns the ID for the nearest 4417 * provided entity of the specified type. 4418 * 4419 * @param {string} kind The entity kind. 4420 * @param {string} type The entity type. 4421 */ 4422 4423 function useEntityId(kind, type) { 4424 return Object(external_this_wp_element_["useContext"])(entity_provider_getEntity(kind, type).context); 4425 } 4426 /** 4427 * Hook that returns the value and a setter for the 4428 * specified property of the nearest provided 4429 * entity of the specified type. 4430 * 4431 * @param {string} kind The entity kind. 4432 * @param {string} type The entity type. 4433 * @param {string} prop The property name. 4434 * @param {string} [_id] An entity ID to use instead of the context-provided one. 4435 * 4436 * @return {[*, Function]} A tuple where the first item is the 4437 * property value and the second is the 4438 * setter. 4439 */ 4440 4441 function useEntityProp(kind, type, prop, _id) { 4442 var providerId = useEntityId(kind, type); 4443 var id = _id !== null && _id !== void 0 ? _id : providerId; 4444 4445 var _useSelect = Object(external_this_wp_data_["useSelect"])(function (select) { 4446 var _select = select('core'), 4447 getEntityRecord = _select.getEntityRecord, 4448 getEditedEntityRecord = _select.getEditedEntityRecord; 4449 4450 var entity = getEntityRecord(kind, type, id); // Trigger resolver. 4451 4452 var editedEntity = getEditedEntityRecord(kind, type, id); 4453 return entity && editedEntity ? { 4454 value: editedEntity[prop], 4455 fullValue: entity[prop] 4456 } : {}; 4457 }, [kind, type, id, prop]), 4458 value = _useSelect.value, 4459 fullValue = _useSelect.fullValue; 4460 4461 var _useDispatch = Object(external_this_wp_data_["useDispatch"])('core'), 4462 editEntityRecord = _useDispatch.editEntityRecord; 4463 4464 var setValue = Object(external_this_wp_element_["useCallback"])(function (newValue) { 4465 editEntityRecord(kind, type, id, Object(defineProperty["a" /* default */])({}, prop, newValue)); 4466 }, [kind, type, id, prop]); 4467 return [value, setValue, fullValue]; 4468 } 4469 /** 4470 * Hook that returns block content getters and setters for 4471 * the nearest provided entity of the specified type. 4472 * 4473 * The return value has the shape `[ blocks, onInput, onChange ]`. 4474 * `onInput` is for block changes that don't create undo levels 4475 * or dirty the post, non-persistent changes, and `onChange` is for 4476 * peristent changes. They map directly to the props of a 4477 * `BlockEditorProvider` and are intended to be used with it, 4478 * or similar components or hooks. 4479 * 4480 * @param {string} kind The entity kind. 4481 * @param {string} type The entity type. 4482 * @param {Object} options 4483 * @param {Object} [options.initialEdits] Initial edits object for the entity record. 4484 * @param {string} [options.blocksProp='blocks'] The name of the entity prop that holds the blocks array. 4485 * @param {string} [options.contentProp='content'] The name of the entity prop that holds the serialized blocks. 4486 * @param {string} [options.id] An entity ID to use instead of the context-provided one. 4487 * 4488 * @return {[WPBlock[], Function, Function]} The block array and setters. 4489 */ 4490 4491 function useEntityBlockEditor(kind, type) { 4492 var _ref2 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}, 4493 initialEdits = _ref2.initialEdits, 4494 _ref2$blocksProp = _ref2.blocksProp, 4495 blocksProp = _ref2$blocksProp === void 0 ? 'blocks' : _ref2$blocksProp, 4496 _ref2$contentProp = _ref2.contentProp, 4497 contentProp = _ref2$contentProp === void 0 ? 'content' : _ref2$contentProp, 4498 _id = _ref2.id; 4499 4500 var providerId = useEntityId(kind, type); 4501 var id = _id !== null && _id !== void 0 ? _id : providerId; 4502 4503 var _useEntityProp = useEntityProp(kind, type, contentProp, id), 4504 _useEntityProp2 = Object(slicedToArray["a" /* default */])(_useEntityProp, 2), 4505 content = _useEntityProp2[0], 4506 setContent = _useEntityProp2[1]; 4507 4508 var _useDispatch2 = Object(external_this_wp_data_["useDispatch"])('core'), 4509 editEntityRecord = _useDispatch2.editEntityRecord; 4510 4511 Object(external_this_wp_element_["useEffect"])(function () { 4512 if (initialEdits) { 4513 editEntityRecord(kind, type, id, initialEdits, { 4514 undoIgnore: true 4515 }); 4516 } 4517 }, [id]); 4518 var initialBlocks = Object(external_this_wp_element_["useMemo"])(function () { 4519 // Guard against other instances that might have 4520 // set content to a function already. 4521 if (content && typeof content !== 'function') { 4522 var parsedContent = Object(external_this_wp_blocks_["parse"])(content); 4523 return parsedContent.length ? parsedContent : []; 4524 } 4525 4526 return []; 4527 }, [content]); 4528 4529 var _useEntityProp3 = useEntityProp(kind, type, blocksProp, id), 4530 _useEntityProp4 = Object(slicedToArray["a" /* default */])(_useEntityProp3, 2), 4531 _useEntityProp4$ = _useEntityProp4[0], 4532 blocks = _useEntityProp4$ === void 0 ? initialBlocks : _useEntityProp4$, 4533 onInput = _useEntityProp4[1]; 4534 4535 var onChange = Object(external_this_wp_element_["useCallback"])(function (nextBlocks) { 4536 onInput(nextBlocks); // Use a function edit to avoid serializing often. 4537 4538 setContent(function (_ref3) { 4539 var blocksToSerialize = _ref3.blocks; 4540 return Object(external_this_wp_blocks_["serialize"])(blocksToSerialize); 4541 }); 4542 }, [onInput, setContent]); 4543 return [blocks, onInput, onChange]; 4544 } 4545 4546 // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/index.js 4547 4548 4549 function build_module_ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } 4550 4551 function build_module_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { build_module_ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { build_module_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } 4552 4553 /** 4554 * WordPress dependencies 4555 */ 4556 4557 /** 4558 * Internal dependencies 4559 */ 4560 4561 4562 4563 4564 4565 4566 4567 // The entity selectors/resolvers and actions are shortcuts to their generic equivalents 4568 // (getEntityRecord, getEntityRecords, updateEntityRecord, updateEntityRecordss) 4569 // Instead of getEntityRecord, the consumer could use more user-frieldly named selector: getPostType, getTaxonomy... 4570 // The "kind" and the "name" of the entity are combined to generate these shortcuts. 4571 4572 var entitySelectors = defaultEntities.reduce(function (result, entity) { 4573 var kind = entity.kind, 4574 name = entity.name; 4575 4576 result[entities_getMethodName(kind, name)] = function (state, key) { 4577 return getEntityRecord(state, kind, name, key); 4578 }; 4579 4580 result[entities_getMethodName(kind, name, 'get', true)] = function (state) { 4581 for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { 4582 args[_key - 1] = arguments[_key]; 4583 } 4584 4585 return getEntityRecords.apply(build_module_selectors_namespaceObject, [state, kind, name].concat(args)); 4586 }; 4587 4588 return result; 4589 }, {}); 4590 var entityResolvers = defaultEntities.reduce(function (result, entity) { 4591 var kind = entity.kind, 4592 name = entity.name; 4593 4594 result[entities_getMethodName(kind, name)] = function (key) { 4595 return resolvers_getEntityRecord(kind, name, key); 4596 }; 4597 4598 var pluralMethodName = entities_getMethodName(kind, name, 'get', true); 4599 4600 result[pluralMethodName] = function () { 4601 for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { 4602 args[_key2] = arguments[_key2]; 4603 } 4604 4605 return resolvers_getEntityRecords.apply(resolvers_namespaceObject, [kind, name].concat(args)); 4606 }; 4607 4608 result[pluralMethodName].shouldInvalidate = function (action) { 4609 var _resolvers$getEntityR; 4610 4611 for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) { 4612 args[_key3 - 1] = arguments[_key3]; 4613 } 4614 4615 return (_resolvers$getEntityR = resolvers_getEntityRecords).shouldInvalidate.apply(_resolvers$getEntityR, [action, kind, name].concat(args)); 4616 }; 4617 4618 return result; 4619 }, {}); 4620 var entityActions = defaultEntities.reduce(function (result, entity) { 4621 var kind = entity.kind, 4622 name = entity.name; 4623 4624 result[entities_getMethodName(kind, name, 'save')] = function (key) { 4625 return saveEntityRecord(kind, name, key); 4626 }; 4627 4628 return result; 4629 }, {}); 4630 Object(external_this_wp_data_["registerStore"])(REDUCER_KEY, { 4631 reducer: build_module_reducer, 4632 controls: build_module_controls, 4633 actions: build_module_objectSpread({}, build_module_actions_namespaceObject, {}, entityActions), 4634 selectors: build_module_objectSpread({}, build_module_selectors_namespaceObject, {}, entitySelectors), 4635 resolvers: build_module_objectSpread({}, resolvers_namespaceObject, {}, entityResolvers) 4636 }); 4637 4638 4639 4640 4641 /***/ }), 4642 4643 /***/ 45: 4644 /***/ (function(module, exports) { 4645 4646 (function() { module.exports = this["wp"]["apiFetch"]; }()); 4647 4648 /***/ }), 4649 4650 /***/ 5: 4651 /***/ (function(module, __webpack_exports__, __webpack_require__) { 4652 4653 "use strict"; 4654 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _defineProperty; }); 4655 function _defineProperty(obj, key, value) { 4656 if (key in obj) { 4657 Object.defineProperty(obj, key, { 4658 value: value, 4659 enumerable: true, 4660 configurable: true, 4661 writable: true 4662 }); 4663 } else { 4664 obj[key] = value; 4665 } 4666 4667 return obj; 4668 } 4669 4670 /***/ }), 4671 4672 /***/ 55: 4673 /***/ (function(module, exports) { 4674 4675 (function() { module.exports = this["wp"]["isShallowEqual"]; }()); 4676 4677 /***/ }) 4678 4679 /******/ });
title
Description
Body
title
Description
Body
title
Description
Body
title
Body
| Generated: Tue Jul 7 01:00:03 2020 | Cross-referenced by PHPXref 0.7.1 |