Gutenberg / 14.5.2

Gutenberg v14.5.2

gutenberg / build / priority-queue / index.js

index.js in Gutenberg 14.5.2, at build/priority-queue/index.js

532 lines 13.9 KB

Raw Download Zip

1	/******/ (() => { // webpackBootstrap
2	/******/ var __webpack_modules__ = ({
3
4	/***/ 3159:
5	/***/ ((module, exports, __webpack_require__) => {
6
7	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;(function (factory) {
8	if (true) {
9	!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
10	__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
11	(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
12	__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
13	} else {}
14	}(function(){
15	'use strict';
16	var scheduleStart, throttleDelay, lazytimer, lazyraf;
17	var root = typeof window != 'undefined' ?
18	window :
19	typeof __webpack_require__.g != undefined ?
20	__webpack_require__.g :
21	this \|\| {};
22	var requestAnimationFrame = root.cancelRequestAnimationFrame && root.requestAnimationFrame \|\| setTimeout;
23	var cancelRequestAnimationFrame = root.cancelRequestAnimationFrame \|\| clearTimeout;
24	var tasks = [];
25	var runAttempts = 0;
26	var isRunning = false;
27	var remainingTime = 7;
28	var minThrottle = 35;
29	var throttle = 125;
30	var index = 0;
31	var taskStart = 0;
32	var tasklength = 0;
33	var IdleDeadline = {
34	get didTimeout(){
35	return false;
36	},
37	timeRemaining: function(){
38	var timeRemaining = remainingTime - (Date.now() - taskStart);
39	return timeRemaining < 0 ? 0 : timeRemaining;
40	},
41	};
42	var setInactive = debounce(function(){
43	remainingTime = 22;
44	throttle = 66;
45	minThrottle = 0;
46	});
47
48	function debounce(fn){
49	var id, timestamp;
50	var wait = 99;
51	var check = function(){
52	var last = (Date.now()) - timestamp;
53
54	if (last < wait) {
55	id = setTimeout(check, wait - last);
56	} else {
57	id = null;
58	fn();
59	}
60	};
61	return function(){
62	timestamp = Date.now();
63	if(!id){
64	id = setTimeout(check, wait);
65	}
66	};
67	}
68
69	function abortRunning(){
70	if(isRunning){
71	if(lazyraf){
72	cancelRequestAnimationFrame(lazyraf);
73	}
74	if(lazytimer){
75	clearTimeout(lazytimer);
76	}
77	isRunning = false;
78	}
79	}
80
81	function onInputorMutation(){
82	if(throttle != 125){
83	remainingTime = 7;
84	throttle = 125;
85	minThrottle = 35;
86
87	if(isRunning) {
88	abortRunning();
89	scheduleLazy();
90	}
91	}
92	setInactive();
93	}
94
95	function scheduleAfterRaf() {
96	lazyraf = null;
97	lazytimer = setTimeout(runTasks, 0);
98	}
99
100	function scheduleRaf(){
101	lazytimer = null;
102	requestAnimationFrame(scheduleAfterRaf);
103	}
104
105	function scheduleLazy(){
106
107	if(isRunning){return;}
108	throttleDelay = throttle - (Date.now() - taskStart);
109
110	scheduleStart = Date.now();
111
112	isRunning = true;
113
114	if(minThrottle && throttleDelay < minThrottle){
115	throttleDelay = minThrottle;
116	}
117
118	if(throttleDelay > 9){
119	lazytimer = setTimeout(scheduleRaf, throttleDelay);
120	} else {
121	throttleDelay = 0;
122	scheduleRaf();
123	}
124	}
125
126	function runTasks(){
127	var task, i, len;
128	var timeThreshold = remainingTime > 9 ?
129	9 :
130	1
131	;
132
133	taskStart = Date.now();
134	isRunning = false;
135
136	lazytimer = null;
137
138	if(runAttempts > 2 \|\| taskStart - throttleDelay - 50 < scheduleStart){
139	for(i = 0, len = tasks.length; i < len && IdleDeadline.timeRemaining() > timeThreshold; i++){
140	task = tasks.shift();
141	tasklength++;
142	if(task){
143	task(IdleDeadline);
144	}
145	}
146	}
147
148	if(tasks.length){
149	scheduleLazy();
150	} else {
151	runAttempts = 0;
152	}
153	}
154
155	function requestIdleCallbackShim(task){
156	index++;
157	tasks.push(task);
158	scheduleLazy();
159	return index;
160	}
161
162	function cancelIdleCallbackShim(id){
163	var index = id - 1 - tasklength;
164	if(tasks[index]){
165	tasks[index] = null;
166	}
167	}
168
169	if(!root.requestIdleCallback \|\| !root.cancelIdleCallback){
170	root.requestIdleCallback = requestIdleCallbackShim;
171	root.cancelIdleCallback = cancelIdleCallbackShim;
172
173	if(root.document && document.addEventListener){
174	root.addEventListener('scroll', onInputorMutation, true);
175	root.addEventListener('resize', onInputorMutation);
176
177	document.addEventListener('focus', onInputorMutation, true);
178	document.addEventListener('mouseover', onInputorMutation, true);
179	['click', 'keypress', 'touchstart', 'mousedown'].forEach(function(name){
180	document.addEventListener(name, onInputorMutation, {capture: true, passive: true});
181	});
182
183	if(root.MutationObserver){
184	new MutationObserver( onInputorMutation ).observe( document.documentElement, {childList: true, subtree: true, attributes: true} );
185	}
186	}
187	} else {
188	try{
189	root.requestIdleCallback(function(){}, {timeout: 0});
190	} catch(e){
191	(function(rIC){
192	var timeRemainingProto, timeRemaining;
193	root.requestIdleCallback = function(fn, timeout){
194	if(timeout && typeof timeout.timeout == 'number'){
195	return rIC(fn, timeout.timeout);
196	}
197	return rIC(fn);
198	};
199	if(root.IdleCallbackDeadline && (timeRemainingProto = IdleCallbackDeadline.prototype)){
200	timeRemaining = Object.getOwnPropertyDescriptor(timeRemainingProto, 'timeRemaining');
201	if(!timeRemaining \|\| !timeRemaining.configurable \|\| !timeRemaining.get){return;}
202	Object.defineProperty(timeRemainingProto, 'timeRemaining', {
203	value: function(){
204	return timeRemaining.get.call(this);
205	},
206	enumerable: true,
207	configurable: true,
208	});
209	}
210	})(root.requestIdleCallback)
211	}
212	}
213
214	return {
215	request: requestIdleCallbackShim,
216	cancel: cancelIdleCallbackShim,
217	};
218	}));
219
220
221	/***/ })
222
223	/******/ });
224	/************************************************************************/
225	/******/ // The module cache
226	/******/ var __webpack_module_cache__ = {};
227	/******/
228	/******/ // The require function
229	/******/ function __webpack_require__(moduleId) {
230	/******/ // Check if module is in cache
231	/******/ var cachedModule = __webpack_module_cache__[moduleId];
232	/******/ if (cachedModule !== undefined) {
233	/******/ return cachedModule.exports;
234	/******/ }
235	/******/ // Create a new module (and put it into the cache)
236	/******/ var module = __webpack_module_cache__[moduleId] = {
237	/******/ // no module.id needed
238	/******/ // no module.loaded needed
239	/******/ exports: {}
240	/******/ };
241	/******/
242	/******/ // Execute the module function
243	/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
244	/******/
245	/******/ // Return the exports of the module
246	/******/ return module.exports;
247	/******/ }
248	/******/
249	/************************************************************************/
250	/*****/ / webpack/runtime/define property getters */
251	/******/ (() => {
252	/******/ // define getter functions for harmony exports
253	/******/ __webpack_require__.d = (exports, definition) => {
254	/******/ for(var key in definition) {
255	/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
256	/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
257	/******/ }
258	/******/ }
259	/******/ };
260	/******/ })();
261	/******/
262	/*****/ / webpack/runtime/global */
263	/******/ (() => {
264	/******/ __webpack_require__.g = (function() {
265	/******/ if (typeof globalThis === 'object') return globalThis;
266	/******/ try {
267	/******/ return this \|\| new Function('return this')();
268	/******/ } catch (e) {
269	/******/ if (typeof window === 'object') return window;
270	/******/ }
271	/******/ })();
272	/******/ })();
273	/******/
274	/*****/ / webpack/runtime/hasOwnProperty shorthand */
275	/******/ (() => {
276	/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
277	/******/ })();
278	/******/
279	/*****/ / webpack/runtime/make namespace object */
280	/******/ (() => {
281	/******/ // define __esModule on exports
282	/******/ __webpack_require__.r = (exports) => {
283	/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
284	/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
285	/******/ }
286	/******/ Object.defineProperty(exports, '__esModule', { value: true });
287	/******/ };
288	/******/ })();
289	/******/
290	/************************************************************************/
291	var __webpack_exports__ = {};
292	// This entry need to be wrapped in an IIFE because it need to be in strict mode.
293	(() => {
294	"use strict";
295	// ESM COMPAT FLAG
296	__webpack_require__.r(__webpack_exports__);
297
298	// EXPORTS
299	__webpack_require__.d(__webpack_exports__, {
300	"createQueue": () => (/* binding */ createQueue)
301	});
302
303	// EXTERNAL MODULE: ./node_modules/requestidlecallback/index.js
304	var requestidlecallback = __webpack_require__(3159);
305	;// CONCATENATED MODULE: ./packages/priority-queue/build-module/request-idle-callback.js
306	/**
307	* External dependencies
308	*/
309
310	/**
311	* @typedef {( timeOrDeadline: IdleDeadline \| number ) => void} Callback
312	*/
313
314	/**
315	* @return {(callback: Callback) => void} RequestIdleCallback
316	*/
317
318	function createRequestIdleCallback() {
319	if (typeof window === 'undefined') {
320	return callback => {
321	setTimeout(() => callback(Date.now()), 0);
322	};
323	}
324
325	return window.requestIdleCallback;
326	}
327	/* harmony default export */ const request_idle_callback = (createRequestIdleCallback());
328
329	;// CONCATENATED MODULE: ./packages/priority-queue/build-module/index.js
330	/**
331	* Internal dependencies
332	*/
333
334	/**
335	* Enqueued callback to invoke once idle time permits.
336	*
337	* @typedef {()=>void} WPPriorityQueueCallback
338	*/
339
340	/**
341	* An object used to associate callbacks in a particular context grouping.
342	*
343	* @typedef {{}} WPPriorityQueueContext
344	*/
345
346	/**
347	* Function to add callback to priority queue.
348	*
349	* @typedef {(element:WPPriorityQueueContext,item:WPPriorityQueueCallback)=>void} WPPriorityQueueAdd
350	*/
351
352	/**
353	* Function to flush callbacks from priority queue.
354	*
355	* @typedef {(element:WPPriorityQueueContext)=>boolean} WPPriorityQueueFlush
356	*/
357
358	/**
359	* Reset the queue.
360	*
361	* @typedef {()=>void} WPPriorityQueueReset
362	*/
363
364	/**
365	* Priority queue instance.
366	*
367	* @typedef {Object} WPPriorityQueue
368	*
369	* @property {WPPriorityQueueAdd} add Add callback to queue for context.
370	* @property {WPPriorityQueueFlush} flush Flush queue for context.
371	* @property {WPPriorityQueueFlush} cancel Clear queue for context.
372	* @property {WPPriorityQueueReset} reset Reset queue.
373	*/
374
375	/**
376	* Creates a context-aware queue that only executes
377	* the last task of a given context.
378	*
379	* @example
380	*```js
381	* import { createQueue } from '@wordpress/priority-queue';
382	*
383	* const queue = createQueue();
384	*
385	* // Context objects.
386	* const ctx1 = {};
387	* const ctx2 = {};
388	*
389	* // For a given context in the queue, only the last callback is executed.
390	* queue.add( ctx1, () => console.log( 'This will be printed first' ) );
391	* queue.add( ctx2, () => console.log( 'This won\'t be printed' ) );
392	* queue.add( ctx2, () => console.log( 'This will be printed second' ) );
393	*```
394	*
395	* @return {WPPriorityQueue} Queue object with `add`, `flush` and `reset` methods.
396	*/
397
398	const createQueue = () => {
399	/** @type {WPPriorityQueueContext[]} */
400	let waitingList = [];
401	/** @type {WeakMap<WPPriorityQueueContext,WPPriorityQueueCallback>} */
402
403	let elementsMap = new WeakMap();
404	let isRunning = false;
405	/**
406	* Callback to process as much queue as time permits.
407	*
408	* @param {IdleDeadline\|number} deadline Idle callback deadline object, or
409	* animation frame timestamp.
410	*/
411
412	const runWaitingList = deadline => {
413	const hasTimeRemaining = typeof deadline === 'number' ? () => false : () => deadline.timeRemaining() > 0;
414
415	do {
416	if (waitingList.length === 0) {
417	isRunning = false;
418	return;
419	}
420
421	const nextElement =
422	/** @type {WPPriorityQueueContext} */
423	waitingList.shift();
424	const callback =
425	/** @type {WPPriorityQueueCallback} */
426	elementsMap.get(nextElement); // If errors with undefined callbacks are encountered double check that all of your useSelect calls
427	// have all dependecies set correctly in second parameter. Missing dependencies can cause unexpected
428	// loops and race conditions in the queue.
429
430	callback();
431	elementsMap.delete(nextElement);
432	} while (hasTimeRemaining());
433
434	request_idle_callback(runWaitingList);
435	};
436	/**
437	* Add a callback to the queue for a given context.
438	*
439	* @type {WPPriorityQueueAdd}
440	*
441	* @param {WPPriorityQueueContext} element Context object.
442	* @param {WPPriorityQueueCallback} item Callback function.
443	*/
444
445
446	const add = (element, item) => {
447	if (!elementsMap.has(element)) {
448	waitingList.push(element);
449	}
450
451	elementsMap.set(element, item);
452
453	if (!isRunning) {
454	isRunning = true;
455	request_idle_callback(runWaitingList);
456	}
457	};
458	/**
459	* Flushes queue for a given context, returning true if the flush was
460	* performed, or false if there is no queue for the given context.
461	*
462	* @type {WPPriorityQueueFlush}
463	*
464	* @param {WPPriorityQueueContext} element Context object.
465	*
466	* @return {boolean} Whether flush was performed.
467	*/
468
469
470	const flush = element => {
471	if (!elementsMap.has(element)) {
472	return false;
473	}
474
475	const index = waitingList.indexOf(element);
476	waitingList.splice(index, 1);
477	const callback =
478	/** @type {WPPriorityQueueCallback} */
479	elementsMap.get(element);
480	elementsMap.delete(element);
481	callback();
482	return true;
483	};
484	/**
485	* Clears the queue for a given context, cancelling the callbacks without
486	* executing them. Returns `true` if there were scheduled callbacks to cancel,
487	* or `false` if there was is no queue for the given context.
488	*
489	* @type {WPPriorityQueueFlush}
490	*
491	* @param {WPPriorityQueueContext} element Context object.
492	*
493	* @return {boolean} Whether any callbacks got cancelled.
494	*/
495
496
497	const cancel = element => {
498	if (!elementsMap.has(element)) {
499	return false;
500	}
501
502	const index = waitingList.indexOf(element);
503	waitingList.splice(index, 1);
504	elementsMap.delete(element);
505	return true;
506	};
507	/**
508	* Reset the queue without running the pending callbacks.
509	*
510	* @type {WPPriorityQueueReset}
511	*/
512
513
514	const reset = () => {
515	waitingList = [];
516	elementsMap = new WeakMap();
517	isRunning = false;
518	};
519
520	return {
521	add,
522	flush,
523	cancel,
524	reset
525	};
526	};
527
528	})();
529
530	(window.wp = window.wp \|\| {}).priorityQueue = __webpack_exports__;
531	/******/ })()
532	;