Gutenberg / 15.3.1

Gutenberg v15.3.1

gutenberg / build / priority-queue / index.js

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

521 lines 14.0 KB

Raw Download Zip

1	/******/ (function() { // webpackBootstrap
2	/******/ var __webpack_modules__ = ({
3
4	/***/ 3159:
5	/***/ (function(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	/******/ !function() {
252	/******/ // define getter functions for harmony exports
253	/******/ __webpack_require__.d = function(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	/******/ !function() {
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	/******/ !function() {
276	/******/ __webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
277	/******/ }();
278	/******/
279	/*****/ / webpack/runtime/make namespace object */
280	/******/ !function() {
281	/******/ // define __esModule on exports
282	/******/ __webpack_require__.r = function(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	!function() {
294	"use strict";
295	// ESM COMPAT FLAG
296	__webpack_require__.r(__webpack_exports__);
297
298	// EXPORTS
299	__webpack_require__.d(__webpack_exports__, {
300	"createQueue": function() { return /* 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 */ var 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 {Map<WPPriorityQueueContext, WPPriorityQueueCallback>} */
400	const waitingList = new Map();
401	let isRunning = false;
402	/**
403	* Callback to process as much queue as time permits.
404	*
405	* Map Iteration follows the original insertion order. This means that here
406	* we can iterate the queue and know that the first contexts which were
407	* added will be run first. On the other hand, if anyone adds a new callback
408	* for an existing context it will supplant the previously-set callback for
409	* that context because we reassigned that map key's value.
410	*
411	* In the case that a callback adds a new callback to its own context then
412	* the callback it adds will appear at the end of the iteration and will be
413	* run only after all other existing contexts have finished executing.
414	*
415	* @param {IdleDeadline\|number} deadline Idle callback deadline object, or
416	* animation frame timestamp.
417	*/
418
419	const runWaitingList = deadline => {
420	for (const [nextElement, callback] of waitingList) {
421	waitingList.delete(nextElement);
422	callback();
423
424	if ('number' === typeof deadline \|\| deadline.timeRemaining() <= 0) {
425	break;
426	}
427	}
428
429	if (waitingList.size === 0) {
430	isRunning = false;
431	return;
432	}
433
434	request_idle_callback(runWaitingList);
435	};
436	/**
437	* Add a callback to the queue for a given context.
438	*
439	* If errors with undefined callbacks are encountered double check that
440	* all of your useSelect calls have the right dependencies set correctly
441	* in their second parameter. Missing dependencies can cause unexpected
442	* loops and race conditions in the queue.
443	*
444	* @type {WPPriorityQueueAdd}
445	*
446	* @param {WPPriorityQueueContext} element Context object.
447	* @param {WPPriorityQueueCallback} item Callback function.
448	*/
449
450
451	const add = (element, item) => {
452	waitingList.set(element, item);
453
454	if (!isRunning) {
455	isRunning = true;
456	request_idle_callback(runWaitingList);
457	}
458	};
459	/**
460	* Flushes queue for a given context, returning true if the flush was
461	* performed, or false if there is no queue for the given context.
462	*
463	* @type {WPPriorityQueueFlush}
464	*
465	* @param {WPPriorityQueueContext} element Context object.
466	*
467	* @return {boolean} Whether flush was performed.
468	*/
469
470
471	const flush = element => {
472	const callback = waitingList.get(element);
473
474	if (undefined === callback) {
475	return false;
476	}
477
478	waitingList.delete(element);
479	callback();
480	return true;
481	};
482	/**
483	* Clears the queue for a given context, cancelling the callbacks without
484	* executing them. Returns `true` if there were scheduled callbacks to cancel,
485	* or `false` if there was is no queue for the given context.
486	*
487	* @type {WPPriorityQueueFlush}
488	*
489	* @param {WPPriorityQueueContext} element Context object.
490	*
491	* @return {boolean} Whether any callbacks got cancelled.
492	*/
493
494
495	const cancel = element => {
496	return waitingList.delete(element);
497	};
498	/**
499	* Reset the queue without running the pending callbacks.
500	*
501	* @type {WPPriorityQueueReset}
502	*/
503
504
505	const reset = () => {
506	waitingList.clear();
507	isRunning = false;
508	};
509
510	return {
511	add,
512	flush,
513	cancel,
514	reset
515	};
516	};
517
518	}();
519	(window.wp = window.wp \|\| {}).priorityQueue = __webpack_exports__;
520	/******/ })()
521	;