Gutenberg / 21.7.0

Gutenberg v21.7.0

gutenberg / build / priority-queue / index.js

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

472 lines 12.9 KB

Raw Download Zip

1	/******/ (() => { // webpackBootstrap
2	/******/ var __webpack_modules__ = ({
3
4	/***/ 5033:
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 needs to be wrapped in an IIFE because it needs 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__(5033);
305	;// ./packages/priority-queue/build-module/request-idle-callback.js
306	/**
307	* External dependencies
308	*/
309
310
311	/**
312	* Internal dependencies
313	*/
314
315	/**
316	* @return A function that schedules a callback when the browser is idle or via setTimeout on the server.
317	*/
318	function createRequestIdleCallback() {
319	if (typeof window === 'undefined') {
320	return callback => {
321	setTimeout(() => callback(Date.now()), 0);
322	};
323	}
324	return window.requestIdleCallback;
325	}
326	/* harmony default export */ const request_idle_callback = (createRequestIdleCallback());
327
328	;// ./packages/priority-queue/build-module/index.js
329	/**
330	* Internal dependencies
331	*/
332
333
334	/**
335	* Enqueued callback to invoke once idle time permits.
336	*/
337
338	/**
339	* An object used to associate callbacks in a particular context grouping.
340	*/
341
342	/**
343	* Interface for the priority queue instance.
344	*/
345
346	/**
347	* Creates a context-aware queue that only executes
348	* the last task of a given context.
349	*
350	* @example
351	*```js
352	* import { createQueue } from '@wordpress/priority-queue';
353	*
354	* const queue = createQueue();
355	*
356	* // Context objects.
357	* const ctx1 = {};
358	* const ctx2 = {};
359	*
360	* // For a given context in the queue, only the last callback is executed.
361	* queue.add( ctx1, () => console.log( 'This will be printed first' ) );
362	* queue.add( ctx2, () => console.log( 'This won\'t be printed' ) );
363	* queue.add( ctx2, () => console.log( 'This will be printed second' ) );
364	*```
365	*
366	* @return {WPPriorityQueue} Queue object with `add`, `flush` and `reset` methods.
367	*/
368	const createQueue = () => {
369	const waitingList = new Map();
370	let isRunning = false;
371
372	/**
373	* Callback to process as much queue as time permits.
374	*
375	* Map Iteration follows the original insertion order. This means that here
376	* we can iterate the queue and know that the first contexts which were
377	* added will be run first. On the other hand, if anyone adds a new callback
378	* for an existing context it will supplant the previously-set callback for
379	* that context because we reassigned that map key's value.
380	*
381	* In the case that a callback adds a new callback to its own context then
382	* the callback it adds will appear at the end of the iteration and will be
383	* run only after all other existing contexts have finished executing.
384	*
385	* @param {IdleDeadline\|number} deadline Idle callback deadline object, or
386	* animation frame timestamp.
387	*/
388	const runWaitingList = deadline => {
389	for (const [nextElement, callback] of waitingList) {
390	waitingList.delete(nextElement);
391	callback();
392	if ('number' === typeof deadline \|\| deadline.timeRemaining() <= 0) {
393	break;
394	}
395	}
396	if (waitingList.size === 0) {
397	isRunning = false;
398	return;
399	}
400	request_idle_callback(runWaitingList);
401	};
402
403	/**
404	* Add a callback to the queue for a given context.
405	*
406	* If errors with undefined callbacks are encountered double check that
407	* all of your useSelect calls have the right dependencies set correctly
408	* in their second parameter. Missing dependencies can cause unexpected
409	* loops and race conditions in the queue.
410	*
411	* @param {WPPriorityQueueContext} element Context object.
412	* @param {WPPriorityQueueCallback} item Callback function.
413	*/
414	const add = (element, item) => {
415	waitingList.set(element, item);
416	if (!isRunning) {
417	isRunning = true;
418	request_idle_callback(runWaitingList);
419	}
420	};
421
422	/**
423	* Flushes queue for a given context, returning true if the flush was
424	* performed, or false if there is no queue for the given context.
425	*
426	* @param {WPPriorityQueueContext} element Context object.
427	*
428	* @return {boolean} Whether flush was performed.
429	*/
430	const flush = element => {
431	const callback = waitingList.get(element);
432	if (undefined === callback) {
433	return false;
434	}
435	waitingList.delete(element);
436	callback();
437	return true;
438	};
439
440	/**
441	* Clears the queue for a given context, cancelling the callbacks without
442	* executing them. Returns `true` if there were scheduled callbacks to cancel,
443	* or `false` if there was is no queue for the given context.
444	*
445	* @param {WPPriorityQueueContext} element Context object.
446	*
447	* @return {boolean} Whether any callbacks got cancelled.
448	*/
449	const cancel = element => {
450	return waitingList.delete(element);
451	};
452
453	/**
454	* Reset the queue without running the pending callbacks.
455	*/
456	const reset = () => {
457	waitingList.clear();
458	isRunning = false;
459	};
460	return {
461	add,
462	flush,
463	cancel,
464	reset
465	};
466	};
467
468	})();
469
470	(window.wp = window.wp \|\| {}).priorityQueue = __webpack_exports__;
471	/******/ })()
472	;