enmi-conf.org: comparison wp/wp-includes/js/dist/hooks.js

Mercurial Mercurial > enmi-conf.org / comparison

summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help

wp/wp-includes/js/dist/hooks.js

changeset 22	8c2e4d02f4ef
parent 21	48c4eec2b7e6

equal deleted inserted replaced

-:48c4eec2b7e6
+:8c2e4d02f4ef
 __webpack_require__.d(__webpack_exports__, {
 actions: () => (/* binding */ actions),
 addAction: () => (/* binding */ addAction),
 addFilter: () => (/* binding */ addFilter),
 applyFilters: () => (/* binding */ applyFilters),
+applyFiltersAsync: () => (/* binding */ applyFiltersAsync),
 createHooks: () => (/* reexport */ build_module_createHooks),
 currentAction: () => (/* binding */ currentAction),
 currentFilter: () => (/* binding */ currentFilter),
 defaultHooks: () => (/* binding */ defaultHooks),
 didAction: () => (/* binding */ didAction),
 didFilter: () => (/* binding */ didFilter),
 doAction: () => (/* binding */ doAction),
+doActionAsync: () => (/* binding */ doActionAsync),
 doingAction: () => (/* binding */ doingAction),
 doingFilter: () => (/* binding */ doingFilter),
 filters: () => (/* binding */ filters),
 hasAction: () => (/* binding */ hasAction),
 hasFilter: () => (/* binding */ hasFilter),
 removeAllActions: () => (/* binding */ removeAllActions),
 removeAllFilters: () => (/* binding */ removeAllFilters),
 removeFilter: () => (/* binding */ removeFilter)
 });
-;// CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/validateNamespace.js
+;// ./node_modules/@wordpress/hooks/build-module/validateNamespace.js
 /**
 * Validate a namespace string.
 *
 * @param {string} namespace The namespace to validate - should take the form
 *                           `vendor/plugin/function`.
 }
 return true;
 }
 /* harmony default export */ const build_module_validateNamespace = (validateNamespace);
-;// CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/validateHookName.js
+;// ./node_modules/@wordpress/hooks/build-module/validateHookName.js
 /**
 * Validate a hookName string.
 *
 * @param {string} hookName The hook name to validate. Should be a non empty string containing
 *                          only numbers, letters, dashes, periods and underscores. Also,
 }
 return true;
 }
 /* harmony default export */ const build_module_validateHookName = (validateHookName);
-;// CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/createAddHook.js
+;// ./node_modules/@wordpress/hooks/build-module/createAddHook.js
 /**
 * Internal dependencies
 */
 }
 };
 }
 /* harmony default export */ const build_module_createAddHook = (createAddHook);
-;// CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/createRemoveHook.js
+;// ./node_modules/@wordpress/hooks/build-module/createRemoveHook.js
 /**
 * Internal dependencies
 */
 return handlersRemoved;
 };
 }
 /* harmony default export */ const build_module_createRemoveHook = (createRemoveHook);
-;// CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/createHasHook.js
+;// ./node_modules/@wordpress/hooks/build-module/createHasHook.js
 /**
 * @callback HasHook
 *
 * Returns whether any handlers are attached for the given hookName and optional namespace.
 *
 return hookName in hooksStore;
 };
 }
 /* harmony default export */ const build_module_createHasHook = (createHasHook);
-;// CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/createRunHook.js
+;// ./node_modules/@wordpress/hooks/build-module/createRunHook.js
 /**
 * Returns a function which, when invoked, will execute all callbacks
 * registered to a hook of the specified type, optionally returning the final
 * value of the call chain.
 *
-* @param {import('.').Hooks}    hooks                  Hooks instance.
+* @param {import('.').Hooks}    hooks          Hooks instance.
 * @param {import('.').StoreKey} storeKey
-* @param {boolean}              [returnFirstArg=false] Whether each hook callback is expected to
+* @param {boolean}              returnFirstArg Whether each hook callback is expected to return its first argument.
-*                                                      return its first argument.
+* @param {boolean}              async          Whether the hook callback should be run asynchronously
 *
 * @return {(hookName:string, ...args: unknown[]) => undefined|unknown} Function that runs hook callbacks.
 */
-function createRunHook(hooks, storeKey, returnFirstArg = false) {
+function createRunHook(hooks, storeKey, returnFirstArg, async) {
-return function runHooks(hookName, ...args) {
+return function runHook(hookName, ...args) {
 const hooksStore = hooks[storeKey];
 if (!hooksStore[hookName]) {
 hooksStore[hookName] = {
 handlers: [],
 runs: 0
 }
 const hookInfo = {
 name: hookName,
 currentIndex: 0
 };
-hooksStore.__current.push(hookInfo);
+async function asyncRunner() {
-while (hookInfo.currentIndex < handlers.length) {
+try {
-const handler = handlers[hookInfo.currentIndex];
+hooksStore.__current.add(hookInfo);
-const result = handler.callback.apply(null, args);
+let result = returnFirstArg ? args[0] : undefined;
-if (returnFirstArg) {
+while (hookInfo.currentIndex < handlers.length) {
-args[0] = result;
+const handler = handlers[hookInfo.currentIndex];
+result = await handler.callback.apply(null, args);
+if (returnFirstArg) {
+args[0] = result;
+}
+hookInfo.currentIndex++;
+}
+return returnFirstArg ? result : undefined;
+} finally {
+hooksStore.__current.delete(hookInfo);
 }
-hookInfo.currentIndex++;
+}
-}
+function syncRunner() {
-hooksStore.__current.pop();
+try {
-if (returnFirstArg) {
+hooksStore.__current.add(hookInfo);
-return args[0];
+let result = returnFirstArg ? args[0] : undefined;
-}
+while (hookInfo.currentIndex < handlers.length) {
-return undefined;
+const handler = handlers[hookInfo.currentIndex];
+result = handler.callback.apply(null, args);
+if (returnFirstArg) {
+args[0] = result;
+}
+hookInfo.currentIndex++;
+}
+return returnFirstArg ? result : undefined;
+} finally {
+hooksStore.__current.delete(hookInfo);
+}
+}
+return (async ? asyncRunner : syncRunner)();
 };
 }
 /* harmony default export */ const build_module_createRunHook = (createRunHook);
-;// CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/createCurrentHook.js
+;// ./node_modules/@wordpress/hooks/build-module/createCurrentHook.js
 /**
 * Returns a function which, when invoked, will return the name of the
 * currently running hook, or `null` if no hook of the given type is currently
 * running.
 *
 *
 * @return {() => string | null} Function that returns the current hook name or null.
 */
 function createCurrentHook(hooks, storeKey) {
 return function currentHook() {
-var _hooksStore$__current;
+var _currentArray$at$name;
 const hooksStore = hooks[storeKey];
-return (_hooksStore$__current = hooksStore.__current[hooksStore.__current.length - 1]?.name) !== null && _hooksStore$__current !== void 0 ? _hooksStore$__current : null;
+const currentArray = Array.from(hooksStore.__current);
+return (_currentArray$at$name = currentArray.at(-1)?.name) !== null && _currentArray$at$name !== void 0 ? _currentArray$at$name : null;
 };
 }
 /* harmony default export */ const build_module_createCurrentHook = (createCurrentHook);
-;// CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/createDoingHook.js
+;// ./node_modules/@wordpress/hooks/build-module/createDoingHook.js
 /**
 * @callback DoingHook
 * Returns whether a hook is currently being executed.
 *
 * @param {string} [hookName] The name of the hook to check for.  If
 return function doingHook(hookName) {
 const hooksStore = hooks[storeKey];
 // If the hookName was not passed, check for any current hook.
 if ('undefined' === typeof hookName) {
-return 'undefined' !== typeof hooksStore.__current[0];
+return hooksStore.__current.size > 0;
 }
-// Return the __current hook.
+// Find if the `hookName` hook is in `__current`.
-return hooksStore.__current[0] ? hookName === hooksStore.__current[0].name : false;
+return Array.from(hooksStore.__current).some(hook => hook.name === hookName);
 };
 }
 /* harmony default export */ const build_module_createDoingHook = (createDoingHook);
-;// CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/createDidHook.js
+;// ./node_modules/@wordpress/hooks/build-module/createDidHook.js
 /**
 * Internal dependencies
 */
 return hooksStore[hookName] && hooksStore[hookName].runs ? hooksStore[hookName].runs : 0;
 };
 }
 /* harmony default export */ const build_module_createDidHook = (createDidHook);
-;// CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/createHooks.js
+;// ./node_modules/@wordpress/hooks/build-module/createHooks.js
 /**
 * Internal dependencies
 */
 */
 class _Hooks {
 constructor() {
 /** @type {import('.').Store} actions */
 this.actions = Object.create(null);
-this.actions.__current = [];
+this.actions.__current = new Set();
 /** @type {import('.').Store} filters */
 this.filters = Object.create(null);
-this.filters.__current = [];
+this.filters.__current = new Set();
 this.addAction = build_module_createAddHook(this, 'actions');
 this.addFilter = build_module_createAddHook(this, 'filters');
 this.removeAction = build_module_createRemoveHook(this, 'actions');
 this.removeFilter = build_module_createRemoveHook(this, 'filters');
 this.hasAction = build_module_createHasHook(this, 'actions');
 this.hasFilter = build_module_createHasHook(this, 'filters');
 this.removeAllActions = build_module_createRemoveHook(this, 'actions', true);
 this.removeAllFilters = build_module_createRemoveHook(this, 'filters', true);
-this.doAction = build_module_createRunHook(this, 'actions');
+this.doAction = build_module_createRunHook(this, 'actions', false, false);
-this.applyFilters = build_module_createRunHook(this, 'filters', true);
+this.doActionAsync = build_module_createRunHook(this, 'actions', false, true);
+this.applyFilters = build_module_createRunHook(this, 'filters', true, false);
+this.applyFiltersAsync = build_module_createRunHook(this, 'filters', true, true);
 this.currentAction = build_module_createCurrentHook(this, 'actions');
 this.currentFilter = build_module_createCurrentHook(this, 'filters');
 this.doingAction = build_module_createDoingHook(this, 'actions');
 this.doingFilter = build_module_createDoingHook(this, 'filters');
 this.didAction = build_module_createDidHook(this, 'actions');
 function createHooks() {
 return new _Hooks();
 }
 /* harmony default export */ const build_module_createHooks = (createHooks);
-;// CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/index.js
+;// ./node_modules/@wordpress/hooks/build-module/index.js
 /**
 * Internal dependencies
 */
 * @property {string} name         Hook name
 * @property {number} currentIndex The index
 */
 /**
-* @typedef {Record<string, Hook> & {__current: Current[]}} Store
+* @typedef {Record<string, Hook> & {__current: Set<Current>}} Store
 */
 /**
 * @typedef {'actions' | 'filters'} StoreKey
 */
 hasAction,
 hasFilter,
 removeAllActions,
 removeAllFilters,
 doAction,
+doActionAsync,
 applyFilters,
+applyFiltersAsync,
 currentAction,
 currentFilter,
 doingAction,
 doingFilter,
 didAction,

enmi-conf.org