hooks.js (23173B)
1 this["wp"] = this["wp"] || {}; this["wp"]["hooks"] = 2 /******/ (function(modules) { // webpackBootstrap 3 /******/ // The module cache 4 /******/ var installedModules = {}; 5 /******/ 6 /******/ // The require function 7 /******/ function __webpack_require__(moduleId) { 8 /******/ 9 /******/ // Check if module is in cache 10 /******/ if(installedModules[moduleId]) { 11 /******/ return installedModules[moduleId].exports; 12 /******/ } 13 /******/ // Create a new module (and put it into the cache) 14 /******/ var module = installedModules[moduleId] = { 15 /******/ i: moduleId, 16 /******/ l: false, 17 /******/ exports: {} 18 /******/ }; 19 /******/ 20 /******/ // Execute the module function 21 /******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); 22 /******/ 23 /******/ // Flag the module as loaded 24 /******/ module.l = true; 25 /******/ 26 /******/ // Return the exports of the module 27 /******/ return module.exports; 28 /******/ } 29 /******/ 30 /******/ 31 /******/ // expose the modules object (__webpack_modules__) 32 /******/ __webpack_require__.m = modules; 33 /******/ 34 /******/ // expose the module cache 35 /******/ __webpack_require__.c = installedModules; 36 /******/ 37 /******/ // define getter function for harmony exports 38 /******/ __webpack_require__.d = function(exports, name, getter) { 39 /******/ if(!__webpack_require__.o(exports, name)) { 40 /******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); 41 /******/ } 42 /******/ }; 43 /******/ 44 /******/ // define __esModule on exports 45 /******/ __webpack_require__.r = function(exports) { 46 /******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { 47 /******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); 48 /******/ } 49 /******/ Object.defineProperty(exports, '__esModule', { value: true }); 50 /******/ }; 51 /******/ 52 /******/ // create a fake namespace object 53 /******/ // mode & 1: value is a module id, require it 54 /******/ // mode & 2: merge all properties of value into the ns 55 /******/ // mode & 4: return value when already ns object 56 /******/ // mode & 8|1: behave like require 57 /******/ __webpack_require__.t = function(value, mode) { 58 /******/ if(mode & 1) value = __webpack_require__(value); 59 /******/ if(mode & 8) return value; 60 /******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; 61 /******/ var ns = Object.create(null); 62 /******/ __webpack_require__.r(ns); 63 /******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); 64 /******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); 65 /******/ return ns; 66 /******/ }; 67 /******/ 68 /******/ // getDefaultExport function for compatibility with non-harmony modules 69 /******/ __webpack_require__.n = function(module) { 70 /******/ var getter = module && module.__esModule ? 71 /******/ function getDefault() { return module['default']; } : 72 /******/ function getModuleExports() { return module; }; 73 /******/ __webpack_require__.d(getter, 'a', getter); 74 /******/ return getter; 75 /******/ }; 76 /******/ 77 /******/ // Object.prototype.hasOwnProperty.call 78 /******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; 79 /******/ 80 /******/ // __webpack_public_path__ 81 /******/ __webpack_require__.p = ""; 82 /******/ 83 /******/ 84 /******/ // Load entry module and return exports 85 /******/ return __webpack_require__(__webpack_require__.s = "gEOj"); 86 /******/ }) 87 /************************************************************************/ 88 /******/ ({ 89 90 /***/ "gEOj": 91 /***/ (function(module, __webpack_exports__, __webpack_require__) { 92 93 "use strict"; 94 // ESM COMPAT FLAG 95 __webpack_require__.r(__webpack_exports__); 96 97 // EXPORTS 98 __webpack_require__.d(__webpack_exports__, "defaultHooks", function() { return /* binding */ defaultHooks; }); 99 __webpack_require__.d(__webpack_exports__, "createHooks", function() { return /* reexport */ build_module_createHooks; }); 100 __webpack_require__.d(__webpack_exports__, "addAction", function() { return /* binding */ addAction; }); 101 __webpack_require__.d(__webpack_exports__, "addFilter", function() { return /* binding */ addFilter; }); 102 __webpack_require__.d(__webpack_exports__, "removeAction", function() { return /* binding */ removeAction; }); 103 __webpack_require__.d(__webpack_exports__, "removeFilter", function() { return /* binding */ removeFilter; }); 104 __webpack_require__.d(__webpack_exports__, "hasAction", function() { return /* binding */ hasAction; }); 105 __webpack_require__.d(__webpack_exports__, "hasFilter", function() { return /* binding */ hasFilter; }); 106 __webpack_require__.d(__webpack_exports__, "removeAllActions", function() { return /* binding */ removeAllActions; }); 107 __webpack_require__.d(__webpack_exports__, "removeAllFilters", function() { return /* binding */ removeAllFilters; }); 108 __webpack_require__.d(__webpack_exports__, "doAction", function() { return /* binding */ doAction; }); 109 __webpack_require__.d(__webpack_exports__, "applyFilters", function() { return /* binding */ applyFilters; }); 110 __webpack_require__.d(__webpack_exports__, "currentAction", function() { return /* binding */ currentAction; }); 111 __webpack_require__.d(__webpack_exports__, "currentFilter", function() { return /* binding */ currentFilter; }); 112 __webpack_require__.d(__webpack_exports__, "doingAction", function() { return /* binding */ doingAction; }); 113 __webpack_require__.d(__webpack_exports__, "doingFilter", function() { return /* binding */ doingFilter; }); 114 __webpack_require__.d(__webpack_exports__, "didAction", function() { return /* binding */ didAction; }); 115 __webpack_require__.d(__webpack_exports__, "didFilter", function() { return /* binding */ didFilter; }); 116 __webpack_require__.d(__webpack_exports__, "actions", function() { return /* binding */ actions; }); 117 __webpack_require__.d(__webpack_exports__, "filters", function() { return /* binding */ filters; }); 118 119 // CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/validateNamespace.js 120 /** 121 * Validate a namespace string. 122 * 123 * @param {string} namespace The namespace to validate - should take the form 124 * `vendor/plugin/function`. 125 * 126 * @return {boolean} Whether the namespace is valid. 127 */ 128 function validateNamespace(namespace) { 129 if ('string' !== typeof namespace || '' === namespace) { 130 // eslint-disable-next-line no-console 131 console.error('The namespace must be a non-empty string.'); 132 return false; 133 } 134 135 if (!/^[a-zA-Z][a-zA-Z0-9_.\-\/]*$/.test(namespace)) { 136 // eslint-disable-next-line no-console 137 console.error('The namespace can only contain numbers, letters, dashes, periods, underscores and slashes.'); 138 return false; 139 } 140 141 return true; 142 } 143 144 /* harmony default export */ var build_module_validateNamespace = (validateNamespace); 145 146 // CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/validateHookName.js 147 /** 148 * Validate a hookName string. 149 * 150 * @param {string} hookName The hook name to validate. Should be a non empty string containing 151 * only numbers, letters, dashes, periods and underscores. Also, 152 * the hook name cannot begin with `__`. 153 * 154 * @return {boolean} Whether the hook name is valid. 155 */ 156 function validateHookName(hookName) { 157 if ('string' !== typeof hookName || '' === hookName) { 158 // eslint-disable-next-line no-console 159 console.error('The hook name must be a non-empty string.'); 160 return false; 161 } 162 163 if (/^__/.test(hookName)) { 164 // eslint-disable-next-line no-console 165 console.error('The hook name cannot begin with `__`.'); 166 return false; 167 } 168 169 if (!/^[a-zA-Z][a-zA-Z0-9_.-]*$/.test(hookName)) { 170 // eslint-disable-next-line no-console 171 console.error('The hook name can only contain numbers, letters, dashes, periods and underscores.'); 172 return false; 173 } 174 175 return true; 176 } 177 178 /* harmony default export */ var build_module_validateHookName = (validateHookName); 179 180 // CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/createAddHook.js 181 /** 182 * Internal dependencies 183 */ 184 185 186 /** 187 * @callback AddHook 188 * 189 * Adds the hook to the appropriate hooks container. 190 * 191 * @param {string} hookName Name of hook to add 192 * @param {string} namespace The unique namespace identifying the callback in the form `vendor/plugin/function`. 193 * @param {import('.').Callback} callback Function to call when the hook is run 194 * @param {number} [priority=10] Priority of this hook 195 */ 196 197 /** 198 * Returns a function which, when invoked, will add a hook. 199 * 200 * @param {import('.').Hooks} hooks Hooks instance. 201 * @param {import('.').StoreKey} storeKey 202 * 203 * @return {AddHook} Function that adds a new hook. 204 */ 205 206 function createAddHook(hooks, storeKey) { 207 return function addHook(hookName, namespace, callback, priority = 10) { 208 const hooksStore = hooks[storeKey]; 209 210 if (!build_module_validateHookName(hookName)) { 211 return; 212 } 213 214 if (!build_module_validateNamespace(namespace)) { 215 return; 216 } 217 218 if ('function' !== typeof callback) { 219 // eslint-disable-next-line no-console 220 console.error('The hook callback must be a function.'); 221 return; 222 } // Validate numeric priority 223 224 225 if ('number' !== typeof priority) { 226 // eslint-disable-next-line no-console 227 console.error('If specified, the hook priority must be a number.'); 228 return; 229 } 230 231 const handler = { 232 callback, 233 priority, 234 namespace 235 }; 236 237 if (hooksStore[hookName]) { 238 // Find the correct insert index of the new hook. 239 const handlers = hooksStore[hookName].handlers; 240 /** @type {number} */ 241 242 let i; 243 244 for (i = handlers.length; i > 0; i--) { 245 if (priority >= handlers[i - 1].priority) { 246 break; 247 } 248 } 249 250 if (i === handlers.length) { 251 // If append, operate via direct assignment. 252 handlers[i] = handler; 253 } else { 254 // Otherwise, insert before index via splice. 255 handlers.splice(i, 0, handler); 256 } // We may also be currently executing this hook. If the callback 257 // we're adding would come after the current callback, there's no 258 // problem; otherwise we need to increase the execution index of 259 // any other runs by 1 to account for the added element. 260 261 262 hooksStore.__current.forEach(hookInfo => { 263 if (hookInfo.name === hookName && hookInfo.currentIndex >= i) { 264 hookInfo.currentIndex++; 265 } 266 }); 267 } else { 268 // This is the first hook of its type. 269 hooksStore[hookName] = { 270 handlers: [handler], 271 runs: 0 272 }; 273 } 274 275 if (hookName !== 'hookAdded') { 276 hooks.doAction('hookAdded', hookName, namespace, callback, priority); 277 } 278 }; 279 } 280 281 /* harmony default export */ var build_module_createAddHook = (createAddHook); 282 283 // CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/createRemoveHook.js 284 /** 285 * Internal dependencies 286 */ 287 288 289 /** 290 * @callback RemoveHook 291 * Removes the specified callback (or all callbacks) from the hook with a given hookName 292 * and namespace. 293 * 294 * @param {string} hookName The name of the hook to modify. 295 * @param {string} namespace The unique namespace identifying the callback in the 296 * form `vendor/plugin/function`. 297 * 298 * @return {number | undefined} The number of callbacks removed. 299 */ 300 301 /** 302 * Returns a function which, when invoked, will remove a specified hook or all 303 * hooks by the given name. 304 * 305 * @param {import('.').Hooks} hooks Hooks instance. 306 * @param {import('.').StoreKey} storeKey 307 * @param {boolean} [removeAll=false] Whether to remove all callbacks for a hookName, 308 * without regard to namespace. Used to create 309 * `removeAll*` functions. 310 * 311 * @return {RemoveHook} Function that removes hooks. 312 */ 313 314 function createRemoveHook(hooks, storeKey, removeAll = false) { 315 return function removeHook(hookName, namespace) { 316 const hooksStore = hooks[storeKey]; 317 318 if (!build_module_validateHookName(hookName)) { 319 return; 320 } 321 322 if (!removeAll && !build_module_validateNamespace(namespace)) { 323 return; 324 } // Bail if no hooks exist by this name 325 326 327 if (!hooksStore[hookName]) { 328 return 0; 329 } 330 331 let handlersRemoved = 0; 332 333 if (removeAll) { 334 handlersRemoved = hooksStore[hookName].handlers.length; 335 hooksStore[hookName] = { 336 runs: hooksStore[hookName].runs, 337 handlers: [] 338 }; 339 } else { 340 // Try to find the specified callback to remove. 341 const handlers = hooksStore[hookName].handlers; 342 343 for (let i = handlers.length - 1; i >= 0; i--) { 344 if (handlers[i].namespace === namespace) { 345 handlers.splice(i, 1); 346 handlersRemoved++; // This callback may also be part of a hook that is 347 // currently executing. If the callback we're removing 348 // comes after the current callback, there's no problem; 349 // otherwise we need to decrease the execution index of any 350 // other runs by 1 to account for the removed element. 351 352 hooksStore.__current.forEach(hookInfo => { 353 if (hookInfo.name === hookName && hookInfo.currentIndex >= i) { 354 hookInfo.currentIndex--; 355 } 356 }); 357 } 358 } 359 } 360 361 if (hookName !== 'hookRemoved') { 362 hooks.doAction('hookRemoved', hookName, namespace); 363 } 364 365 return handlersRemoved; 366 }; 367 } 368 369 /* harmony default export */ var build_module_createRemoveHook = (createRemoveHook); 370 371 // CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/createHasHook.js 372 /** 373 * @callback HasHook 374 * 375 * Returns whether any handlers are attached for the given hookName and optional namespace. 376 * 377 * @param {string} hookName The name of the hook to check for. 378 * @param {string} [namespace] Optional. The unique namespace identifying the callback 379 * in the form `vendor/plugin/function`. 380 * 381 * @return {boolean} Whether there are handlers that are attached to the given hook. 382 */ 383 384 /** 385 * Returns a function which, when invoked, will return whether any handlers are 386 * attached to a particular hook. 387 * 388 * @param {import('.').Hooks} hooks Hooks instance. 389 * @param {import('.').StoreKey} storeKey 390 * 391 * @return {HasHook} Function that returns whether any handlers are 392 * attached to a particular hook and optional namespace. 393 */ 394 function createHasHook(hooks, storeKey) { 395 return function hasHook(hookName, namespace) { 396 const hooksStore = hooks[storeKey]; // Use the namespace if provided. 397 398 if ('undefined' !== typeof namespace) { 399 return hookName in hooksStore && hooksStore[hookName].handlers.some(hook => hook.namespace === namespace); 400 } 401 402 return hookName in hooksStore; 403 }; 404 } 405 406 /* harmony default export */ var build_module_createHasHook = (createHasHook); 407 408 // CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/createRunHook.js 409 /** 410 * Returns a function which, when invoked, will execute all callbacks 411 * registered to a hook of the specified type, optionally returning the final 412 * value of the call chain. 413 * 414 * @param {import('.').Hooks} hooks Hooks instance. 415 * @param {import('.').StoreKey} storeKey 416 * @param {boolean} [returnFirstArg=false] Whether each hook callback is expected to 417 * return its first argument. 418 * 419 * @return {(hookName:string, ...args: unknown[]) => unknown} Function that runs hook callbacks. 420 */ 421 function createRunHook(hooks, storeKey, returnFirstArg = false) { 422 return function runHooks(hookName, ...args) { 423 const hooksStore = hooks[storeKey]; 424 425 if (!hooksStore[hookName]) { 426 hooksStore[hookName] = { 427 handlers: [], 428 runs: 0 429 }; 430 } 431 432 hooksStore[hookName].runs++; 433 const handlers = hooksStore[hookName].handlers; // The following code is stripped from production builds. 434 435 if (false) {} 436 437 if (!handlers || !handlers.length) { 438 return returnFirstArg ? args[0] : undefined; 439 } 440 441 const hookInfo = { 442 name: hookName, 443 currentIndex: 0 444 }; 445 446 hooksStore.__current.push(hookInfo); 447 448 while (hookInfo.currentIndex < handlers.length) { 449 const handler = handlers[hookInfo.currentIndex]; 450 const result = handler.callback.apply(null, args); 451 452 if (returnFirstArg) { 453 args[0] = result; 454 } 455 456 hookInfo.currentIndex++; 457 } 458 459 hooksStore.__current.pop(); 460 461 if (returnFirstArg) { 462 return args[0]; 463 } 464 }; 465 } 466 467 /* harmony default export */ var build_module_createRunHook = (createRunHook); 468 469 // CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/createCurrentHook.js 470 /** 471 * Returns a function which, when invoked, will return the name of the 472 * currently running hook, or `null` if no hook of the given type is currently 473 * running. 474 * 475 * @param {import('.').Hooks} hooks Hooks instance. 476 * @param {import('.').StoreKey} storeKey 477 * 478 * @return {() => string | null} Function that returns the current hook name or null. 479 */ 480 function createCurrentHook(hooks, storeKey) { 481 return function currentHook() { 482 var _hooksStore$__current, _hooksStore$__current2; 483 484 const hooksStore = hooks[storeKey]; 485 return (_hooksStore$__current = (_hooksStore$__current2 = hooksStore.__current[hooksStore.__current.length - 1]) === null || _hooksStore$__current2 === void 0 ? void 0 : _hooksStore$__current2.name) !== null && _hooksStore$__current !== void 0 ? _hooksStore$__current : null; 486 }; 487 } 488 489 /* harmony default export */ var build_module_createCurrentHook = (createCurrentHook); 490 491 // CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/createDoingHook.js 492 /** 493 * @callback DoingHook 494 * Returns whether a hook is currently being executed. 495 * 496 * @param {string} [hookName] The name of the hook to check for. If 497 * omitted, will check for any hook being executed. 498 * 499 * @return {boolean} Whether the hook is being executed. 500 */ 501 502 /** 503 * Returns a function which, when invoked, will return whether a hook is 504 * currently being executed. 505 * 506 * @param {import('.').Hooks} hooks Hooks instance. 507 * @param {import('.').StoreKey} storeKey 508 * 509 * @return {DoingHook} Function that returns whether a hook is currently 510 * being executed. 511 */ 512 function createDoingHook(hooks, storeKey) { 513 return function doingHook(hookName) { 514 const hooksStore = hooks[storeKey]; // If the hookName was not passed, check for any current hook. 515 516 if ('undefined' === typeof hookName) { 517 return 'undefined' !== typeof hooksStore.__current[0]; 518 } // Return the __current hook. 519 520 521 return hooksStore.__current[0] ? hookName === hooksStore.__current[0].name : false; 522 }; 523 } 524 525 /* harmony default export */ var build_module_createDoingHook = (createDoingHook); 526 527 // CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/createDidHook.js 528 /** 529 * Internal dependencies 530 */ 531 532 /** 533 * @callback DidHook 534 * 535 * Returns the number of times an action has been fired. 536 * 537 * @param {string} hookName The hook name to check. 538 * 539 * @return {number | undefined} The number of times the hook has run. 540 */ 541 542 /** 543 * Returns a function which, when invoked, will return the number of times a 544 * hook has been called. 545 * 546 * @param {import('.').Hooks} hooks Hooks instance. 547 * @param {import('.').StoreKey} storeKey 548 * 549 * @return {DidHook} Function that returns a hook's call count. 550 */ 551 552 function createDidHook(hooks, storeKey) { 553 return function didHook(hookName) { 554 const hooksStore = hooks[storeKey]; 555 556 if (!build_module_validateHookName(hookName)) { 557 return; 558 } 559 560 return hooksStore[hookName] && hooksStore[hookName].runs ? hooksStore[hookName].runs : 0; 561 }; 562 } 563 564 /* harmony default export */ var build_module_createDidHook = (createDidHook); 565 566 // CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/createHooks.js 567 /** 568 * Internal dependencies 569 */ 570 571 572 573 574 575 576 577 /** 578 * Internal class for constructing hooks. Use `createHooks()` function 579 * 580 * Note, it is necessary to expose this class to make its type public. 581 * 582 * @private 583 */ 584 585 class createHooks_Hooks { 586 constructor() { 587 /** @type {import('.').Store} actions */ 588 this.actions = Object.create(null); 589 this.actions.__current = []; 590 /** @type {import('.').Store} filters */ 591 592 this.filters = Object.create(null); 593 this.filters.__current = []; 594 this.addAction = build_module_createAddHook(this, 'actions'); 595 this.addFilter = build_module_createAddHook(this, 'filters'); 596 this.removeAction = build_module_createRemoveHook(this, 'actions'); 597 this.removeFilter = build_module_createRemoveHook(this, 'filters'); 598 this.hasAction = build_module_createHasHook(this, 'actions'); 599 this.hasFilter = build_module_createHasHook(this, 'filters'); 600 this.removeAllActions = build_module_createRemoveHook(this, 'actions', true); 601 this.removeAllFilters = build_module_createRemoveHook(this, 'filters', true); 602 this.doAction = build_module_createRunHook(this, 'actions'); 603 this.applyFilters = build_module_createRunHook(this, 'filters', true); 604 this.currentAction = build_module_createCurrentHook(this, 'actions'); 605 this.currentFilter = build_module_createCurrentHook(this, 'filters'); 606 this.doingAction = build_module_createDoingHook(this, 'actions'); 607 this.doingFilter = build_module_createDoingHook(this, 'filters'); 608 this.didAction = build_module_createDidHook(this, 'actions'); 609 this.didFilter = build_module_createDidHook(this, 'filters'); 610 } 611 612 } 613 /** @typedef {_Hooks} Hooks */ 614 615 /** 616 * Returns an instance of the hooks object. 617 * 618 * @return {Hooks} A Hooks instance. 619 */ 620 621 function createHooks() { 622 return new createHooks_Hooks(); 623 } 624 625 /* harmony default export */ var build_module_createHooks = (createHooks); 626 627 // CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/index.js 628 /** 629 * Internal dependencies 630 */ 631 632 /** @typedef {(...args: any[])=>any} Callback */ 633 634 /** 635 * @typedef Handler 636 * @property {Callback} callback The callback 637 * @property {string} namespace The namespace 638 * @property {number} priority The namespace 639 */ 640 641 /** 642 * @typedef Hook 643 * @property {Handler[]} handlers Array of handlers 644 * @property {number} runs Run counter 645 */ 646 647 /** 648 * @typedef Current 649 * @property {string} name Hook name 650 * @property {number} currentIndex The index 651 */ 652 653 /** 654 * @typedef {Record<string, Hook> & {__current: Current[]}} Store 655 */ 656 657 /** 658 * @typedef {'actions' | 'filters'} StoreKey 659 */ 660 661 /** 662 * @typedef {import('./createHooks').Hooks} Hooks 663 */ 664 665 const defaultHooks = build_module_createHooks(); 666 const { 667 addAction, 668 addFilter, 669 removeAction, 670 removeFilter, 671 hasAction, 672 hasFilter, 673 removeAllActions, 674 removeAllFilters, 675 doAction, 676 applyFilters, 677 currentAction, 678 currentFilter, 679 doingAction, 680 doingFilter, 681 didAction, 682 didFilter, 683 actions, 684 filters 685 } = defaultHooks; 686 687 688 689 /***/ }) 690 691 /******/ });