1(function() { 2"use strict"; 3var wp; 4(wp ||= {}).data = (() => { 5 var __create = Object.create; 6 var __defProp = Object.defineProperty; 7 var __getOwnPropDesc = Object.getOwnPropertyDescriptor; 8 var __getOwnPropNames = Object.getOwnPropertyNames; 9 var __getProtoOf = Object.getPrototypeOf; 10 var __hasOwnProp = Object.prototype.hasOwnProperty; 11 var __commonJS = (cb, mod) => function __require() { 12 return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; 13 }; 14 var __export = (target, all) => { 15 for (var name in all) 16 __defProp(target, name, { get: all[name], enumerable: true }); 17 }; 18 var __copyProps = (to, from, except, desc) => { 19 if (from && typeof from === "object" || typeof from === "function") { 20 for (let key of __getOwnPropNames(from)) 21 if (!__hasOwnProp.call(to, key) && key !== except) 22 __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); 23 } 24 return to; 25 }; 26 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( 27 // If the importer is in node compatibility mode or this is not an ESM 28 // file that has been converted to a CommonJS file using a Babel- 29 // compatible transform (i.e. "__esModule" has not been set), then set 30 // "default" to the CommonJS "module.exports" for node compatibility. 31 isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, 32 mod 33 )); 34 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); 35 36 // package-external:@wordpress/deprecated 37 var require_deprecated = __commonJS({ 38 "package-external:@wordpress/deprecated"(exports, module) { 39 module.exports = window.wp.deprecated; 40 } 41 }); 42 43
vendor: 8,351 bytes, lines 43-277
43// node_modules/equivalent-key-map/equivalent-key-map.js 44 var require_equivalent_key_map = __commonJS({ 45 "node_modules/equivalent-key-map/equivalent-key-map.js"(exports, module) { 46 "use strict"; 47 function _typeof(obj) { 48 if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { 49 _typeof = function(obj2) { 50 return typeof obj2; 51 }; 52 } else { 53 _typeof = function(obj2) { 54 return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2; 55 }; 56 } 57 return _typeof(obj); 58 } 59 function _classCallCheck(instance, Constructor) { 60 if (!(instance instanceof Constructor)) { 61 throw new TypeError("Cannot call a class as a function"); 62 } 63 } 64 function _defineProperties(target, props) { 65 for (var i = 0; i < props.length; i++) { 66 var descriptor = props[i]; 67 descriptor.enumerable = descriptor.enumerable || false; 68 descriptor.configurable = true; 69 if ("value" in descriptor) descriptor.writable = true; 70 Object.defineProperty(target, descriptor.key, descriptor); 71 } 72 } 73 function _createClass(Constructor, protoProps, staticProps) { 74 if (protoProps) _defineProperties(Constructor.prototype, protoProps); 75 if (staticProps) _defineProperties(Constructor, staticProps); 76 return Constructor; 77 } 78 function getValuePair(instance, key) { 79 var _map = instance._map, _arrayTreeMap = instance._arrayTreeMap, _objectTreeMap = instance._objectTreeMap; 80 if (_map.has(key)) { 81 return _map.get(key); 82 } 83 var properties = Object.keys(key).sort(); 84 var map = Array.isArray(key) ? _arrayTreeMap : _objectTreeMap; 85 for (var i = 0; i < properties.length; i++) { 86 var property = properties[i]; 87 map = map.get(property); 88 if (map === void 0) { 89 return; 90 } 91 var propertyValue = key[property]; 92 map = map.get(propertyValue); 93 if (map === void 0) { 94 return; 95 } 96 } 97 var valuePair = map.get("_ekm_value"); 98 if (!valuePair) { 99 return; 100 } 101 _map.delete(valuePair[0]); 102 valuePair[0] = key; 103 map.set("_ekm_value", valuePair); 104 _map.set(key, valuePair); 105 return valuePair; 106 } 107 var EquivalentKeyMap3 = /* @__PURE__ */ (function() { 108 function EquivalentKeyMap4(iterable) { 109 _classCallCheck(this, EquivalentKeyMap4); 110 this.clear(); 111 if (iterable instanceof EquivalentKeyMap4) { 112 var iterablePairs = []; 113 iterable.forEach(function(value, key) { 114 iterablePairs.push([key, value]); 115 }); 116 iterable = iterablePairs; 117 } 118 if (iterable != null) { 119 for (var i = 0; i < iterable.length; i++) { 120 this.set(iterable[i][0], iterable[i][1]); 121 } 122 } 123 } 124 _createClass(EquivalentKeyMap4, [{ 125 key: "set", 126 /** 127 * Add or update an element with a specified key and value. 128 * 129 * @param {*} key The key of the element to add. 130 * @param {*} value The value of the element to add. 131 * 132 * @return {EquivalentKeyMap} Map instance. 133 */ 134 value: function set(key, value) { 135 if (key === null || _typeof(key) !== "object") { 136 this._map.set(key, value); 137 return this; 138 } 139 var properties = Object.keys(key).sort(); 140 var valuePair = [key, value]; 141 var map = Array.isArray(key) ? this._arrayTreeMap : this._objectTreeMap; 142 for (var i = 0; i < properties.length; i++) { 143 var property = properties[i]; 144 if (!map.has(property)) { 145 map.set(property, new EquivalentKeyMap4()); 146 } 147 map = map.get(property); 148 var propertyValue = key[property]; 149 if (!map.has(propertyValue)) { 150 map.set(propertyValue, new EquivalentKeyMap4()); 151 } 152 map = map.get(propertyValue); 153 } 154 var previousValuePair = map.get("_ekm_value"); 155 if (previousValuePair) { 156 this._map.delete(previousValuePair[0]); 157 } 158 map.set("_ekm_value", valuePair); 159 this._map.set(key, valuePair); 160 return this; 161 } 162 /** 163 * Returns a specified element. 164 * 165 * @param {*} key The key of the element to return. 166 * 167 * @return {?*} The element associated with the specified key or undefined 168 * if the key can't be found. 169 */ 170 }, { 171 key: "get", 172 value: function get(key) { 173 if (key === null || _typeof(key) !== "object") { 174 return this._map.get(key); 175 } 176 var valuePair = getValuePair(this, key); 177 if (valuePair) { 178 return valuePair[1]; 179 } 180 } 181 /** 182 * Returns a boolean indicating whether an element with the specified key 183 * exists or not. 184 * 185 * @param {*} key The key of the element to test for presence. 186 * 187 * @return {boolean} Whether an element with the specified key exists. 188 */ 189 }, { 190 key: "has", 191 value: function has(key) { 192 if (key === null || _typeof(key) !== "object") { 193 return this._map.has(key); 194 } 195 return getValuePair(this, key) !== void 0; 196 } 197 /** 198 * Removes the specified element. 199 * 200 * @param {*} key The key of the element to remove. 201 * 202 * @return {boolean} Returns true if an element existed and has been 203 * removed, or false if the element does not exist. 204 */ 205 }, { 206 key: "delete", 207 value: function _delete(key) { 208 if (!this.has(key)) { 209 return false; 210 } 211 this.set(key, void 0); 212 return true; 213 } 214 /** 215 * Executes a provided function once per each key/value pair, in insertion 216 * order. 217 * 218 * @param {Function} callback Function to execute for each element. 219 * @param {*} thisArg Value to use as `this` when executing 220 * `callback`. 221 */ 222 }, { 223 key: "forEach", 224 value: function forEach(callback) { 225 var _this = this; 226 var thisArg = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this; 227 this._map.forEach(function(value, key) { 228 if (key !== null && _typeof(key) === "object") { 229 value = value[1]; 230 } 231 callback.call(thisArg, value, key, _this); 232 }); 233 } 234 /** 235 * Removes all elements. 236 */ 237 }, { 238 key: "clear", 239 value: function clear() { 240 this._map = /* @__PURE__ */ new Map(); 241 this._arrayTreeMap = /* @__PURE__ */ new Map(); 242 this._objectTreeMap = /* @__PURE__ */ new Map(); 243 } 244 }, { 245 key: "size", 246 get: function get() { 247 return this._map.size; 248 } 249 }]); 250 return EquivalentKeyMap4; 251 })(); 252 module.exports = EquivalentKeyMap3; 253 } 254 }); 255 256 // package-external:@wordpress/redux-routine 257 var require_redux_routine = __commonJS({ 258 "package-external:@wordpress/redux-routine"(exports, module) { 259 module.exports = window.wp.reduxRoutine; 260 } 261 }); 262 263 // package-external:@wordpress/compose 264 var require_compose = __commonJS({ 265 "package-external:@wordpress/compose"(exports, module) { 266 module.exports = window.wp.compose; 267 } 268 }); 269 270 // package-external:@wordpress/private-apis 271 var require_private_apis = __commonJS({ 272 "package-external:@wordpress/private-apis"(exports, module) { 273 module.exports = window.wp.privateApis; 274 } 275 }); 276 277
vendor: 5,170 bytes, lines 277-408
277// node_modules/deepmerge/dist/cjs.js 278 var require_cjs = __commonJS({ 279 "node_modules/deepmerge/dist/cjs.js"(exports, module) { 280 "use strict"; 281 var isMergeableObject = function isMergeableObject2(value) { 282 return isNonNullObject(value) && !isSpecial(value); 283 }; 284 function isNonNullObject(value) { 285 return !!value && typeof value === "object"; 286 } 287 function isSpecial(value) { 288 var stringValue = Object.prototype.toString.call(value); 289 return stringValue === "[object RegExp]" || stringValue === "[object Date]" || isReactElement(value); 290 } 291 var canUseSymbol = typeof Symbol === "function" && Symbol.for; 292 var REACT_ELEMENT_TYPE = canUseSymbol ? /* @__PURE__ */ Symbol.for("react.element") : 60103; 293 function isReactElement(value) { 294 return value.$$typeof === REACT_ELEMENT_TYPE; 295 } 296 function emptyTarget(val) { 297 return Array.isArray(val) ? [] : {}; 298 } 299 function cloneUnlessOtherwiseSpecified(value, options) { 300 return options.clone !== false && options.isMergeableObject(value) ? deepmerge2(emptyTarget(value), value, options) : value; 301 } 302 function defaultArrayMerge(target, source, options) { 303 return target.concat(source).map(function(element) { 304 return cloneUnlessOtherwiseSpecified(element, options); 305 }); 306 } 307 function getMergeFunction(key, options) { 308 if (!options.customMerge) { 309 return deepmerge2; 310 } 311 var customMerge = options.customMerge(key); 312 return typeof customMerge === "function" ? customMerge : deepmerge2; 313 } 314 function getEnumerableOwnPropertySymbols(target) { 315 return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol) { 316 return Object.propertyIsEnumerable.call(target, symbol); 317 }) : []; 318 } 319 function getKeys(target) { 320 return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target)); 321 } 322 function propertyIsOnObject(object, property) { 323 try { 324 return property in object; 325 } catch (_) { 326 return false; 327 } 328 } 329 function propertyIsUnsafe(target, key) { 330 return propertyIsOnObject(target, key) && !(Object.hasOwnProperty.call(target, key) && Object.propertyIsEnumerable.call(target, key)); 331 } 332 function mergeObject(target, source, options) { 333 var destination = {}; 334 if (options.isMergeableObject(target)) { 335 getKeys(target).forEach(function(key) { 336 destination[key] = cloneUnlessOtherwiseSpecified(target[key], options); 337 }); 338 } 339 getKeys(source).forEach(function(key) { 340 if (propertyIsUnsafe(target, key)) { 341 return; 342 } 343 if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) { 344 destination[key] = getMergeFunction(key, options)(target[key], source[key], options); 345 } else { 346 destination[key] = cloneUnlessOtherwiseSpecified(source[key], options); 347 } 348 }); 349 return destination; 350 } 351 function deepmerge2(target, source, options) { 352 options = options || {}; 353 options.arrayMerge = options.arrayMerge || defaultArrayMerge; 354 options.isMergeableObject = options.isMergeableObject || isMergeableObject; 355 options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified; 356 var sourceIsArray = Array.isArray(source); 357 var targetIsArray = Array.isArray(target); 358 var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray; 359 if (!sourceAndTargetTypesMatch) { 360 return cloneUnlessOtherwiseSpecified(source, options); 361 } else if (sourceIsArray) { 362 return options.arrayMerge(target, source, options); 363 } else { 364 return mergeObject(target, source, options); 365 } 366 } 367 deepmerge2.all = function deepmergeAll(array, options) { 368 if (!Array.isArray(array)) { 369 throw new Error("first argument should be an array"); 370 } 371 return array.reduce(function(prev, next) { 372 return deepmerge2(prev, next, options); 373 }, {}); 374 }; 375 var deepmerge_1 = deepmerge2; 376 module.exports = deepmerge_1; 377 } 378 }); 379 380 // package-external:@wordpress/element 381 var require_element = __commonJS({ 382 "package-external:@wordpress/element"(exports, module) { 383 module.exports = window.wp.element; 384 } 385 }); 386 387 // package-external:@wordpress/priority-queue 388 var require_priority_queue = __commonJS({ 389 "package-external:@wordpress/priority-queue"(exports, module) { 390 module.exports = window.wp.priorityQueue; 391 } 392 }); 393 394 // package-external:@wordpress/is-shallow-equal 395 var require_is_shallow_equal = __commonJS({ 396 "package-external:@wordpress/is-shallow-equal"(exports, module) { 397 module.exports = window.wp.isShallowEqual; 398 } 399 }); 400 401 // vendor-external:react/jsx-runtime 402 var require_jsx_runtime = __commonJS({ 403 "vendor-external:react/jsx-runtime"(exports, module) { 404 module.exports = window.ReactJSXRuntime; 405 } 406 }); 407 408
408// packages/data/build-module/index.mjs 409 var index_exports = {}; 410 __export(index_exports, { 411 AsyncModeProvider: () => context_default2, 412 RegistryConsumer: () => RegistryConsumer, 413 RegistryProvider: () => context_default, 414 combineReducers: () => combineReducers2, 415 controls: () => controls, 416 createReduxStore: () => createReduxStore, 417 createRegistry: () => createRegistry, 418 createRegistryControl: () => createRegistryControl, 419 createRegistrySelector: () => createRegistrySelector, 420 createSelector: () => createSelector, 421 dispatch: () => dispatch2, 422 keyedReducer: () => keyedReducer, 423 plugins: () => plugins_exports, 424 register: () => register, 425 registerGenericStore: () => registerGenericStore, 426 registerStore: () => registerStore, 427 resolveSelect: () => resolveSelect2, 428 select: () => select2, 429 subscribe: () => subscribe, 430 suspendSelect: () => suspendSelect, 431 use: () => use, 432 useDispatch: () => use_dispatch_default, 433 useRegistry: () => useRegistry, 434 useSelect: () => useSelect, 435 useSuspenseSelect: () => useSuspenseSelect, 436 withDispatch: () => with_dispatch_default, 437 withRegistry: () => with_registry_default, 438 withSelect: () => with_select_default 439 }); 440 441
441// packages/data/build-module/registry.mjs 442 var import_deprecated2 = __toESM(require_deprecated(), 1); 443 444
vendor: 9,901 bytes, lines 444-681
444// node_modules/redux/dist/redux.mjs 445 var $$observable = /* @__PURE__ */ (() => typeof Symbol === "function" && Symbol.observable || "@@observable")(); 446 var symbol_observable_default = $$observable; 447 var randomString = () => Math.random().toString(36).substring(7).split("").join("."); 448 var ActionTypes = { 449 INIT: `@@redux/INIT${/* @__PURE__ */ randomString()}`, 450 REPLACE: `@@redux/REPLACE${/* @__PURE__ */ randomString()}`, 451 PROBE_UNKNOWN_ACTION: () => `@@redux/PROBE_UNKNOWN_ACTION${randomString()}` 452 }; 453 var actionTypes_default = ActionTypes; 454 function isPlainObject(obj) { 455 if (typeof obj !== "object" || obj === null) 456 return false; 457 let proto = obj; 458 while (Object.getPrototypeOf(proto) !== null) { 459 proto = Object.getPrototypeOf(proto); 460 } 461 return Object.getPrototypeOf(obj) === proto || Object.getPrototypeOf(obj) === null; 462 } 463 function miniKindOf(val) { 464 if (val === void 0) 465 return "undefined"; 466 if (val === null) 467 return "null"; 468 const type = typeof val; 469 switch (type) { 470 case "boolean": 471 case "string": 472 case "number": 473 case "symbol": 474 case "function": { 475 return type; 476 } 477 } 478 if (Array.isArray(val)) 479 return "array"; 480 if (isDate(val)) 481 return "date"; 482 if (isError(val)) 483 return "error"; 484 const constructorName = ctorName(val); 485 switch (constructorName) { 486 case "Symbol": 487 case "Promise": 488 case "WeakMap": 489 case "WeakSet": 490 case "Map": 491 case "Set": 492 return constructorName; 493 } 494 return Object.prototype.toString.call(val).slice(8, -1).toLowerCase().replace(/\s/g, ""); 495 } 496 function ctorName(val) { 497 return typeof val.constructor === "function" ? val.constructor.name : null; 498 } 499 function isError(val) { 500 return val instanceof Error || typeof val.message === "string" && val.constructor && typeof val.constructor.stackTraceLimit === "number"; 501 } 502 function isDate(val) { 503 if (val instanceof Date) 504 return true; 505 return typeof val.toDateString === "function" && typeof val.getDate === "function" && typeof val.setDate === "function"; 506 } 507 function kindOf(val) { 508 let typeOfVal = typeof val; 509 if (true) { 510 typeOfVal = miniKindOf(val); 511 } 512 return typeOfVal; 513 } 514 function createStore(reducer, preloadedState, enhancer) { 515 if (typeof reducer !== "function") { 516 throw new Error(false ? formatProdErrorMessage(2) : `Expected the root reducer to be a function. Instead, received: '${kindOf(reducer)}'`); 517 } 518 if (typeof preloadedState === "function" && typeof enhancer === "function" || typeof enhancer === "function" && typeof arguments[3] === "function") { 519 throw new Error(false ? formatProdErrorMessage(0) : "It looks like you are passing several store enhancers to createStore(). This is not supported. Instead, compose them together to a single function. See https://redux.js.org/tutorials/fundamentals/part-4-store#creating-a-store-with-enhancers for an example."); 520 } 521 if (typeof preloadedState === "function" && typeof enhancer === "undefined") { 522 enhancer = preloadedState; 523 preloadedState = void 0; 524 } 525 if (typeof enhancer !== "undefined") { 526 if (typeof enhancer !== "function") { 527 throw new Error(false ? formatProdErrorMessage(1) : `Expected the enhancer to be a function. Instead, received: '${kindOf(enhancer)}'`); 528 } 529 return enhancer(createStore)(reducer, preloadedState); 530 } 531 let currentReducer = reducer; 532 let currentState = preloadedState; 533 let currentListeners = /* @__PURE__ */ new Map(); 534 let nextListeners = currentListeners; 535 let listenerIdCounter = 0; 536 let isDispatching = false; 537 function ensureCanMutateNextListeners() { 538 if (nextListeners === currentListeners) { 539 nextListeners = /* @__PURE__ */ new Map(); 540 currentListeners.forEach((listener, key) => { 541 nextListeners.set(key, listener); 542 }); 543 } 544 } 545 function getState() { 546 if (isDispatching) { 547 throw new Error(false ? formatProdErrorMessage(3) : "You may not call store.getState() while the reducer is executing. The reducer has already received the state as an argument. Pass it down from the top reducer instead of reading it from the store."); 548 } 549 return currentState; 550 } 551 function subscribe2(listener) { 552 if (typeof listener !== "function") { 553 throw new Error(false ? formatProdErrorMessage(4) : `Expected the listener to be a function. Instead, received: '${kindOf(listener)}'`); 554 } 555 if (isDispatching) { 556 throw new Error(false ? formatProdErrorMessage(5) : "You may not call store.subscribe() while the reducer is executing. If you would like to be notified after the store has been updated, subscribe from a component and invoke store.getState() in the callback to access the latest state. See https://redux.js.org/api/store#subscribelistener for more details."); 557 } 558 let isSubscribed = true; 559 ensureCanMutateNextListeners(); 560 const listenerId = listenerIdCounter++; 561 nextListeners.set(listenerId, listener); 562 return function unsubscribe() { 563 if (!isSubscribed) { 564 return; 565 } 566 if (isDispatching) { 567 throw new Error(false ? formatProdErrorMessage(6) : "You may not unsubscribe from a store listener while the reducer is executing. See https://redux.js.org/api/store#subscribelistener for more details."); 568 } 569 isSubscribed = false; 570 ensureCanMutateNextListeners(); 571 nextListeners.delete(listenerId); 572 currentListeners = null; 573 }; 574 } 575 function dispatch3(action) { 576 if (!isPlainObject(action)) { 577 throw new Error(false ? formatProdErrorMessage(7) : `Actions must be plain objects. Instead, the actual type was: '${kindOf(action)}'. You may need to add middleware to your store setup to handle dispatching other values, such as 'redux-thunk' to handle dispatching functions. See https://redux.js.org/tutorials/fundamentals/part-4-store#middleware and https://redux.js.org/tutorials/fundamentals/part-6-async-logic#using-the-redux-thunk-middleware for examples.`); 578 } 579 if (typeof action.type === "undefined") { 580 throw new Error(false ? formatProdErrorMessage(8) : 'Actions may not have an undefined "type" property. You may have misspelled an action type string constant.'); 581 } 582 if (typeof action.type !== "string") { 583 throw new Error(false ? formatProdErrorMessage(17) : `Action "type" property must be a string. Instead, the actual type was: '${kindOf(action.type)}'. Value was: '${action.type}' (stringified)`); 584 } 585 if (isDispatching) { 586 throw new Error(false ? formatProdErrorMessage(9) : "Reducers may not dispatch actions."); 587 } 588 try { 589 isDispatching = true; 590 currentState = currentReducer(currentState, action); 591 } finally { 592 isDispatching = false; 593 } 594 const listeners = currentListeners = nextListeners; 595 listeners.forEach((listener) => { 596 listener(); 597 }); 598 return action; 599 } 600 function replaceReducer(nextReducer) { 601 if (typeof nextReducer !== "function") { 602 throw new Error(false ? formatProdErrorMessage(10) : `Expected the nextReducer to be a function. Instead, received: '${kindOf(nextReducer)}`); 603 } 604 currentReducer = nextReducer; 605 dispatch3({ 606 type: actionTypes_default.REPLACE 607 }); 608 } 609 function observable() { 610 const outerSubscribe = subscribe2; 611 return { 612 /** 613 * The minimal observable subscription method. 614 * @param observer Any object that can be used as an observer. 615 * The observer object should have a `next` method. 616 * @returns An object with an `unsubscribe` method that can 617 * be used to unsubscribe the observable from the store, and prevent further 618 * emission of values from the observable. 619 */ 620 subscribe(observer) { 621 if (typeof observer !== "object" || observer === null) { 622 throw new Error(false ? formatProdErrorMessage(11) : `Expected the observer to be an object. Instead, received: '${kindOf(observer)}'`); 623 } 624 function observeState() { 625 const observerAsObserver = observer; 626 if (observerAsObserver.next) { 627 observerAsObserver.next(getState()); 628 } 629 } 630 observeState(); 631 const unsubscribe = outerSubscribe(observeState); 632 return { 633 unsubscribe 634 }; 635 }, 636 [symbol_observable_default]() { 637 return this; 638 } 639 }; 640 } 641 dispatch3({ 642 type: actionTypes_default.INIT 643 }); 644 const store = { 645 dispatch: dispatch3, 646 subscribe: subscribe2, 647 getState, 648 replaceReducer, 649 [symbol_observable_default]: observable 650 }; 651 return store; 652 } 653 function compose(...funcs) { 654 if (funcs.length === 0) { 655 return (arg) => arg; 656 } 657 if (funcs.length === 1) { 658 return funcs[0]; 659 } 660 return funcs.reduce((a, b) => (...args) => a(b(...args))); 661 } 662 function applyMiddleware(...middlewares) { 663 return (createStore2) => (reducer, preloadedState) => { 664 const store = createStore2(reducer, preloadedState); 665 let dispatch3 = () => { 666 throw new Error(false ? formatProdErrorMessage(15) : "Dispatching while constructing your middleware is not allowed. Other middleware would not be applied to this dispatch."); 667 }; 668 const middlewareAPI = { 669 getState: store.getState, 670 dispatch: (action, ...args) => dispatch3(action, ...args) 671 }; 672 const chain = middlewares.map((middleware) => middleware(middlewareAPI)); 673 dispatch3 = compose(...chain)(store.dispatch); 674 return { 675 ...store, 676 dispatch: dispatch3 677 }; 678 }; 679 } 680 681
681// packages/data/build-module/redux-store/index.mjs 682 var import_equivalent_key_map2 = __toESM(require_equivalent_key_map(), 1); 683 var import_redux_routine = __toESM(require_redux_routine(), 1); 684 var import_compose = __toESM(require_compose(), 1); 685 686
686// packages/data/build-module/redux-store/combine-reducers.mjs 687 function combineReducers(reducers) { 688 const keys = Object.keys(reducers); 689 return function combinedReducer(state = {}, action) { 690 const nextState = {}; 691 let hasChanged = false; 692 for (const key of keys) { 693 const reducer = reducers[key]; 694 const prevStateForKey = state[key]; 695 const nextStateForKey = reducer(prevStateForKey, action); 696 nextState[key] = nextStateForKey; 697 hasChanged = hasChanged || nextStateForKey !== prevStateForKey; 698 } 699 return hasChanged ? nextState : state; 700 }; 701 } 702 703
703// packages/data/build-module/factory.mjs 704 function createRegistrySelector(registrySelector) { 705 const selectorsByRegistry = /* @__PURE__ */ new WeakMap(); 706 const wrappedSelector = (...args) => { 707 let selector = selectorsByRegistry.get(wrappedSelector.registry); 708 if (!selector) { 709 selector = registrySelector(wrappedSelector.registry.select); 710 selectorsByRegistry.set(wrappedSelector.registry, selector); 711 } 712 return selector(...args); 713 }; 714 wrappedSelector.isRegistrySelector = true; 715 return wrappedSelector; 716 } 717 function createRegistryControl(registryControl) { 718 registryControl.isRegistryControl = true; 719 return registryControl; 720 } 721 722
722// packages/data/build-module/controls.mjs 723 var SELECT = "@@data/SELECT"; 724 var RESOLVE_SELECT = "@@data/RESOLVE_SELECT"; 725 var DISPATCH = "@@data/DISPATCH"; 726 function isStoreDescriptor(object) { 727 return object !== null && typeof object === "object"; 728 } 729 function select(storeNameOrDescriptor, selectorName, ...args) { 730 return { 731 type: SELECT, 732 storeKey: isStoreDescriptor(storeNameOrDescriptor) ? storeNameOrDescriptor.name : storeNameOrDescriptor, 733 selectorName, 734 args 735 }; 736 } 737 function resolveSelect(storeNameOrDescriptor, selectorName, ...args) { 738 return { 739 type: RESOLVE_SELECT, 740 storeKey: isStoreDescriptor(storeNameOrDescriptor) ? storeNameOrDescriptor.name : storeNameOrDescriptor, 741 selectorName, 742 args 743 }; 744 } 745 function dispatch(storeNameOrDescriptor, actionName, ...args) { 746 return { 747 type: DISPATCH, 748 storeKey: isStoreDescriptor(storeNameOrDescriptor) ? storeNameOrDescriptor.name : storeNameOrDescriptor, 749 actionName, 750 args 751 }; 752 } 753 var controls = { select, resolveSelect, dispatch }; 754 var builtinControls = { 755 [SELECT]: createRegistryControl( 756 (registry) => ({ storeKey, selectorName, args }) => registry.select(storeKey)[selectorName](...args) 757 ), 758 [RESOLVE_SELECT]: createRegistryControl( 759 (registry) => ({ storeKey, selectorName, args }) => { 760 const selector = registry.select(storeKey)[selectorName]; 761 const method = selector.hasResolver ? "resolveSelect" : "select"; 762 return registry[method](storeKey)[selectorName]( 763 ...args 764 ); 765 } 766 ), 767 [DISPATCH]: createRegistryControl( 768 (registry) => ({ storeKey, actionName, args }) => registry.dispatch(storeKey)[actionName](...args) 769 ) 770 }; 771 772
772// packages/data/build-module/lock-unlock.mjs 773 var import_private_apis = __toESM(require_private_apis(), 1); 774 var { lock, unlock } = (0, import_private_apis.__dangerousOptInToUnstableAPIsOnlyForCoreModules)( 775 "I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.", 776 "@wordpress/data" 777 ); 778 779
vendor: 182 bytes, lines 779-784
779// node_modules/is-promise/index.mjs 780 function isPromise(obj) { 781 return !!obj && (typeof obj === "object" || typeof obj === "function") && typeof obj.then === "function"; 782 } 783 784
784// packages/data/build-module/promise-middleware.mjs 785 var promiseMiddleware = () => (next) => (action) => { 786 if (isPromise(action)) { 787 return action.then((resolvedAction) => { 788 if (resolvedAction) { 789 return next(resolvedAction); 790 } 791 return void 0; 792 }); 793 } 794 return next(action); 795 }; 796 var promise_middleware_default = promiseMiddleware; 797 798
798// packages/data/build-module/resolvers-cache-middleware.mjs 799 var createResolversCacheMiddleware = (registry, storeName) => () => (next) => (action) => { 800 const resolvers = registry.select(storeName).getCachedResolvers(); 801 const resolverEntries = Object.entries( 802 resolvers 803 ); 804 resolverEntries.forEach(([selectorName, resolversByArgs]) => { 805 const resolver = registry.stores[storeName]?.resolvers?.[selectorName]; 806 if (!resolver || !resolver.shouldInvalidate) { 807 return; 808 } 809 const { shouldInvalidate } = resolver; 810 resolversByArgs.forEach((value, args) => { 811 if (value === void 0) { 812 return; 813 } 814 if (value.status !== "finished" && value.status !== "error") { 815 return; 816 } 817 if (!shouldInvalidate(action, ...args)) { 818 return; 819 } 820 registry.dispatch(storeName).invalidateResolution(selectorName, args); 821 }); 822 }); 823 return next(action); 824 }; 825 var resolvers_cache_middleware_default = createResolversCacheMiddleware; 826 827
827// packages/data/build-module/redux-store/thunk-middleware.mjs 828 function createThunkMiddleware(args) { 829 return () => (next) => (action) => { 830 if (typeof action === "function") { 831 return action(args); 832 } 833 return next(action); 834 }; 835 } 836 837
837// packages/data/build-module/redux-store/metadata/reducer.mjs 838 var import_equivalent_key_map = __toESM(require_equivalent_key_map(), 1); 839 840
840// packages/data/build-module/redux-store/keyed-reducer.mjs 841 var keyedReducer = (actionProperty) => (reducer) => (state = {}, action) => { 842 const key = action[actionProperty]; 843 if (key === void 0) { 844 return state; 845 } 846 const nextKeyState = reducer(state[key], action); 847 if (nextKeyState === state[key]) { 848 return state; 849 } 850 return { 851 ...state, 852 [key]: nextKeyState 853 }; 854 }; 855 856
856// packages/data/build-module/redux-store/metadata/utils.mjs 857 function selectorArgsToStateKey(args) { 858 if (args === void 0 || args === null) { 859 return []; 860 } 861 const len = args.length; 862 let idx = len; 863 while (idx > 0 && args[idx - 1] === void 0) { 864 idx--; 865 } 866 return idx === len ? args : args.slice(0, idx); 867 } 868 869
869// packages/data/build-module/redux-store/metadata/reducer.mjs 870 var subKeysIsResolved = keyedReducer("selectorName")((state = new import_equivalent_key_map.default(), action) => { 871 switch (action.type) { 872 case "START_RESOLUTION": { 873 const nextState = new import_equivalent_key_map.default(state); 874 nextState.set(selectorArgsToStateKey(action.args), { 875 status: "resolving" 876 }); 877 return nextState; 878 } 879 case "FINISH_RESOLUTION": { 880 const nextState = new import_equivalent_key_map.default(state); 881 nextState.set(selectorArgsToStateKey(action.args), { 882 status: "finished" 883 }); 884 return nextState; 885 } 886 case "FAIL_RESOLUTION": { 887 const nextState = new import_equivalent_key_map.default(state); 888 nextState.set(selectorArgsToStateKey(action.args), { 889 status: "error", 890 error: action.error 891 }); 892 return nextState; 893 } 894 case "START_RESOLUTIONS": { 895 const nextState = new import_equivalent_key_map.default(state);
896 for (const resolutionArgs of action.args) { 897 nextState.set(selectorArgsToStateKey(resolutionArgs), { 898 status: "resolving" 899 }); 900 } 901 return nextState; 902 } 903 case "FINISH_RESOLUTIONS": { 904 const nextState = new import_equivalent_key_map.default(state); 905 for (const resolutionArgs of action.args) { 906 nextState.set(selectorArgsToStateKey(resolutionArgs), { 907 status: "finished" 908 }); 909 } 910 return nextState; 911 } 912 case "FAIL_RESOLUTIONS": { 913 const nextState = new import_equivalent_key_map.default(state); 914 action.args.forEach((resolutionArgs, idx) => { 915 const resolutionState = { 916 status: "error", 917 error: void 0 918 }; 919 const error = action.errors[idx]; 920 if (error) { 921 resolutionState.error = error; 922 } 923 nextState.set( 924 selectorArgsToStateKey(resolutionArgs), 925 resolutionState 926 ); 927 }); 928 return nextState; 929 } 930 case "INVALIDATE_RESOLUTION": { 931 const nextState = new import_equivalent_key_map.default(state); 932 nextState.delete(selectorArgsToStateKey(action.args)); 933 return nextState; 934 } 935 } 936 return state; 937 }); 938 var isResolved = (state = {}, action) => { 939 switch (action.type) { 940 case "INVALIDATE_RESOLUTION_FOR_STORE": 941 return {}; 942 case "INVALIDATE_RESOLUTION_FOR_STORE_SELECTOR": { 943 if (action.selectorName in state) { 944 const { 945 [action.selectorName]: removedSelector, 946 ...restState 947 } = state; 948 return restState; 949 } 950 return state; 951 } 952 case "START_RESOLUTION": 953 case "FINISH_RESOLUTION": 954 case "FAIL_RESOLUTION": 955 case "START_RESOLUTIONS": 956 case "FINISH_RESOLUTIONS": 957 case "FAIL_RESOLUTIONS": 958 case "INVALIDATE_RESOLUTION": 959 return subKeysIsResolved(state, action); 960 default: 961 return state; 962 } 963 }; 964 var reducer_default = isResolved; 965 966
966// packages/data/build-module/redux-store/metadata/selectors.mjs 967 var selectors_exports = {}; 968 __export(selectors_exports, { 969 countSelectorsByStatus: () => countSelectorsByStatus, 970 getCachedResolvers: () => getCachedResolvers, 971 getIsResolving: () => getIsResolving, 972 getResolutionError: () => getResolutionError, 973 getResolutionState: () => getResolutionState, 974 hasFinishedResolution: () => hasFinishedResolution, 975 hasResolutionFailed: () => hasResolutionFailed, 976 hasResolvingSelectors: () => hasResolvingSelectors, 977 hasStartedResolution: () => hasStartedResolution, 978 isResolving: () => isResolving 979 }); 980 var import_deprecated = __toESM(require_deprecated(), 1); 981 982
vendor: 3,070 bytes, lines 982-1094
982// node_modules/rememo/rememo.js 983 var LEAF_KEY = {}; 984 function arrayOf(value) { 985 return [value]; 986 } 987 function isObjectLike(value) { 988 return !!value && "object" === typeof value; 989 } 990 function createCache() { 991 var cache = { 992 clear: function() { 993 cache.head = null; 994 } 995 }; 996 return cache; 997 } 998 function isShallowEqual(a, b, fromIndex) { 999 var i; 1000 if (a.length !== b.length) { 1001 return false; 1002 } 1003 for (i = fromIndex; i < a.length; i++) { 1004 if (a[i] !== b[i]) { 1005 return false; 1006 } 1007 } 1008 return true; 1009 } 1010 function rememo_default(selector, getDependants) { 1011 var rootCache; 1012 var normalizedGetDependants = getDependants ? getDependants : arrayOf; 1013 function getCache(dependants) { 1014 var caches = rootCache, isUniqueByDependants = true, i, dependant, map, cache; 1015 for (i = 0; i < dependants.length; i++) { 1016 dependant = dependants[i]; 1017 if (!isObjectLike(dependant)) { 1018 isUniqueByDependants = false; 1019 break; 1020 } 1021 if (caches.has(dependant)) { 1022 caches = caches.get(dependant); 1023 } else { 1024 map = /* @__PURE__ */ new WeakMap(); 1025 caches.set(dependant, map); 1026 caches = map; 1027 } 1028 } 1029 if (!caches.has(LEAF_KEY)) { 1030 cache = createCache(); 1031 cache.isUniqueByDependants = isUniqueByDependants; 1032 caches.set(LEAF_KEY, cache); 1033 } 1034 return caches.get(LEAF_KEY); 1035 } 1036 function clear() { 1037 rootCache = /* @__PURE__ */ new WeakMap(); 1038 } 1039 function callSelector() { 1040 var len = arguments.length, cache, node, i, args, dependants; 1041 args = new Array(len); 1042 for (i = 0; i < len; i++) { 1043 args[i] = arguments[i]; 1044 } 1045 dependants = normalizedGetDependants.apply(null, args); 1046 cache = getCache(dependants); 1047 if (!cache.isUniqueByDependants) { 1048 if (cache.lastDependants && !isShallowEqual(dependants, cache.lastDependants, 0)) { 1049 cache.clear(); 1050 } 1051 cache.lastDependants = dependants; 1052 } 1053 node = cache.head; 1054 while (node) { 1055 if (!isShallowEqual(node.args, args, 1)) { 1056 node = node.next; 1057 continue; 1058 } 1059 if (node !== cache.head) { 1060 node.prev.next = node.next; 1061 if (node.next) { 1062 node.next.prev = node.prev; 1063 } 1064 node.next = cache.head; 1065 node.prev = null; 1066 cache.head.prev = node; 1067 cache.head = node; 1068 } 1069 return node.val; 1070 } 1071 node = /** @type {CacheNode} */ 1072 { 1073 // Generate the result from original function 1074 val: selector.apply(null, args) 1075 }; 1076 args[0] = null; 1077 node.args = args; 1078 if (cache.head) { 1079 cache.head.prev = node; 1080 node.next = cache.head; 1081 } 1082 cache.head = node; 1083 return node.val; 1084 } 1085 callSelector.getDependants = normalizedGetDependants; 1086 callSelector.clear = clear; 1087 clear(); 1088 return ( 1089 /** @type {S & EnhancedSelector} */ 1090 callSelector 1091 ); 1092 } 1093 1094
1094// packages/data/build-module/create-selector.mjs 1095 var createSelector = rememo_default; 1096 1097
1097// packages/data/build-module/redux-store/metadata/selectors.mjs 1098 function getResolutionState(state, selectorName, args) { 1099 const map = state[selectorName]; 1100 if (!map) { 1101 return; 1102 } 1103 return map.get(selectorArgsToStateKey(args)); 1104 } 1105 function getIsResolving(state, selectorName, args) { 1106 (0, import_deprecated.default)("wp.data.select( store ).getIsResolving", { 1107 since: "6.6", 1108 version: "6.8", 1109 alternative: "wp.data.select( store ).getResolutionState" 1110 }); 1111 const resolutionState = getResolutionState(state, selectorName, args); 1112 return resolutionState && resolutionState.status === "resolving"; 1113 } 1114 function hasStartedResolution(state, selectorName, args) { 1115 return getResolutionState(state, selectorName, args) !== void 0; 1116 } 1117 function hasFinishedResolution(state, selectorName, args) { 1118 const status = getResolutionState(state, selectorName, args)?.status; 1119 return status === "finished" || status === "error"; 1120 } 1121 function hasResolutionFailed(state, selectorName, args) { 1122 return getResolutionState(state, selectorName, args)?.status === "error"; 1123 } 1124 function getResolutionError(state, selectorName, args) { 1125 const resolutionState = getResolutionState(state, selectorName, args); 1126 return resolutionState?.status === "error" ? resolutionState.error : null; 1127 } 1128 function isResolving(state, selectorName, args) { 1129 return getResolutionState(state, selectorName, args)?.status === "resolving"; 1130 } 1131 function getCachedResolvers(state) { 1132 return state; 1133 } 1134 function hasResolvingSelectors(state) { 1135 return Object.values(state).some( 1136 (selectorState) => ( 1137 /** 1138 * This uses the internal `_map` property of `EquivalentKeyMap` for 1139 * optimization purposes, since the `EquivalentKeyMap` implementation 1140 * does not support a `.values()` implementation. 1141 * 1142 * @see https://github.com/aduth/equivalent-key-map 1143 */ 1144 Array.from(selectorState._map.values()).some( 1145 (resolution) => resolution[1]?.status === "resolving" 1146 ) 1147 ) 1148 ); 1149 } 1150 var countSelectorsByStatus = createSelector( 1151 (state) => { 1152 const selectorsByStatus = {}; 1153 Object.values(state).forEach( 1154 (selectorState) => ( 1155 /** 1156 * This uses the internal `_map` property of `EquivalentKeyMap` for 1157 * optimization purposes, since the `EquivalentKeyMap` implementation 1158 * does not support a `.values()` implementation. 1159 * 1160 * @see https://github.com/aduth/equivalent-key-map 1161 */ 1162 Array.from(selectorState._map.values()).forEach( 1163 (resolution) => { 1164 const currentStatus = resolution[1]?.status ?? "error"; 1165 if (!selectorsByStatus[currentStatus]) { 1166 selectorsByStatus[currentStatus] = 0; 1167 } 1168 selectorsByStatus[currentStatus]++; 1169 } 1170 ) 1171 ) 1172 ); 1173 return selectorsByStatus; 1174 }, 1175 (state) => [state] 1176 ); 1177 1178
1178// packages/data/build-module/redux-store/metadata/actions.mjs 1179 var actions_exports = {}; 1180 __export(actions_exports, { 1181 failResolution: () => failResolution, 1182 failResolutions: () => failResolutions, 1183 finishResolution: () => finishResolution, 1184 finishResolutions: () => finishResolutions, 1185 invalidateResolution: () => invalidateResolution, 1186 invalidateResolutionForStore: () => invalidateResolutionForStore, 1187 invalidateResolutionForStoreSelector: () => invalidateResolutionForStoreSelector, 1188 startResolution: () => startResolution, 1189 startResolutions: () => startResolutions 1190 }); 1191 function startResolution(selectorName, args) { 1192 return { 1193 type: "START_RESOLUTION", 1194 selectorName, 1195 args 1196 }; 1197 } 1198 function finishResolution(selectorName, args) { 1199 return { 1200 type: "FINISH_RESOLUTION", 1201 selectorName, 1202 args 1203 }; 1204 } 1205 function failResolution(selectorName, args, error) { 1206 return { 1207 type: "FAIL_RESOLUTION", 1208 selectorName, 1209 args, 1210 error 1211 }; 1212 } 1213 function startResolutions(selectorName, args) { 1214 return { 1215 type: "START_RESOLUTIONS", 1216 selectorName, 1217 args 1218 }; 1219 } 1220 function finishResolutions(selectorName, args) { 1221 return { 1222 type: "FINISH_RESOLUTIONS", 1223 selectorName, 1224 args 1225 }; 1226 } 1227 function failResolutions(selectorName, args, errors) { 1228 return { 1229 type: "FAIL_RESOLUTIONS", 1230 selectorName, 1231 args, 1232 errors 1233 }; 1234 }
1235 function invalidateResolution(selectorName, args) { 1236 return { 1237 type: "INVALIDATE_RESOLUTION", 1238 selectorName, 1239 args 1240 }; 1241 } 1242 function invalidateResolutionForStore() { 1243 return { 1244 type: "INVALIDATE_RESOLUTION_FOR_STORE" 1245 }; 1246 } 1247 function invalidateResolutionForStoreSelector(selectorName) { 1248 return { 1249 type: "INVALIDATE_RESOLUTION_FOR_STORE_SELECTOR", 1250 selectorName 1251 }; 1252 } 1253 1254
1254// packages/data/build-module/redux-store/index.mjs 1255 var trimUndefinedValues = (array) => { 1256 const result = [...array]; 1257 for (let i = result.length - 1; i >= 0; i--) { 1258 if (result[i] === void 0) { 1259 result.splice(i, 1); 1260 } 1261 } 1262 return result; 1263 }; 1264 var mapValues = (obj, callback) => Object.fromEntries( 1265 Object.entries(obj ?? {}).map(([key, value]) => [ 1266 key, 1267 callback(value, key) 1268 ]) 1269 ); 1270 var devToolsReplacer = (_key, state) => { 1271 if (state instanceof Map) { 1272 return Object.fromEntries(state); 1273 } 1274 if (typeof window !== "undefined" && state instanceof window.HTMLElement) { 1275 return null; 1276 } 1277 return state; 1278 }; 1279 function createResolversCache() { 1280 const cache = {}; 1281 return { 1282 isRunning(selectorName, args) { 1283 return !!(cache[selectorName] && cache[selectorName].get(trimUndefinedValues(args))); 1284 }, 1285 clear(selectorName, args) { 1286 if (cache[selectorName]) { 1287 cache[selectorName].delete(trimUndefinedValues(args)); 1288 } 1289 }, 1290 markAsRunning(selectorName, args) { 1291 if (!cache[selectorName]) { 1292 cache[selectorName] = new import_equivalent_key_map2.default(); 1293 } 1294 cache[selectorName].set(trimUndefinedValues(args), true); 1295 } 1296 }; 1297 } 1298 function createBindingCache(getItem, bindItem) { 1299 const cache = /* @__PURE__ */ new WeakMap(); 1300 return { 1301 get(itemName) { 1302 const item = getItem(itemName); 1303 if (!item) { 1304 return null; 1305 } 1306 let boundItem = cache.get(item); 1307 if (!boundItem) { 1308 boundItem = bindItem(item, itemName); 1309 cache.set(item, boundItem); 1310 } 1311 return boundItem; 1312 } 1313 }; 1314 } 1315 function createPrivateProxy(publicItems, privateItems) { 1316 return new Proxy(publicItems, { 1317 get: (target, itemName) => privateItems.get(itemName) || Reflect.get(target, itemName) 1318 }); 1319 } 1320 function createReduxStore(key, options) { 1321 const privateActions = {}; 1322 const privateSelectors = {}; 1323 const privateRegistrationFunctions = { 1324 privateActions, 1325 registerPrivateActions: (actions) => { 1326 Object.assign(privateActions, actions); 1327 }, 1328 privateSelectors, 1329 registerPrivateSelectors: (selectors) => { 1330 Object.assign(privateSelectors, selectors); 1331 } 1332 }; 1333 const storeDescriptor = { 1334 name: key, 1335 instantiate: (registry) => { 1336 const listeners = /* @__PURE__ */ new Set(); 1337 const reducer = options.reducer; 1338 const thunkArgs = { 1339 registry, 1340 get dispatch() { 1341 return thunkDispatch; 1342 }, 1343 get select() { 1344 return thunkSelect; 1345 }, 1346 get resolveSelect() { 1347 return resolveSelectors; 1348 } 1349 }; 1350 const store = instantiateReduxStore( 1351 key, 1352 options, 1353 registry, 1354 thunkArgs 1355 ); 1356 lock(store, privateRegistrationFunctions); 1357 const resolversCache = createResolversCache(); 1358 function bindAction(action) { 1359 return (...args) => Promise.resolve(store.dispatch(action(...args))); 1360 } 1361 const actions = { 1362 ...mapValues( 1363 actions_exports, 1364 bindAction 1365 ), 1366 ...mapValues( 1367 options.actions, 1368 bindAction 1369 ) 1370 }; 1371 const allActions = createPrivateProxy( 1372 actions, 1373 createBindingCache( 1374 (name) => privateActions[name], 1375 bindAction 1376 ) 1377 ); 1378 const thunkDispatch = new Proxy( 1379 (action) => store.dispatch(action), 1380 { 1381 get: (_target, name) => allActions[name] 1382 } 1383 ); 1384 lock(actions, allActions); 1385 const resolvers = options.resolvers ? mapValues( 1386 options.resolvers, 1387 mapResolver 1388 ) : {}; 1389 function bindSelector(selector, selectorName) { 1390 if (selector.isRegistrySelector) { 1391 selector.registry = registry; 1392 } 1393 const boundSelector = (...args) => { 1394 args = normalize(selector, args); 1395 const state = store.__unstableOriginalGetState(); 1396 if (selector.isRegistrySelector) { 1397 selector.registry = registry; 1398 } 1399 return selector(state.root, ...args); 1400 }; 1401 boundSelector.__unstableNormalizeArgs = selector.__unstableNormalizeArgs; 1402 const resolver = resolvers[selectorName]; 1403 if (!resolver) { 1404 boundSelector.hasResolver = false;
1405 return boundSelector; 1406 } 1407 return mapSelectorWithResolver( 1408 boundSelector, 1409 selectorName, 1410 resolver, 1411 store, 1412 resolversCache, 1413 boundMetadataSelectors 1414 ); 1415 } 1416 function bindMetadataSelector(metaDataSelector) { 1417 const boundSelector = (selectorName, selectorArgs, ...args) => { 1418 if (selectorName) { 1419 const targetSelector = options.selectors?.[selectorName]; 1420 if (targetSelector) { 1421 selectorArgs = normalize( 1422 targetSelector, 1423 selectorArgs 1424 ); 1425 } 1426 } 1427 const state = store.__unstableOriginalGetState(); 1428 return metaDataSelector( 1429 state.metadata, 1430 selectorName, 1431 selectorArgs, 1432 ...args 1433 ); 1434 }; 1435 boundSelector.hasResolver = false; 1436 return boundSelector; 1437 } 1438 const boundMetadataSelectors = mapValues( 1439 selectors_exports, 1440 bindMetadataSelector 1441 ); 1442 const boundSelectors = mapValues( 1443 options.selectors, 1444 bindSelector 1445 ); 1446 const selectors = { 1447 ...boundMetadataSelectors, 1448 ...boundSelectors 1449 }; 1450 const boundPrivateSelectors = createBindingCache( 1451 (name) => privateSelectors[name], 1452 bindSelector 1453 ); 1454 const allSelectors = createPrivateProxy( 1455 selectors, 1456 boundPrivateSelectors 1457 ); 1458 for (const selectorName of Object.keys(privateSelectors)) { 1459 boundPrivateSelectors.get(selectorName); 1460 } 1461 const thunkSelect = new Proxy( 1462 (selector) => selector(store.__unstableOriginalGetState()), 1463 { 1464 get: (_target, name) => allSelectors[name] 1465 } 1466 ); 1467 lock(selectors, allSelectors); 1468 const bindResolveSelector = mapResolveSelector( 1469 store, 1470 resolvers, 1471 boundMetadataSelectors 1472 ); 1473 const resolveSelectors = mapValues( 1474 boundSelectors, 1475 bindResolveSelector 1476 ); 1477 const allResolveSelectors = createPrivateProxy( 1478 resolveSelectors, 1479 createBindingCache( 1480 (name) => boundPrivateSelectors.get(name), 1481 bindResolveSelector 1482 ) 1483 ); 1484 lock(resolveSelectors, allResolveSelectors); 1485 const bindSuspendSelector = mapSuspendSelector( 1486 store, 1487 boundMetadataSelectors 1488 ); 1489 const suspendSelectors = { 1490 ...boundMetadataSelectors, 1491 // no special suspense behavior 1492 ...mapValues(boundSelectors, bindSuspendSelector) 1493 }; 1494 const allSuspendSelectors = createPrivateProxy( 1495 suspendSelectors, 1496 createBindingCache( 1497 (name) => boundPrivateSelectors.get(name), 1498 bindSuspendSelector 1499 ) 1500 ); 1501 lock(suspendSelectors, allSuspendSelectors); 1502 const getSelectors = () => selectors; 1503 const getActions = () => actions; 1504 const getResolveSelectors = () => resolveSelectors; 1505 const getSuspendSelectors = () => suspendSelectors; 1506 store.__unstableOriginalGetState = store.getState; 1507 store.getState = () => store.__unstableOriginalGetState().root; 1508 const subscribe2 = (listener) => { 1509 listeners.add(listener); 1510 return () => listeners.delete(listener); 1511 }; 1512 let lastState = store.__unstableOriginalGetState(); 1513 store.subscribe(() => { 1514 const state = store.__unstableOriginalGetState(); 1515 const hasChanged = state !== lastState; 1516 lastState = state; 1517 if (hasChanged) { 1518 for (const listener of listeners) { 1519 listener(); 1520 } 1521 } 1522 }); 1523 return { 1524 reducer, 1525 store, 1526 actions, 1527 selectors, 1528 resolvers, 1529 getSelectors, 1530 getResolveSelectors, 1531 getSuspendSelectors, 1532 getActions, 1533 subscribe: subscribe2 1534 }; 1535 } 1536 }; 1537 lock(storeDescriptor, privateRegistrationFunctions); 1538 return storeDescriptor; 1539 } 1540 function instantiateReduxStore(key, options, registry, thunkArgs) { 1541 const controls2 = { 1542 ...options.controls, 1543 ...builtinControls 1544 }; 1545 const normalizedControls = mapValues( 1546 controls2,
1547 (control) => control.isRegistryControl ? control(registry) : control 1548 ); 1549 const middlewares = [ 1550 resolvers_cache_middleware_default(registry, key), 1551 promise_middleware_default, 1552 (0, import_redux_routine.default)(normalizedControls), 1553 createThunkMiddleware(thunkArgs) 1554 ]; 1555 const enhancers = [applyMiddleware(...middlewares)]; 1556 if (typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION__) { 1557 enhancers.push( 1558 window.__REDUX_DEVTOOLS_EXTENSION__({ 1559 name: key, 1560 instanceId: key, 1561 serialize: { 1562 replacer: devToolsReplacer 1563 } 1564 }) 1565 ); 1566 } 1567 const { reducer, initialState } = options; 1568 const enhancedReducer = combineReducers({ 1569 metadata: reducer_default, 1570 root: reducer 1571 }); 1572 return createStore( 1573 enhancedReducer, 1574 { root: initialState }, 1575 (0, import_compose.compose)(...enhancers) 1576 ); 1577 } 1578 function mapResolveSelector(store, resolvers, boundMetadataSelectors) { 1579 return (selector, selectorName) => { 1580 if (!selector.hasResolver) { 1581 return async (...args) => selector(...args); 1582 } 1583 return (...args) => new Promise((resolve, reject) => { 1584 const resolver = resolvers[selectorName]; 1585 const hasFinished = () => { 1586 return boundMetadataSelectors.hasFinishedResolution( 1587 selectorName, 1588 args 1589 ) || typeof resolver.isFulfilled === "function" && resolver.isFulfilled(store.getState(), ...args); 1590 }; 1591 const finalize = (result2) => { 1592 const hasFailed = boundMetadataSelectors.hasResolutionFailed( 1593 selectorName, 1594 args 1595 ); 1596 if (hasFailed) { 1597 const error = boundMetadataSelectors.getResolutionError( 1598 selectorName, 1599 args 1600 ); 1601 reject(error); 1602 } else { 1603 resolve(result2); 1604 } 1605 }; 1606 const getResult = () => selector(...args); 1607 const result = getResult(); 1608 if (hasFinished()) { 1609 return finalize(result); 1610 } 1611 const unsubscribe = store.subscribe(() => { 1612 if (hasFinished()) { 1613 unsubscribe(); 1614 finalize(getResult()); 1615 } 1616 }); 1617 }); 1618 }; 1619 } 1620 function mapSuspendSelector(store, boundMetadataSelectors) { 1621 return (selector, selectorName) => { 1622 if (!selector.hasResolver) { 1623 return selector; 1624 } 1625 return (...args) => { 1626 const result = selector(...args); 1627 if (boundMetadataSelectors.hasFinishedResolution( 1628 selectorName, 1629 args 1630 )) { 1631 if (boundMetadataSelectors.hasResolutionFailed( 1632 selectorName, 1633 args 1634 )) { 1635 throw boundMetadataSelectors.getResolutionError( 1636 selectorName, 1637 args 1638 ); 1639 } 1640 return result; 1641 } 1642 throw new Promise((resolve) => { 1643 const unsubscribe = store.subscribe(() => { 1644 if (boundMetadataSelectors.hasFinishedResolution( 1645 selectorName, 1646 args 1647 )) { 1648 resolve(); 1649 unsubscribe(); 1650 } 1651 }); 1652 }); 1653 }; 1654 }; 1655 } 1656 function mapResolver(resolver) { 1657 if (resolver.fulfill) { 1658 return resolver; 1659 } 1660 return { 1661 ...resolver, 1662 // Copy the enumerable properties of the resolver function. 1663 fulfill: resolver 1664 // Add the fulfill method. 1665 }; 1666 } 1667 function mapSelectorWithResolver(selector, selectorName, resolver, store, resolversCache, boundMetadataSelectors) { 1668 function fulfillSelector(args) { 1669 if (resolversCache.isRunning(selectorName, args) || boundMetadataSelectors.hasStartedResolution(selectorName, args) || typeof resolver.isFulfilled === "function" && resolver.isFulfilled(store.getState(), ...args)) { 1670 return; 1671 } 1672 resolversCache.markAsRunning(selectorName, args); 1673 setTimeout(async () => { 1674 resolversCache.clear(selectorName, args); 1675 store.dispatch( 1676 startResolution(selectorName, args) 1677 ); 1678 try { 1679 const action = resolver.fulfill(...args); 1680 if (action) { 1681 await store.dispatch(action); 1682 } 1683 store.dispatch( 1684 finishResolution(selectorName, args) 1685 ); 1686 } catch (error) { 1687 store.dispatch( 1688 failResolution(selectorName, args, error) 1689 ); 1690 } 1691 }, 0); 1692 } 1693 const selectorResolver = (...args) => { 1694 args = normalize(selector, args); 1695 fulfillSelector(args); 1696 return selector(...args); 1697 }; 1698 selectorResolver.hasResolver = true; 1699 return selectorResolver; 1700 } 1701 function normalize(selector, args) { 1702 if (selector.__unstableNormalizeArgs && typeof selector.__unstableNormalizeArgs === "function" && args?.length) { 1703 return selector.__unstableNormalizeArgs(args); 1704 } 1705 return args; 1706 } 1707 1708
1708// packages/data/build-module/store/index.mjs 1709 var coreDataStore = { 1710 name: "core/data", 1711 instantiate(registry) { 1712 const getCoreDataSelector = (selectorName) => (key, ...args) => { 1713 return registry.select(key)[selectorName](...args); 1714 }; 1715 const getCoreDataAction = (actionName) => (key, ...args) => { 1716 return registry.dispatch(key)[actionName](...args); 1717 }; 1718 return { 1719 getSelectors() { 1720 return Object.fromEntries( 1721 [ 1722 "getIsResolving", 1723 "hasStartedResolution", 1724 "hasFinishedResolution", 1725 "isResolving", 1726 "getCachedResolvers" 1727 ].map((selectorName) => [ 1728 selectorName, 1729 getCoreDataSelector(selectorName) 1730 ]) 1731 ); 1732 }, 1733 getActions() { 1734 return Object.fromEntries( 1735 [ 1736 "startResolution", 1737 "finishResolution", 1738 "invalidateResolution", 1739 "invalidateResolutionForStore", 1740 "invalidateResolutionForStoreSelector" 1741 ].map((actionName) => [ 1742 actionName, 1743 getCoreDataAction(actionName) 1744 ]) 1745 ); 1746 }, 1747 subscribe() { 1748 return () => () => { 1749 }; 1750 } 1751 }; 1752 } 1753 }; 1754 var store_default = coreDataStore; 1755 1756
1756// packages/data/build-module/utils/emitter.mjs 1757 function createEmitter() { 1758 let isPaused = false; 1759 let isPending = false; 1760 const listeners = /* @__PURE__ */ new Set(); 1761 const notifyListeners = () => ( 1762 // We use Array.from to clone the listeners Set 1763 // This ensures that we don't run a listener 1764 // that was added as a response to another listener. 1765 Array.from(listeners).forEach((listener) => listener()) 1766 ); 1767 return { 1768 get isPaused() { 1769 return isPaused; 1770 }, 1771 subscribe(listener) { 1772 listeners.add(listener); 1773 return () => listeners.delete(listener); 1774 }, 1775 pause() { 1776 isPaused = true; 1777 }, 1778 resume() { 1779 isPaused = false; 1780 if (isPending) { 1781 isPending = false; 1782 notifyListeners(); 1783 } 1784 }, 1785 emit() { 1786 if (isPaused) { 1787 isPending = true; 1788 return; 1789 } 1790 notifyListeners(); 1791 } 1792 }; 1793 } 1794 1795
1795// packages/data/build-module/registry.mjs 1796 function getStoreName(storeNameOrDescriptor) { 1797 return typeof storeNameOrDescriptor === "string" ? storeNameOrDescriptor : storeNameOrDescriptor.name; 1798 } 1799 function createRegistry(storeConfigs = {}, parent = null) { 1800 const stores = {}; 1801 const emitter = createEmitter(); 1802 let listeningStores = null; 1803 function globalListener() { 1804 emitter.emit(); 1805 } 1806 const subscribe2 = (listener, storeNameOrDescriptor) => { 1807 if (!storeNameOrDescriptor) { 1808 return emitter.subscribe(listener); 1809 } 1810 const storeName = getStoreName(storeNameOrDescriptor); 1811 const store = stores[storeName]; 1812 if (store) { 1813 return store.subscribe(listener); 1814 } 1815 if (!parent) { 1816 return emitter.subscribe(listener); 1817 } 1818 return parent.subscribe(listener, storeNameOrDescriptor); 1819 }; 1820 function select3(storeNameOrDescriptor) { 1821 const storeName = getStoreName(storeNameOrDescriptor); 1822 listeningStores?.add(storeName); 1823 const store = stores[storeName]; 1824 if (store) { 1825 return store.getSelectors(); 1826 } 1827 return parent?.select(storeName); 1828 } 1829 function __unstableMarkListeningStores(callback, ref) { 1830 listeningStores = /* @__PURE__ */ new Set(); 1831 try { 1832 return callback.call(this); 1833 } finally { 1834 ref.current = Array.from(listeningStores); 1835 listeningStores = null; 1836 } 1837 } 1838 function resolveSelect3(storeNameOrDescriptor) { 1839 const storeName = getStoreName(storeNameOrDescriptor); 1840 listeningStores?.add(storeName); 1841 const store = stores[storeName]; 1842 if (store) { 1843 return store.getResolveSelectors(); 1844 } 1845 return parent && parent.resolveSelect(storeName); 1846 } 1847 function suspendSelect2(storeNameOrDescriptor) { 1848 const storeName = getStoreName(storeNameOrDescriptor); 1849 listeningStores?.add(storeName); 1850 const store = stores[storeName]; 1851 if (store) { 1852 return store.getSuspendSelectors(); 1853 } 1854 return parent && parent.suspendSelect(storeName); 1855 } 1856 function dispatch3(storeNameOrDescriptor) { 1857 const storeName = getStoreName(storeNameOrDescriptor); 1858 const store = stores[storeName]; 1859 if (store) { 1860 return store.getActions(); 1861 } 1862 return parent && parent.dispatch(storeName); 1863 } 1864 function withPlugins(attributes) { 1865 return Object.fromEntries( 1866 Object.entries(attributes).map(([key, attribute]) => { 1867 if (typeof attribute !== "function") { 1868 return [key, attribute]; 1869 } 1870 return [ 1871 key, 1872 (...args) => { 1873 return registry[key](...args); 1874 } 1875 ]; 1876 }) 1877 ); 1878 } 1879 function registerStoreInstance(name, createStoreFunc) { 1880 if (stores[name]) { 1881 console.error('Store "' + name + '" is already registered.'); 1882 return stores[name]; 1883 } 1884 const store = createStoreFunc(); 1885 if (typeof store.getSelectors !== "function") { 1886 throw new TypeError("store.getSelectors must be a function"); 1887 } 1888 if (typeof store.getActions !== "function") { 1889 throw new TypeError("store.getActions must be a function"); 1890 } 1891 if (typeof store.subscribe !== "function") { 1892 throw new TypeError("store.subscribe must be a function"); 1893 } 1894 store.emitter = createEmitter(); 1895 const currentSubscribe = store.subscribe; 1896 store.subscribe = (listener) => { 1897 const unsubscribeFromEmitter = store.emitter.subscribe(listener); 1898 const unsubscribeFromStore = currentSubscribe(() => { 1899 if (store.emitter.isPaused) { 1900 store.emitter.emit(); 1901 return; 1902 } 1903 listener(); 1904 }); 1905 return () => { 1906 unsubscribeFromStore?.(); 1907 unsubscribeFromEmitter?.(); 1908 }; 1909 }; 1910 stores[name] = store; 1911 store.subscribe(globalListener); 1912 if (parent) { 1913 try { 1914 unlock(store.store).registerPrivateActions( 1915 unlock(parent).privateActionsOf(name) 1916 ); 1917 unlock(store.store).registerPrivateSelectors( 1918 unlock(parent).privateSelectorsOf(name) 1919 ); 1920 } catch { 1921 } 1922 } 1923 return store; 1924 } 1925 function register2(store) { 1926 registerStoreInstance( 1927 store.name, 1928 () => store.instantiate(registry) 1929 ); 1930 } 1931 function registerGenericStore2(name, store) { 1932 (0, import_deprecated2.default)("wp.data.registerGenericStore", { 1933 since: "5.9",
1934 alternative: "wp.data.register( storeDescriptor )" 1935 }); 1936 registerStoreInstance(name, () => store); 1937 } 1938 function registerStore2(storeName, options) { 1939 if (!options.reducer) { 1940 throw new TypeError("Must specify store reducer"); 1941 } 1942 const store = registerStoreInstance( 1943 storeName, 1944 () => createReduxStore(storeName, options).instantiate( 1945 registry 1946 ) 1947 ); 1948 return store.store; 1949 } 1950 function batch(callback) { 1951 if (emitter.isPaused) { 1952 callback(); 1953 return; 1954 } 1955 emitter.pause(); 1956 Object.values(stores).forEach((store) => store.emitter.pause()); 1957 try { 1958 callback(); 1959 } finally { 1960 emitter.resume(); 1961 Object.values(stores).forEach( 1962 (store) => store.emitter.resume() 1963 ); 1964 } 1965 } 1966 let registry = { 1967 batch, 1968 stores, 1969 namespaces: stores, 1970 // TODO: Deprecate/remove this. 1971 subscribe: subscribe2, 1972 select: select3, 1973 resolveSelect: resolveSelect3, 1974 suspendSelect: suspendSelect2, 1975 dispatch: dispatch3, 1976 use: use2, 1977 register: register2, 1978 registerGenericStore: registerGenericStore2, 1979 registerStore: registerStore2, 1980 __unstableMarkListeningStores 1981 }; 1982 function use2(plugin, options) { 1983 if (!plugin) { 1984 return; 1985 } 1986 registry = { 1987 ...registry, 1988 ...plugin(registry, options) 1989 }; 1990 return registry; 1991 } 1992 registry.register(store_default); 1993 for (const [name, config] of Object.entries(storeConfigs)) { 1994 registry.register(createReduxStore(name, config)); 1995 } 1996 if (parent) { 1997 parent.subscribe(globalListener); 1998 } 1999 const registryWithPlugins = withPlugins( 2000 registry 2001 ); 2002 lock(registryWithPlugins, { 2003 privateActionsOf: (name) => { 2004 try { 2005 return unlock(stores[name].store).privateActions; 2006 } catch { 2007 return {}; 2008 } 2009 }, 2010 privateSelectorsOf: (name) => { 2011 try { 2012 return unlock(stores[name].store).privateSelectors; 2013 } catch { 2014 return {}; 2015 } 2016 } 2017 }); 2018 return registryWithPlugins; 2019 } 2020 2021
2021// packages/data/build-module/default-registry.mjs 2022 var defaultRegistry = createRegistry(); 2023 var default_registry_default = defaultRegistry; 2024 2025
2025// packages/data/build-module/plugins/index.mjs 2026 var plugins_exports = {}; 2027 __export(plugins_exports, { 2028 persistence: () => persistence_default 2029 }); 2030 2031
vendor: 497 bytes, lines 2031-2048
2031// node_modules/is-plain-object/dist/is-plain-object.mjs 2032 function isObject(o) { 2033 return Object.prototype.toString.call(o) === "[object Object]"; 2034 } 2035 function isPlainObject2(o) { 2036 var ctor, prot; 2037 if (isObject(o) === false) return false; 2038 ctor = o.constructor; 2039 if (ctor === void 0) return true; 2040 prot = ctor.prototype; 2041 if (isObject(prot) === false) return false; 2042 if (prot.hasOwnProperty("isPrototypeOf") === false) { 2043 return false; 2044 } 2045 return true; 2046 } 2047 2048
2048// packages/data/build-module/plugins/persistence/index.mjs 2049 var import_deepmerge = __toESM(require_cjs(), 1); 2050 2051
2051// packages/data/build-module/plugins/persistence/storage/object.mjs 2052 var objectStorage; 2053 var storage = { 2054 getItem(key) { 2055 if (!objectStorage || !objectStorage[key]) { 2056 return null; 2057 } 2058 return objectStorage[key]; 2059 }, 2060 setItem(key, value) { 2061 if (!objectStorage) { 2062 storage.clear(); 2063 } 2064 objectStorage[key] = String(value); 2065 }, 2066 clear() { 2067 objectStorage = /* @__PURE__ */ Object.create(null); 2068 } 2069 }; 2070 var object_default = storage; 2071 2072
2072// packages/data/build-module/plugins/persistence/storage/default.mjs 2073 var storage2; 2074 try { 2075 storage2 = window.localStorage; 2076 storage2.setItem("__wpDataTestLocalStorage", ""); 2077 storage2.removeItem("__wpDataTestLocalStorage"); 2078 } catch { 2079 storage2 = object_default; 2080 } 2081 var default_default = storage2; 2082 2083
2083// packages/data/build-module/plugins/persistence/index.mjs 2084 var DEFAULT_STORAGE = default_default; 2085 var DEFAULT_STORAGE_KEY = "WP_DATA"; 2086 var withLazySameState = (reducer) => (state, action) => { 2087 if (action.nextState === state) { 2088 return state; 2089 } 2090 return reducer(state, action); 2091 }; 2092 function createPersistenceInterface(options) { 2093 const { storage: storage3 = DEFAULT_STORAGE, storageKey = DEFAULT_STORAGE_KEY } = options; 2094 let data; 2095 function getData() { 2096 if (data === void 0) { 2097 const persisted = storage3.getItem(storageKey); 2098 if (persisted === null) { 2099 data = {}; 2100 } else { 2101 try { 2102 data = JSON.parse(persisted); 2103 } catch { 2104 data = {}; 2105 } 2106 } 2107 } 2108 return data; 2109 } 2110 function setData(key, value) { 2111 data = { ...data, [key]: value }; 2112 storage3.setItem(storageKey, JSON.stringify(data)); 2113 } 2114 return { 2115 get: getData, 2116 set: setData 2117 }; 2118 } 2119 function persistencePlugin(registry, pluginOptions) { 2120 const persistence = createPersistenceInterface(pluginOptions); 2121 function createPersistOnChange(getState, storeName, keys) { 2122 let getPersistedState; 2123 if (Array.isArray(keys)) { 2124 const reducers = keys.reduce( 2125 (accumulator, key) => Object.assign(accumulator, { 2126 [key]: (state, action) => action.nextState[key] 2127 }), 2128 {} 2129 ); 2130 getPersistedState = withLazySameState( 2131 combineReducers2(reducers) 2132 ); 2133 } else { 2134 getPersistedState = (_state, action) => action.nextState; 2135 } 2136 let lastState = getPersistedState(void 0, { 2137 nextState: getState() 2138 }); 2139 return () => { 2140 const state = getPersistedState(lastState, { 2141 nextState: getState() 2142 }); 2143 if (state !== lastState) { 2144 persistence.set(storeName, state); 2145 lastState = state; 2146 } 2147 }; 2148 } 2149 return { 2150 registerStore(storeName, options) { 2151 if (!options.persist) { 2152 return registry.registerStore(storeName, options); 2153 } 2154 const persistedState = persistence.get()[storeName]; 2155 if (persistedState !== void 0) { 2156 let initialState = options.reducer(options.initialState, { 2157 type: "@@WP/PERSISTENCE_RESTORE" 2158 }); 2159 if (isPlainObject2(initialState) && isPlainObject2(persistedState)) { 2160 initialState = (0, import_deepmerge.default)( 2161 initialState, 2162 persistedState, 2163 { 2164 isMergeableObject: isPlainObject2 2165 } 2166 ); 2167 } else { 2168 initialState = persistedState; 2169 } 2170 options = { 2171 ...options, 2172 initialState 2173 }; 2174 } 2175 const store = registry.registerStore(storeName, options); 2176 store.subscribe( 2177 createPersistOnChange( 2178 store.getState, 2179 storeName, 2180 options.persist 2181 ) 2182 ); 2183 return store; 2184 } 2185 }; 2186 } 2187 var persistence_default = Object.assign(persistencePlugin, { 2188 __unstableMigrate: () => { 2189 } 2190 }); 2191 2192
2192// packages/data/build-module/components/with-select/index.mjs 2193 var import_compose2 = __toESM(require_compose(), 1); 2194 var import_element6 = __toESM(require_element(), 1); 2195 2196
2196// packages/data/build-module/components/use-select/index.mjs 2197 var import_priority_queue = __toESM(require_priority_queue(), 1); 2198 var import_element5 = __toESM(require_element(), 1); 2199 var import_is_shallow_equal = __toESM(require_is_shallow_equal(), 1); 2200 2201
2201// packages/data/build-module/components/registry-provider/use-registry.mjs 2202 var import_element2 = __toESM(require_element(), 1); 2203 2204
2204// packages/data/build-module/components/registry-provider/context.mjs 2205 var import_element = __toESM(require_element(), 1); 2206 var Context = (0, import_element.createContext)(default_registry_default); 2207 Context.displayName = "RegistryProviderContext"; 2208 var { Consumer, Provider } = Context; 2209 var RegistryConsumer = Consumer; 2210 var context_default = Provider; 2211 2212
2212// packages/data/build-module/components/registry-provider/use-registry.mjs 2213 function useRegistry() { 2214 return (0, import_element2.useContext)(Context); 2215 } 2216 2217
2217// packages/data/build-module/components/async-mode-provider/use-async-mode.mjs 2218 var import_element4 = __toESM(require_element(), 1); 2219 2220
2220// packages/data/build-module/components/async-mode-provider/context.mjs 2221 var import_element3 = __toESM(require_element(), 1); 2222 var Context2 = (0, import_element3.createContext)(false); 2223 Context2.displayName = "AsyncModeContext"; 2224 var { Consumer: Consumer2, Provider: Provider2 } = Context2; 2225 var context_default2 = Provider2; 2226 2227
2227// packages/data/build-module/components/async-mode-provider/use-async-mode.mjs 2228 function useAsyncMode() { 2229 return (0, import_element4.useContext)(Context2); 2230 } 2231 2232
2232// packages/data/build-module/components/use-select/index.mjs 2233 var renderQueue = (0, import_priority_queue.createQueue)(); 2234 function warnOnUnstableReference(a, b) { 2235 if (!a || !b) { 2236 return; 2237 } 2238 const keys = typeof a === "object" && typeof b === "object" ? Object.keys(a).filter((k) => a[k] !== b[k]) : []; 2239 console.warn( 2240 "The `useSelect` hook returns different values when called with the same state and parameters.\nThis can lead to unnecessary re-renders and performance issues if not fixed.\n\nNon-equal value keys: %s\n\n", 2241 keys.join(", ") 2242 ); 2243 } 2244 function Store(registry, suspense) { 2245 const select3 = suspense ? registry.suspendSelect : registry.select; 2246 const queueContext = {}; 2247 let lastMapSelect; 2248 let lastMapResult; 2249 let lastMapResultValid = false; 2250 let lastIsAsync; 2251 let subscriber; 2252 let didWarnUnstableReference; 2253 const storeStatesOnMount = /* @__PURE__ */ new Map(); 2254 function getStoreState(name) { 2255 return registry.stores[name]?.store?.getState?.() ?? {}; 2256 } 2257 const createSubscriber = (stores) => { 2258 const activeStores = [...stores]; 2259 const activeSubscriptions = /* @__PURE__ */ new Set(); 2260 function subscribe2(listener) { 2261 if (lastMapResultValid) { 2262 for (const name of activeStores) { 2263 if (storeStatesOnMount.get(name) !== getStoreState(name)) { 2264 lastMapResultValid = false; 2265 } 2266 } 2267 } 2268 storeStatesOnMount.clear(); 2269 const onStoreChange = () => { 2270 lastMapResultValid = false; 2271 listener(); 2272 }; 2273 const onChange = () => { 2274 if (lastIsAsync) { 2275 renderQueue.add(queueContext, onStoreChange); 2276 } else { 2277 onStoreChange(); 2278 } 2279 }; 2280 const unsubs = []; 2281 function subscribeStore(storeName) { 2282 unsubs.push(registry.subscribe(onChange, storeName)); 2283 } 2284 for (const storeName of activeStores) { 2285 subscribeStore(storeName); 2286 } 2287 activeSubscriptions.add(subscribeStore); 2288 return () => { 2289 activeSubscriptions.delete(subscribeStore); 2290 for (const unsub of unsubs.values()) { 2291 unsub?.(); 2292 } 2293 renderQueue.cancel(queueContext); 2294 }; 2295 } 2296 function updateStores(newStores) { 2297 for (const newStore of newStores) { 2298 if (activeStores.includes(newStore)) { 2299 continue; 2300 } 2301 activeStores.push(newStore); 2302 for (const subscription of activeSubscriptions) { 2303 subscription(newStore); 2304 } 2305 } 2306 } 2307 return { subscribe: subscribe2, updateStores }; 2308 }; 2309 return (mapSelect, isAsync) => { 2310 function updateValue() { 2311 if (lastMapResultValid && mapSelect === lastMapSelect) { 2312 return; 2313 } 2314 const listeningStores = { current: null }; 2315 const mapResult = registry.__unstableMarkListeningStores( 2316 () => mapSelect(select3, registry), 2317 listeningStores 2318 ); 2319 if (true) { 2320 if (!didWarnUnstableReference) { 2321 const secondMapResult = mapSelect(select3, registry); 2322 if (!(0, import_is_shallow_equal.isShallowEqual)(mapResult, secondMapResult)) { 2323 warnOnUnstableReference(mapResult, secondMapResult); 2324 didWarnUnstableReference = true; 2325 } 2326 } 2327 } 2328 if (!subscriber) { 2329 for (const name of listeningStores.current) { 2330 storeStatesOnMount.set(name, getStoreState(name)); 2331 } 2332 subscriber = createSubscriber(listeningStores.current); 2333 } else { 2334 subscriber.updateStores(listeningStores.current); 2335 } 2336 if (!(0, import_is_shallow_equal.isShallowEqual)(lastMapResult, mapResult)) { 2337 lastMapResult = mapResult; 2338 } 2339 lastMapSelect = mapSelect; 2340 lastMapResultValid = true; 2341 } 2342 function getValue() { 2343 updateValue(); 2344 return lastMapResult; 2345 } 2346 if (lastIsAsync && !isAsync) { 2347 lastMapResultValid = false;
2348 renderQueue.cancel(queueContext); 2349 } 2350 updateValue(); 2351 lastIsAsync = isAsync; 2352 return { subscribe: subscriber.subscribe, getValue }; 2353 }; 2354 } 2355 function _useStaticSelect(storeName) { 2356 return useRegistry().select(storeName); 2357 } 2358 function _useMappingSelect(suspense, mapSelect, deps) { 2359 const registry = useRegistry(); 2360 const isAsync = useAsyncMode(); 2361 const store = (0, import_element5.useMemo)( 2362 () => Store(registry, suspense), 2363 [registry, suspense] 2364 ); 2365 const selector = (0, import_element5.useCallback)(mapSelect, deps); 2366 const { subscribe: subscribe2, getValue } = store(selector, isAsync); 2367 const result = (0, import_element5.useSyncExternalStore)(subscribe2, getValue, getValue); 2368 (0, import_element5.useDebugValue)(result); 2369 return result; 2370 } 2371 function useSelect(mapSelect, deps) { 2372 const staticSelectMode = typeof mapSelect !== "function"; 2373 const staticSelectModeRef = (0, import_element5.useRef)(staticSelectMode); 2374 if (staticSelectMode !== staticSelectModeRef.current) { 2375 const prevMode = staticSelectModeRef.current ? "static" : "mapping"; 2376 const nextMode = staticSelectMode ? "static" : "mapping"; 2377 throw new Error( 2378 `Switching useSelect from ${prevMode} to ${nextMode} is not allowed` 2379 ); 2380 } 2381 return staticSelectMode ? _useStaticSelect(mapSelect) : _useMappingSelect(false, mapSelect, deps); 2382 } 2383 function useSuspenseSelect(mapSelect, deps) { 2384 return _useMappingSelect(true, mapSelect, deps); 2385 } 2386 2387
2387// packages/data/build-module/components/with-select/index.mjs 2388 var import_jsx_runtime = __toESM(require_jsx_runtime(), 1); 2389 var withSelect = (mapSelectToProps) => (0, import_compose2.createHigherOrderComponent)( 2390 (WrappedComponent) => (0, import_element6.memo)( 2391 (0, import_element6.forwardRef)(function WithSelect(ownProps, ref) { 2392 const mapSelect = (select3, registry) => mapSelectToProps(select3, ownProps, registry); 2393 const mergeProps = useSelect(mapSelect); 2394 return /* @__PURE__ */ (0, import_jsx_runtime.jsx)( 2395 WrappedComponent, 2396 { 2397 ref, 2398 ...ownProps, 2399 ...mergeProps 2400 } 2401 ); 2402 }) 2403 ), 2404 "withSelect" 2405 ); 2406 var with_select_default = withSelect; 2407 2408
2408// packages/data/build-module/components/with-dispatch/index.mjs 2409 var import_compose4 = __toESM(require_compose(), 1); 2410 2411
2411// packages/data/build-module/components/use-dispatch/use-dispatch.mjs 2412 var useDispatch = (storeNameOrDescriptor) => { 2413 const { dispatch: dispatch3 } = useRegistry(); 2414 return storeNameOrDescriptor === void 0 ? dispatch3 : dispatch3(storeNameOrDescriptor); 2415 }; 2416 var use_dispatch_default = useDispatch; 2417 2418
2418// packages/data/build-module/components/use-dispatch/use-dispatch-with-map.mjs 2419 var import_element7 = __toESM(require_element(), 1); 2420 var import_compose3 = __toESM(require_compose(), 1); 2421 var useDispatchWithMap = (dispatchMap, deps) => { 2422 const registry = useRegistry(); 2423 const currentDispatchMapRef = (0, import_element7.useRef)(dispatchMap); 2424 (0, import_compose3.useIsomorphicLayoutEffect)(() => { 2425 currentDispatchMapRef.current = dispatchMap; 2426 }); 2427 return (0, import_element7.useMemo)(() => { 2428 const currentDispatchProps = currentDispatchMapRef.current( 2429 registry.dispatch, 2430 registry 2431 ); 2432 return Object.fromEntries( 2433 Object.entries(currentDispatchProps).map( 2434 ([propName, dispatcher]) => { 2435 if (typeof dispatcher !== "function") { 2436 console.warn( 2437 `Property ${propName} returned from dispatchMap in useDispatchWithMap must be a function.` 2438 ); 2439 } 2440 return [ 2441 propName, 2442 (...args) => currentDispatchMapRef.current(registry.dispatch, registry)[propName](...args) 2443 ]; 2444 } 2445 ) 2446 ); 2447 }, [registry, ...deps]); 2448 }; 2449 var use_dispatch_with_map_default = useDispatchWithMap; 2450 2451
2451// packages/data/build-module/components/with-dispatch/index.mjs 2452 var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1); 2453 var withDispatch = (mapDispatchToProps) => (0, import_compose4.createHigherOrderComponent)( 2454 (WrappedComponent) => (ownProps) => { 2455 const mapDispatch = (dispatch3, registry) => mapDispatchToProps(dispatch3, ownProps, registry); 2456 const dispatchProps = use_dispatch_with_map_default(mapDispatch, []); 2457 return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(WrappedComponent, { ...ownProps, ...dispatchProps }); 2458 }, 2459 "withDispatch" 2460 ); 2461 var with_dispatch_default = withDispatch; 2462 2463
2463// packages/data/build-module/components/with-registry/index.mjs 2464 var import_compose5 = __toESM(require_compose(), 1); 2465 var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1); 2466 var withRegistry = (0, import_compose5.createHigherOrderComponent)( 2467 (OriginalComponent) => (props) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(RegistryConsumer, { children: (registry) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(OriginalComponent, { ...props, registry }) }), 2468 "withRegistry" 2469 ); 2470 var with_registry_default = withRegistry; 2471 2472
2472// packages/data/build-module/dispatch.mjs 2473 function dispatch2(storeNameOrDescriptor) { 2474 return default_registry_default.dispatch( 2475 storeNameOrDescriptor 2476 ); 2477 } 2478 2479
2479// packages/data/build-module/select.mjs 2480 function select2(storeNameOrDescriptor) { 2481 return default_registry_default.select( 2482 storeNameOrDescriptor 2483 ); 2484 } 2485 2486
2486// packages/data/build-module/index.mjs 2487 var combineReducers2 = combineReducers; 2488 function resolveSelect2(storeNameOrDescriptor) { 2489 return default_registry_default.resolveSelect( 2490 storeNameOrDescriptor 2491 ); 2492 } 2493 var suspendSelect = (storeNameOrDescriptor) => default_registry_default.suspendSelect(storeNameOrDescriptor); 2494 var subscribe = (listener, storeNameOrDescriptor) => default_registry_default.subscribe(listener, storeNameOrDescriptor); 2495 var registerGenericStore = default_registry_default.registerGenericStore; 2496 var registerStore = default_registry_default.registerStore; 2497 var use = default_registry_default.use; 2498 var register = (store) => default_registry_default.register(store); 2499 return __toCommonJS(index_exports); 2500})(); 2501/*! Bundled license information: 2502 2503is-plain-object/dist/is-plain-object.mjs: 2504 (*! 2505 * is-plain-object <https://github.com/jonschlinkert/is-plain-object> 2506 * 2507 * Copyright (c) 2014-2017, Jon Schlinkert. 2508 * Released under the MIT License. 2509 *) 2510*/ 2511(window.wp ||= {}).data = wp.data; 2512})();
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.