| 1 |
window["wp"] = window["wp"] || {}; window["wp"]["priorityQueue"] = |
| 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 = 433); |
| 86 |
/******/ }) |
| 87 |
/************************************************************************/ |
| 88 |
/******/ ({ |
| 89 |
|
| 90 |
/***/ 433: |
| 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__, "createQueue", function() { return /* binding */ createQueue; }); |
| 99 |
|
| 100 |
// CONCATENATED MODULE: ./packages/priority-queue/build-module/request-idle-callback.js |
| 101 |
/** |
| 102 |
* @typedef {( timeOrDeadline: IdleDeadline | number ) => void} Callback |
| 103 |
*/ |
| 104 |
|
| 105 |
/** |
| 106 |
* @return {(callback: Callback) => void} RequestIdleCallback |
| 107 |
*/ |
| 108 |
function createRequestIdleCallback() { |
| 109 |
if (typeof window === 'undefined') { |
| 110 |
return callback => { |
| 111 |
setTimeout(() => callback(Date.now()), 0); |
| 112 |
}; |
| 113 |
} |
| 114 |
|
| 115 |
return window.requestIdleCallback || window.requestAnimationFrame; |
| 116 |
} |
| 117 |
/* harmony default export */ var request_idle_callback = (createRequestIdleCallback()); |
| 118 |
//# sourceMappingURL=request-idle-callback.js.map |
| 119 |
// CONCATENATED MODULE: ./packages/priority-queue/build-module/index.js |
| 120 |
/** |
| 121 |
* Internal dependencies |
| 122 |
*/ |
| 123 |
|
| 124 |
/** |
| 125 |
* Enqueued callback to invoke once idle time permits. |
| 126 |
* |
| 127 |
* @typedef {()=>void} WPPriorityQueueCallback |
| 128 |
*/ |
| 129 |
|
| 130 |
/** |
| 131 |
* An object used to associate callbacks in a particular context grouping. |
| 132 |
* |
| 133 |
* @typedef {{}} WPPriorityQueueContext |
| 134 |
*/ |
| 135 |
|
| 136 |
/** |
| 137 |
* Function to add callback to priority queue. |
| 138 |
* |
| 139 |
* @typedef {(element:WPPriorityQueueContext,item:WPPriorityQueueCallback)=>void} WPPriorityQueueAdd |
| 140 |
*/ |
| 141 |
|
| 142 |
/** |
| 143 |
* Function to flush callbacks from priority queue. |
| 144 |
* |
| 145 |
* @typedef {(element:WPPriorityQueueContext)=>boolean} WPPriorityQueueFlush |
| 146 |
*/ |
| 147 |
|
| 148 |
/** |
| 149 |
* Reset the queue. |
| 150 |
* |
| 151 |
* @typedef {()=>void} WPPriorityQueueReset |
| 152 |
*/ |
| 153 |
|
| 154 |
/** |
| 155 |
* Priority queue instance. |
| 156 |
* |
| 157 |
* @typedef {Object} WPPriorityQueue |
| 158 |
* |
| 159 |
* @property {WPPriorityQueueAdd} add Add callback to queue for context. |
| 160 |
* @property {WPPriorityQueueFlush} flush Flush queue for context. |
| 161 |
* @property {WPPriorityQueueReset} reset Reset queue. |
| 162 |
*/ |
| 163 |
|
| 164 |
/** |
| 165 |
* Creates a context-aware queue that only executes |
| 166 |
* the last task of a given context. |
| 167 |
* |
| 168 |
* @example |
| 169 |
*```js |
| 170 |
* import { createQueue } from '@wordpress/priority-queue'; |
| 171 |
* |
| 172 |
* const queue = createQueue(); |
| 173 |
* |
| 174 |
* // Context objects. |
| 175 |
* const ctx1 = {}; |
| 176 |
* const ctx2 = {}; |
| 177 |
* |
| 178 |
* // For a given context in the queue, only the last callback is executed. |
| 179 |
* queue.add( ctx1, () => console.log( 'This will be printed first' ) ); |
| 180 |
* queue.add( ctx2, () => console.log( 'This won\'t be printed' ) ); |
| 181 |
* queue.add( ctx2, () => console.log( 'This will be printed second' ) ); |
| 182 |
*``` |
| 183 |
* |
| 184 |
* @return {WPPriorityQueue} Queue object with `add`, `flush` and `reset` methods. |
| 185 |
*/ |
| 186 |
|
| 187 |
const createQueue = () => { |
| 188 |
/** @type {WPPriorityQueueContext[]} */ |
| 189 |
let waitingList = []; |
| 190 |
/** @type {WeakMap<WPPriorityQueueContext,WPPriorityQueueCallback>} */ |
| 191 |
|
| 192 |
let elementsMap = new WeakMap(); |
| 193 |
let isRunning = false; |
| 194 |
/** |
| 195 |
* Callback to process as much queue as time permits. |
| 196 |
* |
| 197 |
* @param {IdleDeadline|number} deadline Idle callback deadline object, or |
| 198 |
* animation frame timestamp. |
| 199 |
*/ |
| 200 |
|
| 201 |
const runWaitingList = deadline => { |
| 202 |
const hasTimeRemaining = typeof deadline === 'number' ? () => false : () => deadline.timeRemaining() > 0; |
| 203 |
|
| 204 |
do { |
| 205 |
if (waitingList.length === 0) { |
| 206 |
isRunning = false; |
| 207 |
return; |
| 208 |
} |
| 209 |
|
| 210 |
const nextElement = |
| 211 |
/** @type {WPPriorityQueueContext} */ |
| 212 |
waitingList.shift(); |
| 213 |
const callback = |
| 214 |
/** @type {WPPriorityQueueCallback} */ |
| 215 |
elementsMap.get(nextElement); // If errors with undefined callbacks are encountered double check that all of your useSelect calls |
| 216 |
// have all dependecies set correctly in second parameter. Missing dependencies can cause unexpected |
| 217 |
// loops and race conditions in the queue. |
| 218 |
|
| 219 |
callback(); |
| 220 |
elementsMap.delete(nextElement); |
| 221 |
} while (hasTimeRemaining()); |
| 222 |
|
| 223 |
request_idle_callback(runWaitingList); |
| 224 |
}; |
| 225 |
/** |
| 226 |
* Add a callback to the queue for a given context. |
| 227 |
* |
| 228 |
* @type {WPPriorityQueueAdd} |
| 229 |
* |
| 230 |
* @param {WPPriorityQueueContext} element Context object. |
| 231 |
* @param {WPPriorityQueueCallback} item Callback function. |
| 232 |
*/ |
| 233 |
|
| 234 |
|
| 235 |
const add = (element, item) => { |
| 236 |
if (!elementsMap.has(element)) { |
| 237 |
waitingList.push(element); |
| 238 |
} |
| 239 |
|
| 240 |
elementsMap.set(element, item); |
| 241 |
|
| 242 |
if (!isRunning) { |
| 243 |
isRunning = true; |
| 244 |
request_idle_callback(runWaitingList); |
| 245 |
} |
| 246 |
}; |
| 247 |
/** |
| 248 |
* Flushes queue for a given context, returning true if the flush was |
| 249 |
* performed, or false if there is no queue for the given context. |
| 250 |
* |
| 251 |
* @type {WPPriorityQueueFlush} |
| 252 |
* |
| 253 |
* @param {WPPriorityQueueContext} element Context object. |
| 254 |
* |
| 255 |
* @return {boolean} Whether flush was performed. |
| 256 |
*/ |
| 257 |
|
| 258 |
|
| 259 |
const flush = element => { |
| 260 |
if (!elementsMap.has(element)) { |
| 261 |
return false; |
| 262 |
} |
| 263 |
|
| 264 |
const index = waitingList.indexOf(element); |
| 265 |
waitingList.splice(index, 1); |
| 266 |
const callback = |
| 267 |
/** @type {WPPriorityQueueCallback} */ |
| 268 |
elementsMap.get(element); |
| 269 |
elementsMap.delete(element); |
| 270 |
callback(); |
| 271 |
return true; |
| 272 |
}; |
| 273 |
/** |
| 274 |
* Reset the queue without running the pending callbacks. |
| 275 |
* |
| 276 |
* @type {WPPriorityQueueReset} |
| 277 |
*/ |
| 278 |
|
| 279 |
|
| 280 |
const reset = () => { |
| 281 |
waitingList = []; |
| 282 |
elementsMap = new WeakMap(); |
| 283 |
isRunning = false; |
| 284 |
}; |
| 285 |
|
| 286 |
return { |
| 287 |
add, |
| 288 |
flush, |
| 289 |
reset |
| 290 |
}; |
| 291 |
}; |
| 292 |
//# sourceMappingURL=index.js.map |
| 293 |
|
| 294 |
/***/ }) |
| 295 |
|
| 296 |
/******/ }); |
