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