diff -r 7b1b88e27a20 -r 48c4eec2b7e6 wp/wp-includes/js/dist/priority-queue.js --- a/wp/wp-includes/js/dist/priority-queue.js Thu Sep 29 08:06:27 2022 +0200 +++ b/wp/wp-includes/js/dist/priority-queue.js Fri Sep 05 18:40:08 2025 +0200 @@ -1,49 +1,314 @@ -/******/ (function() { // webpackBootstrap -/******/ "use strict"; -/******/ // The require scope -/******/ var __webpack_require__ = {}; +/******/ (() => { // webpackBootstrap +/******/ var __webpack_modules__ = ({ + +/***/ 5033: +/***/ ((module, exports, __webpack_require__) => { + +var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;(function (factory) { + if (true) { + !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), + __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? + (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), + __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); + } else {} +}(function(){ + 'use strict'; + var scheduleStart, throttleDelay, lazytimer, lazyraf; + var root = typeof window != 'undefined' ? + window : + typeof __webpack_require__.g != undefined ? + __webpack_require__.g : + this || {}; + var requestAnimationFrame = root.cancelRequestAnimationFrame && root.requestAnimationFrame || setTimeout; + var cancelRequestAnimationFrame = root.cancelRequestAnimationFrame || clearTimeout; + var tasks = []; + var runAttempts = 0; + var isRunning = false; + var remainingTime = 7; + var minThrottle = 35; + var throttle = 125; + var index = 0; + var taskStart = 0; + var tasklength = 0; + var IdleDeadline = { + get didTimeout(){ + return false; + }, + timeRemaining: function(){ + var timeRemaining = remainingTime - (Date.now() - taskStart); + return timeRemaining < 0 ? 0 : timeRemaining; + }, + }; + var setInactive = debounce(function(){ + remainingTime = 22; + throttle = 66; + minThrottle = 0; + }); + + function debounce(fn){ + var id, timestamp; + var wait = 99; + var check = function(){ + var last = (Date.now()) - timestamp; + + if (last < wait) { + id = setTimeout(check, wait - last); + } else { + id = null; + fn(); + } + }; + return function(){ + timestamp = Date.now(); + if(!id){ + id = setTimeout(check, wait); + } + }; + } + + function abortRunning(){ + if(isRunning){ + if(lazyraf){ + cancelRequestAnimationFrame(lazyraf); + } + if(lazytimer){ + clearTimeout(lazytimer); + } + isRunning = false; + } + } + + function onInputorMutation(){ + if(throttle != 125){ + remainingTime = 7; + throttle = 125; + minThrottle = 35; + + if(isRunning) { + abortRunning(); + scheduleLazy(); + } + } + setInactive(); + } + + function scheduleAfterRaf() { + lazyraf = null; + lazytimer = setTimeout(runTasks, 0); + } + + function scheduleRaf(){ + lazytimer = null; + requestAnimationFrame(scheduleAfterRaf); + } + + function scheduleLazy(){ + + if(isRunning){return;} + throttleDelay = throttle - (Date.now() - taskStart); + + scheduleStart = Date.now(); + + isRunning = true; + + if(minThrottle && throttleDelay < minThrottle){ + throttleDelay = minThrottle; + } + + if(throttleDelay > 9){ + lazytimer = setTimeout(scheduleRaf, throttleDelay); + } else { + throttleDelay = 0; + scheduleRaf(); + } + } + + function runTasks(){ + var task, i, len; + var timeThreshold = remainingTime > 9 ? + 9 : + 1 + ; + + taskStart = Date.now(); + isRunning = false; + + lazytimer = null; + + if(runAttempts > 2 || taskStart - throttleDelay - 50 < scheduleStart){ + for(i = 0, len = tasks.length; i < len && IdleDeadline.timeRemaining() > timeThreshold; i++){ + task = tasks.shift(); + tasklength++; + if(task){ + task(IdleDeadline); + } + } + } + + if(tasks.length){ + scheduleLazy(); + } else { + runAttempts = 0; + } + } + + function requestIdleCallbackShim(task){ + index++; + tasks.push(task); + scheduleLazy(); + return index; + } + + function cancelIdleCallbackShim(id){ + var index = id - 1 - tasklength; + if(tasks[index]){ + tasks[index] = null; + } + } + + if(!root.requestIdleCallback || !root.cancelIdleCallback){ + root.requestIdleCallback = requestIdleCallbackShim; + root.cancelIdleCallback = cancelIdleCallbackShim; + + if(root.document && document.addEventListener){ + root.addEventListener('scroll', onInputorMutation, true); + root.addEventListener('resize', onInputorMutation); + + document.addEventListener('focus', onInputorMutation, true); + document.addEventListener('mouseover', onInputorMutation, true); + ['click', 'keypress', 'touchstart', 'mousedown'].forEach(function(name){ + document.addEventListener(name, onInputorMutation, {capture: true, passive: true}); + }); + + if(root.MutationObserver){ + new MutationObserver( onInputorMutation ).observe( document.documentElement, {childList: true, subtree: true, attributes: true} ); + } + } + } else { + try{ + root.requestIdleCallback(function(){}, {timeout: 0}); + } catch(e){ + (function(rIC){ + var timeRemainingProto, timeRemaining; + root.requestIdleCallback = function(fn, timeout){ + if(timeout && typeof timeout.timeout == 'number'){ + return rIC(fn, timeout.timeout); + } + return rIC(fn); + }; + if(root.IdleCallbackDeadline && (timeRemainingProto = IdleCallbackDeadline.prototype)){ + timeRemaining = Object.getOwnPropertyDescriptor(timeRemainingProto, 'timeRemaining'); + if(!timeRemaining || !timeRemaining.configurable || !timeRemaining.get){return;} + Object.defineProperty(timeRemainingProto, 'timeRemaining', { + value: function(){ + return timeRemaining.get.call(this); + }, + enumerable: true, + configurable: true, + }); + } + })(root.requestIdleCallback) + } + } + + return { + request: requestIdleCallbackShim, + cancel: cancelIdleCallbackShim, + }; +})); + + +/***/ }) + +/******/ }); +/************************************************************************/ +/******/ // The module cache +/******/ var __webpack_module_cache__ = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ // Check if module is in cache +/******/ var cachedModule = __webpack_module_cache__[moduleId]; +/******/ if (cachedModule !== undefined) { +/******/ return cachedModule.exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = __webpack_module_cache__[moduleId] = { +/******/ // no module.id needed +/******/ // no module.loaded needed +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__); +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } /******/ /************************************************************************/ /******/ /* webpack/runtime/define property getters */ -/******/ !function() { +/******/ (() => { /******/ // define getter functions for harmony exports -/******/ __webpack_require__.d = function(exports, definition) { +/******/ __webpack_require__.d = (exports, definition) => { /******/ for(var key in definition) { /******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { /******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); /******/ } /******/ } /******/ }; -/******/ }(); +/******/ })(); +/******/ +/******/ /* webpack/runtime/global */ +/******/ (() => { +/******/ __webpack_require__.g = (function() { +/******/ if (typeof globalThis === 'object') return globalThis; +/******/ try { +/******/ return this || new Function('return this')(); +/******/ } catch (e) { +/******/ if (typeof window === 'object') return window; +/******/ } +/******/ })(); +/******/ })(); /******/ /******/ /* webpack/runtime/hasOwnProperty shorthand */ -/******/ !function() { -/******/ __webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); } -/******/ }(); +/******/ (() => { +/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop)) +/******/ })(); /******/ /******/ /* webpack/runtime/make namespace object */ -/******/ !function() { +/******/ (() => { /******/ // define __esModule on exports -/******/ __webpack_require__.r = function(exports) { +/******/ __webpack_require__.r = (exports) => { /******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { /******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); /******/ } /******/ Object.defineProperty(exports, '__esModule', { value: true }); /******/ }; -/******/ }(); +/******/ })(); /******/ /************************************************************************/ var __webpack_exports__ = {}; +// This entry need to be wrapped in an IIFE because it need to be in strict mode. +(() => { +"use strict"; // ESM COMPAT FLAG __webpack_require__.r(__webpack_exports__); // EXPORTS __webpack_require__.d(__webpack_exports__, { - "createQueue": function() { return /* binding */ createQueue; } + createQueue: () => (/* binding */ createQueue) }); +// EXTERNAL MODULE: ./node_modules/requestidlecallback/index.js +var requestidlecallback = __webpack_require__(5033); ;// CONCATENATED MODULE: ./node_modules/@wordpress/priority-queue/build-module/request-idle-callback.js /** + * External dependencies + */ + + +/** * @typedef {( timeOrDeadline: IdleDeadline | number ) => void} Callback */ @@ -56,16 +321,16 @@ setTimeout(() => callback(Date.now()), 0); }; } - - return window.requestIdleCallback || window.requestAnimationFrame; + return window.requestIdleCallback; } -/* harmony default export */ var request_idle_callback = (createRequestIdleCallback()); +/* harmony default export */ const request_idle_callback = (createRequestIdleCallback()); ;// CONCATENATED MODULE: ./node_modules/@wordpress/priority-queue/build-module/index.js /** * Internal dependencies */ + /** * Enqueued callback to invoke once idle time permits. * @@ -101,9 +366,10 @@ * * @typedef {Object} WPPriorityQueue * - * @property {WPPriorityQueueAdd} add Add callback to queue for context. - * @property {WPPriorityQueueFlush} flush Flush queue for context. - * @property {WPPriorityQueueReset} reset Reset queue. + * @property {WPPriorityQueueAdd} add Add callback to queue for context. + * @property {WPPriorityQueueFlush} flush Flush queue for context. + * @property {WPPriorityQueueFlush} cancel Clear queue for context. + * @property {WPPriorityQueueReset} reset Reset queue. */ /** @@ -128,67 +394,63 @@ * * @return {WPPriorityQueue} Queue object with `add`, `flush` and `reset` methods. */ +const createQueue = () => { + /** @type {Map} */ + const waitingList = new Map(); + let isRunning = false; -const createQueue = () => { - /** @type {WPPriorityQueueContext[]} */ - let waitingList = []; - /** @type {WeakMap} */ - - let elementsMap = new WeakMap(); - let isRunning = false; /** * Callback to process as much queue as time permits. * + * Map Iteration follows the original insertion order. This means that here + * we can iterate the queue and know that the first contexts which were + * added will be run first. On the other hand, if anyone adds a new callback + * for an existing context it will supplant the previously-set callback for + * that context because we reassigned that map key's value. + * + * In the case that a callback adds a new callback to its own context then + * the callback it adds will appear at the end of the iteration and will be + * run only after all other existing contexts have finished executing. + * * @param {IdleDeadline|number} deadline Idle callback deadline object, or * animation frame timestamp. */ - const runWaitingList = deadline => { - const hasTimeRemaining = typeof deadline === 'number' ? () => false : () => deadline.timeRemaining() > 0; - - do { - if (waitingList.length === 0) { - isRunning = false; - return; + for (const [nextElement, callback] of waitingList) { + waitingList.delete(nextElement); + callback(); + if ('number' === typeof deadline || deadline.timeRemaining() <= 0) { + break; } - - const nextElement = - /** @type {WPPriorityQueueContext} */ - waitingList.shift(); - const callback = - /** @type {WPPriorityQueueCallback} */ - elementsMap.get(nextElement); // If errors with undefined callbacks are encountered double check that all of your useSelect calls - // have all dependecies set correctly in second parameter. Missing dependencies can cause unexpected - // loops and race conditions in the queue. - - callback(); - elementsMap.delete(nextElement); - } while (hasTimeRemaining()); - + } + if (waitingList.size === 0) { + isRunning = false; + return; + } request_idle_callback(runWaitingList); }; + /** * Add a callback to the queue for a given context. * + * If errors with undefined callbacks are encountered double check that + * all of your useSelect calls have the right dependencies set correctly + * in their second parameter. Missing dependencies can cause unexpected + * loops and race conditions in the queue. + * * @type {WPPriorityQueueAdd} * * @param {WPPriorityQueueContext} element Context object. * @param {WPPriorityQueueCallback} item Callback function. */ - - const add = (element, item) => { - if (!elementsMap.has(element)) { - waitingList.push(element); - } - - elementsMap.set(element, item); - + waitingList.set(element, item); if (!isRunning) { isRunning = true; request_idle_callback(runWaitingList); } }; + /** * Flushes queue for a given context, returning true if the flush was * performed, or false if there is no queue for the given context. @@ -199,42 +461,50 @@ * * @return {boolean} Whether flush was performed. */ - - const flush = element => { - if (!elementsMap.has(element)) { + const callback = waitingList.get(element); + if (undefined === callback) { return false; } - - const index = waitingList.indexOf(element); - waitingList.splice(index, 1); - const callback = - /** @type {WPPriorityQueueCallback} */ - elementsMap.get(element); - elementsMap.delete(element); + waitingList.delete(element); callback(); return true; }; + + /** + * Clears the queue for a given context, cancelling the callbacks without + * executing them. Returns `true` if there were scheduled callbacks to cancel, + * or `false` if there was is no queue for the given context. + * + * @type {WPPriorityQueueFlush} + * + * @param {WPPriorityQueueContext} element Context object. + * + * @return {boolean} Whether any callbacks got cancelled. + */ + const cancel = element => { + return waitingList.delete(element); + }; + /** * Reset the queue without running the pending callbacks. * * @type {WPPriorityQueueReset} */ - - const reset = () => { - waitingList = []; - elementsMap = new WeakMap(); + waitingList.clear(); isRunning = false; }; - return { add, flush, + cancel, reset }; }; +})(); + (window.wp = window.wp || {}).priorityQueue = __webpack_exports__; /******/ })() ; \ No newline at end of file