1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 |
|
10 | 'use strict';
|
11 |
|
12 | (function (global, factory) {
|
13 | typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
|
14 | typeof define === 'function' && define.amd ? define(['exports'], factory) :
|
15 | (factory((global.SchedulerMock = {})));
|
16 | }(this, (function (exports) { 'use strict';
|
17 |
|
18 | var enableSchedulerDebugging = false;
|
19 |
|
20 | var currentTime = 0;
|
21 | var scheduledCallback = null;
|
22 | var scheduledTimeout = null;
|
23 | var timeoutTime = -1;
|
24 | var yieldedValues = null;
|
25 | var expectedNumberOfYields = -1;
|
26 | var didStop = false;
|
27 | var isFlushing = false;
|
28 | var needsPaint = false;
|
29 | var shouldYieldForPaint = false;
|
30 |
|
31 | function requestHostCallback(callback) {
|
32 | scheduledCallback = callback;
|
33 | }
|
34 |
|
35 |
|
36 |
|
37 | function requestHostTimeout(callback, ms) {
|
38 | scheduledTimeout = callback;
|
39 | timeoutTime = currentTime + ms;
|
40 | }
|
41 |
|
42 | function cancelHostTimeout() {
|
43 | scheduledTimeout = null;
|
44 | timeoutTime = -1;
|
45 | }
|
46 |
|
47 | function shouldYieldToHost() {
|
48 | if (expectedNumberOfYields !== -1 && yieldedValues !== null && yieldedValues.length >= expectedNumberOfYields || shouldYieldForPaint && needsPaint) {
|
49 |
|
50 | didStop = true;
|
51 | return true;
|
52 | }
|
53 | return false;
|
54 | }
|
55 |
|
56 | function getCurrentTime() {
|
57 | return currentTime;
|
58 | }
|
59 |
|
60 | function forceFrameRate() {
|
61 |
|
62 | }
|
63 |
|
64 |
|
65 |
|
66 |
|
67 | function unstable_flushNumberOfYields(count) {
|
68 | if (isFlushing) {
|
69 | throw new Error('Already flushing work.');
|
70 | }
|
71 | if (scheduledCallback !== null) {
|
72 | var cb = scheduledCallback;
|
73 | expectedNumberOfYields = count;
|
74 | isFlushing = true;
|
75 | try {
|
76 | var hasMoreWork = true;
|
77 | do {
|
78 | hasMoreWork = cb(true, currentTime);
|
79 | } while (hasMoreWork && !didStop);
|
80 | if (!hasMoreWork) {
|
81 | scheduledCallback = null;
|
82 | }
|
83 | } finally {
|
84 | expectedNumberOfYields = -1;
|
85 | didStop = false;
|
86 | isFlushing = false;
|
87 | }
|
88 | }
|
89 | }
|
90 |
|
91 | function unstable_flushUntilNextPaint() {
|
92 | if (isFlushing) {
|
93 | throw new Error('Already flushing work.');
|
94 | }
|
95 | if (scheduledCallback !== null) {
|
96 | var cb = scheduledCallback;
|
97 | shouldYieldForPaint = true;
|
98 | needsPaint = false;
|
99 | isFlushing = true;
|
100 | try {
|
101 | var hasMoreWork = true;
|
102 | do {
|
103 | hasMoreWork = cb(true, currentTime);
|
104 | } while (hasMoreWork && !didStop);
|
105 | if (!hasMoreWork) {
|
106 | scheduledCallback = null;
|
107 | }
|
108 | } finally {
|
109 | shouldYieldForPaint = false;
|
110 | didStop = false;
|
111 | isFlushing = false;
|
112 | }
|
113 | }
|
114 | }
|
115 |
|
116 | function unstable_flushExpired() {
|
117 | if (isFlushing) {
|
118 | throw new Error('Already flushing work.');
|
119 | }
|
120 | if (scheduledCallback !== null) {
|
121 | isFlushing = true;
|
122 | try {
|
123 | var hasMoreWork = scheduledCallback(false, currentTime);
|
124 | if (!hasMoreWork) {
|
125 | scheduledCallback = null;
|
126 | }
|
127 | } finally {
|
128 | isFlushing = false;
|
129 | }
|
130 | }
|
131 | }
|
132 |
|
133 | function unstable_flushAllWithoutAsserting() {
|
134 |
|
135 | if (isFlushing) {
|
136 | throw new Error('Already flushing work.');
|
137 | }
|
138 | if (scheduledCallback !== null) {
|
139 | var cb = scheduledCallback;
|
140 | isFlushing = true;
|
141 | try {
|
142 | var hasMoreWork = true;
|
143 | do {
|
144 | hasMoreWork = cb(true, currentTime);
|
145 | } while (hasMoreWork);
|
146 | if (!hasMoreWork) {
|
147 | scheduledCallback = null;
|
148 | }
|
149 | return true;
|
150 | } finally {
|
151 | isFlushing = false;
|
152 | }
|
153 | } else {
|
154 | return false;
|
155 | }
|
156 | }
|
157 |
|
158 | function unstable_clearYields() {
|
159 | if (yieldedValues === null) {
|
160 | return [];
|
161 | }
|
162 | var values = yieldedValues;
|
163 | yieldedValues = null;
|
164 | return values;
|
165 | }
|
166 |
|
167 | function unstable_flushAll() {
|
168 | if (yieldedValues !== null) {
|
169 | throw new Error('Log is not empty. Assert on the log of yielded values before ' + 'flushing additional work.');
|
170 | }
|
171 | unstable_flushAllWithoutAsserting();
|
172 | if (yieldedValues !== null) {
|
173 | throw new Error('While flushing work, something yielded a value. Use an ' + 'assertion helper to assert on the log of yielded values, e.g. ' + 'expect(Scheduler).toFlushAndYield([...])');
|
174 | }
|
175 | }
|
176 |
|
177 | function unstable_yieldValue(value) {
|
178 | if (yieldedValues === null) {
|
179 | yieldedValues = [value];
|
180 | } else {
|
181 | yieldedValues.push(value);
|
182 | }
|
183 | }
|
184 |
|
185 | function unstable_advanceTime(ms) {
|
186 | currentTime += ms;
|
187 | if (!isFlushing) {
|
188 | if (scheduledTimeout !== null && timeoutTime <= currentTime) {
|
189 | scheduledTimeout(currentTime);
|
190 | timeoutTime = -1;
|
191 | scheduledTimeout = null;
|
192 | }
|
193 | unstable_flushExpired();
|
194 | }
|
195 | }
|
196 |
|
197 | function requestPaint() {
|
198 | needsPaint = true;
|
199 | }
|
200 |
|
201 |
|
202 |
|
203 |
|
204 | var ImmediatePriority = 1;
|
205 | var UserBlockingPriority = 2;
|
206 | var NormalPriority = 3;
|
207 | var LowPriority = 4;
|
208 | var IdlePriority = 5;
|
209 |
|
210 |
|
211 |
|
212 |
|
213 | var maxSigned31BitInt = 1073741823;
|
214 |
|
215 |
|
216 | var IMMEDIATE_PRIORITY_TIMEOUT = -1;
|
217 |
|
218 | var USER_BLOCKING_PRIORITY = 250;
|
219 | var NORMAL_PRIORITY_TIMEOUT = 5000;
|
220 | var LOW_PRIORITY_TIMEOUT = 10000;
|
221 |
|
222 | var IDLE_PRIORITY = maxSigned31BitInt;
|
223 |
|
224 |
|
225 | var firstTask = null;
|
226 | var firstDelayedTask = null;
|
227 |
|
228 |
|
229 | var isSchedulerPaused = false;
|
230 |
|
231 | var currentTask = null;
|
232 | var currentPriorityLevel = NormalPriority;
|
233 |
|
234 |
|
235 | var isPerformingWork = false;
|
236 |
|
237 | var isHostCallbackScheduled = false;
|
238 | var isHostTimeoutScheduled = false;
|
239 |
|
240 | function scheduler_flushTaskAtPriority_Immediate(callback, didTimeout) {
|
241 | return callback(didTimeout);
|
242 | }
|
243 | function scheduler_flushTaskAtPriority_UserBlocking(callback, didTimeout) {
|
244 | return callback(didTimeout);
|
245 | }
|
246 | function scheduler_flushTaskAtPriority_Normal(callback, didTimeout) {
|
247 | return callback(didTimeout);
|
248 | }
|
249 | function scheduler_flushTaskAtPriority_Low(callback, didTimeout) {
|
250 | return callback(didTimeout);
|
251 | }
|
252 | function scheduler_flushTaskAtPriority_Idle(callback, didTimeout) {
|
253 | return callback(didTimeout);
|
254 | }
|
255 |
|
256 | function flushTask(task, currentTime) {
|
257 |
|
258 |
|
259 | var next = task.next;
|
260 | if (next === task) {
|
261 |
|
262 | firstTask = null;
|
263 | } else {
|
264 |
|
265 | if (task === firstTask) {
|
266 | firstTask = next;
|
267 | }
|
268 | var previous = task.previous;
|
269 | previous.next = next;
|
270 | next.previous = previous;
|
271 | }
|
272 | task.next = task.previous = null;
|
273 |
|
274 |
|
275 | var callback = task.callback;
|
276 | var previousPriorityLevel = currentPriorityLevel;
|
277 | var previousTask = currentTask;
|
278 | currentPriorityLevel = task.priorityLevel;
|
279 | currentTask = task;
|
280 | var continuationCallback;
|
281 | try {
|
282 | var didUserCallbackTimeout = task.expirationTime <= currentTime;
|
283 |
|
284 |
|
285 | switch (currentPriorityLevel) {
|
286 | case ImmediatePriority:
|
287 | continuationCallback = scheduler_flushTaskAtPriority_Immediate(callback, didUserCallbackTimeout);
|
288 | break;
|
289 | case UserBlockingPriority:
|
290 | continuationCallback = scheduler_flushTaskAtPriority_UserBlocking(callback, didUserCallbackTimeout);
|
291 | break;
|
292 | case NormalPriority:
|
293 | continuationCallback = scheduler_flushTaskAtPriority_Normal(callback, didUserCallbackTimeout);
|
294 | break;
|
295 | case LowPriority:
|
296 | continuationCallback = scheduler_flushTaskAtPriority_Low(callback, didUserCallbackTimeout);
|
297 | break;
|
298 | case IdlePriority:
|
299 | continuationCallback = scheduler_flushTaskAtPriority_Idle(callback, didUserCallbackTimeout);
|
300 | break;
|
301 | }
|
302 | } catch (error) {
|
303 | throw error;
|
304 | } finally {
|
305 | currentPriorityLevel = previousPriorityLevel;
|
306 | currentTask = previousTask;
|
307 | }
|
308 |
|
309 |
|
310 |
|
311 | if (typeof continuationCallback === 'function') {
|
312 | var expirationTime = task.expirationTime;
|
313 | var continuationTask = task;
|
314 | continuationTask.callback = continuationCallback;
|
315 |
|
316 |
|
317 |
|
318 |
|
319 |
|
320 | if (firstTask === null) {
|
321 |
|
322 | firstTask = continuationTask.next = continuationTask.previous = continuationTask;
|
323 | } else {
|
324 | var nextAfterContinuation = null;
|
325 | var t = firstTask;
|
326 | do {
|
327 | if (expirationTime <= t.expirationTime) {
|
328 |
|
329 |
|
330 | nextAfterContinuation = t;
|
331 | break;
|
332 | }
|
333 | t = t.next;
|
334 | } while (t !== firstTask);
|
335 | if (nextAfterContinuation === null) {
|
336 |
|
337 |
|
338 | nextAfterContinuation = firstTask;
|
339 | } else if (nextAfterContinuation === firstTask) {
|
340 |
|
341 | firstTask = continuationTask;
|
342 | }
|
343 |
|
344 | var _previous = nextAfterContinuation.previous;
|
345 | _previous.next = nextAfterContinuation.previous = continuationTask;
|
346 | continuationTask.next = nextAfterContinuation;
|
347 | continuationTask.previous = _previous;
|
348 | }
|
349 | }
|
350 | }
|
351 |
|
352 | function advanceTimers(currentTime) {
|
353 |
|
354 | if (firstDelayedTask !== null && firstDelayedTask.startTime <= currentTime) {
|
355 | do {
|
356 | var task = firstDelayedTask;
|
357 | var next = task.next;
|
358 | if (task === next) {
|
359 | firstDelayedTask = null;
|
360 | } else {
|
361 | firstDelayedTask = next;
|
362 | var previous = task.previous;
|
363 | previous.next = next;
|
364 | next.previous = previous;
|
365 | }
|
366 | task.next = task.previous = null;
|
367 | insertScheduledTask(task, task.expirationTime);
|
368 | } while (firstDelayedTask !== null && firstDelayedTask.startTime <= currentTime);
|
369 | }
|
370 | }
|
371 |
|
372 | function handleTimeout(currentTime) {
|
373 | isHostTimeoutScheduled = false;
|
374 | advanceTimers(currentTime);
|
375 |
|
376 | if (!isHostCallbackScheduled) {
|
377 | if (firstTask !== null) {
|
378 | isHostCallbackScheduled = true;
|
379 | requestHostCallback(flushWork);
|
380 | } else if (firstDelayedTask !== null) {
|
381 | requestHostTimeout(handleTimeout, firstDelayedTask.startTime - currentTime);
|
382 | }
|
383 | }
|
384 | }
|
385 |
|
386 | function flushWork(hasTimeRemaining, initialTime) {
|
387 |
|
388 | if (enableSchedulerDebugging && isSchedulerPaused) {
|
389 | return;
|
390 | }
|
391 |
|
392 |
|
393 | isHostCallbackScheduled = false;
|
394 | if (isHostTimeoutScheduled) {
|
395 |
|
396 | isHostTimeoutScheduled = false;
|
397 | cancelHostTimeout();
|
398 | }
|
399 |
|
400 | var currentTime = initialTime;
|
401 | advanceTimers(currentTime);
|
402 |
|
403 | isPerformingWork = true;
|
404 | try {
|
405 | if (!hasTimeRemaining) {
|
406 |
|
407 |
|
408 |
|
409 | while (firstTask !== null && firstTask.expirationTime <= currentTime && !(enableSchedulerDebugging && isSchedulerPaused)) {
|
410 | flushTask(firstTask, currentTime);
|
411 | currentTime = getCurrentTime();
|
412 | advanceTimers(currentTime);
|
413 | }
|
414 | } else {
|
415 |
|
416 | if (firstTask !== null) {
|
417 | do {
|
418 | flushTask(firstTask, currentTime);
|
419 | currentTime = getCurrentTime();
|
420 | advanceTimers(currentTime);
|
421 | } while (firstTask !== null && !shouldYieldToHost() && !(enableSchedulerDebugging && isSchedulerPaused));
|
422 | }
|
423 | }
|
424 |
|
425 | if (firstTask !== null) {
|
426 | return true;
|
427 | } else {
|
428 | if (firstDelayedTask !== null) {
|
429 | requestHostTimeout(handleTimeout, firstDelayedTask.startTime - currentTime);
|
430 | }
|
431 | return false;
|
432 | }
|
433 | } finally {
|
434 | isPerformingWork = false;
|
435 | }
|
436 | }
|
437 |
|
438 | function unstable_runWithPriority(priorityLevel, eventHandler) {
|
439 | switch (priorityLevel) {
|
440 | case ImmediatePriority:
|
441 | case UserBlockingPriority:
|
442 | case NormalPriority:
|
443 | case LowPriority:
|
444 | case IdlePriority:
|
445 | break;
|
446 | default:
|
447 | priorityLevel = NormalPriority;
|
448 | }
|
449 |
|
450 | var previousPriorityLevel = currentPriorityLevel;
|
451 | currentPriorityLevel = priorityLevel;
|
452 |
|
453 | try {
|
454 | return eventHandler();
|
455 | } finally {
|
456 | currentPriorityLevel = previousPriorityLevel;
|
457 | }
|
458 | }
|
459 |
|
460 | function unstable_next(eventHandler) {
|
461 | var priorityLevel;
|
462 | switch (currentPriorityLevel) {
|
463 | case ImmediatePriority:
|
464 | case UserBlockingPriority:
|
465 | case NormalPriority:
|
466 |
|
467 | priorityLevel = NormalPriority;
|
468 | break;
|
469 | default:
|
470 |
|
471 | priorityLevel = currentPriorityLevel;
|
472 | break;
|
473 | }
|
474 |
|
475 | var previousPriorityLevel = currentPriorityLevel;
|
476 | currentPriorityLevel = priorityLevel;
|
477 |
|
478 | try {
|
479 | return eventHandler();
|
480 | } finally {
|
481 | currentPriorityLevel = previousPriorityLevel;
|
482 | }
|
483 | }
|
484 |
|
485 | function unstable_wrapCallback(callback) {
|
486 | var parentPriorityLevel = currentPriorityLevel;
|
487 | return function () {
|
488 |
|
489 | var previousPriorityLevel = currentPriorityLevel;
|
490 | currentPriorityLevel = parentPriorityLevel;
|
491 |
|
492 | try {
|
493 | return callback.apply(this, arguments);
|
494 | } finally {
|
495 | currentPriorityLevel = previousPriorityLevel;
|
496 | }
|
497 | };
|
498 | }
|
499 |
|
500 | function timeoutForPriorityLevel(priorityLevel) {
|
501 | switch (priorityLevel) {
|
502 | case ImmediatePriority:
|
503 | return IMMEDIATE_PRIORITY_TIMEOUT;
|
504 | case UserBlockingPriority:
|
505 | return USER_BLOCKING_PRIORITY;
|
506 | case IdlePriority:
|
507 | return IDLE_PRIORITY;
|
508 | case LowPriority:
|
509 | return LOW_PRIORITY_TIMEOUT;
|
510 | case NormalPriority:
|
511 | default:
|
512 | return NORMAL_PRIORITY_TIMEOUT;
|
513 | }
|
514 | }
|
515 |
|
516 | function unstable_scheduleCallback(priorityLevel, callback, options) {
|
517 | var currentTime = getCurrentTime();
|
518 |
|
519 | var startTime;
|
520 | var timeout;
|
521 | if (typeof options === 'object' && options !== null) {
|
522 | var delay = options.delay;
|
523 | if (typeof delay === 'number' && delay > 0) {
|
524 | startTime = currentTime + delay;
|
525 | } else {
|
526 | startTime = currentTime;
|
527 | }
|
528 | timeout = typeof options.timeout === 'number' ? options.timeout : timeoutForPriorityLevel(priorityLevel);
|
529 | } else {
|
530 | timeout = timeoutForPriorityLevel(priorityLevel);
|
531 | startTime = currentTime;
|
532 | }
|
533 |
|
534 | var expirationTime = startTime + timeout;
|
535 |
|
536 | var newTask = {
|
537 | callback: callback,
|
538 | priorityLevel: priorityLevel,
|
539 | startTime: startTime,
|
540 | expirationTime: expirationTime,
|
541 | next: null,
|
542 | previous: null
|
543 | };
|
544 |
|
545 | if (startTime > currentTime) {
|
546 |
|
547 | insertDelayedTask(newTask, startTime);
|
548 | if (firstTask === null && firstDelayedTask === newTask) {
|
549 |
|
550 | if (isHostTimeoutScheduled) {
|
551 |
|
552 | cancelHostTimeout();
|
553 | } else {
|
554 | isHostTimeoutScheduled = true;
|
555 | }
|
556 |
|
557 | requestHostTimeout(handleTimeout, startTime - currentTime);
|
558 | }
|
559 | } else {
|
560 | insertScheduledTask(newTask, expirationTime);
|
561 |
|
562 |
|
563 | if (!isHostCallbackScheduled && !isPerformingWork) {
|
564 | isHostCallbackScheduled = true;
|
565 | requestHostCallback(flushWork);
|
566 | }
|
567 | }
|
568 |
|
569 | return newTask;
|
570 | }
|
571 |
|
572 | function insertScheduledTask(newTask, expirationTime) {
|
573 |
|
574 |
|
575 |
|
576 | if (firstTask === null) {
|
577 |
|
578 | firstTask = newTask.next = newTask.previous = newTask;
|
579 | } else {
|
580 | var next = null;
|
581 | var task = firstTask;
|
582 | do {
|
583 | if (expirationTime < task.expirationTime) {
|
584 |
|
585 | next = task;
|
586 | break;
|
587 | }
|
588 | task = task.next;
|
589 | } while (task !== firstTask);
|
590 |
|
591 | if (next === null) {
|
592 |
|
593 |
|
594 | next = firstTask;
|
595 | } else if (next === firstTask) {
|
596 |
|
597 | firstTask = newTask;
|
598 | }
|
599 |
|
600 | var previous = next.previous;
|
601 | previous.next = next.previous = newTask;
|
602 | newTask.next = next;
|
603 | newTask.previous = previous;
|
604 | }
|
605 | }
|
606 |
|
607 | function insertDelayedTask(newTask, startTime) {
|
608 |
|
609 | if (firstDelayedTask === null) {
|
610 |
|
611 | firstDelayedTask = newTask.next = newTask.previous = newTask;
|
612 | } else {
|
613 | var next = null;
|
614 | var task = firstDelayedTask;
|
615 | do {
|
616 | if (startTime < task.startTime) {
|
617 |
|
618 | next = task;
|
619 | break;
|
620 | }
|
621 | task = task.next;
|
622 | } while (task !== firstDelayedTask);
|
623 |
|
624 | if (next === null) {
|
625 |
|
626 |
|
627 | next = firstDelayedTask;
|
628 | } else if (next === firstDelayedTask) {
|
629 |
|
630 | firstDelayedTask = newTask;
|
631 | }
|
632 |
|
633 | var previous = next.previous;
|
634 | previous.next = next.previous = newTask;
|
635 | newTask.next = next;
|
636 | newTask.previous = previous;
|
637 | }
|
638 | }
|
639 |
|
640 | function unstable_pauseExecution() {
|
641 | isSchedulerPaused = true;
|
642 | }
|
643 |
|
644 | function unstable_continueExecution() {
|
645 | isSchedulerPaused = false;
|
646 | if (!isHostCallbackScheduled && !isPerformingWork) {
|
647 | isHostCallbackScheduled = true;
|
648 | requestHostCallback(flushWork);
|
649 | }
|
650 | }
|
651 |
|
652 | function unstable_getFirstCallbackNode() {
|
653 | return firstTask;
|
654 | }
|
655 |
|
656 | function unstable_cancelCallback(task) {
|
657 | var next = task.next;
|
658 | if (next === null) {
|
659 |
|
660 | return;
|
661 | }
|
662 |
|
663 | if (task === next) {
|
664 | if (task === firstTask) {
|
665 | firstTask = null;
|
666 | } else if (task === firstDelayedTask) {
|
667 | firstDelayedTask = null;
|
668 | }
|
669 | } else {
|
670 | if (task === firstTask) {
|
671 | firstTask = next;
|
672 | } else if (task === firstDelayedTask) {
|
673 | firstDelayedTask = next;
|
674 | }
|
675 | var previous = task.previous;
|
676 | previous.next = next;
|
677 | next.previous = previous;
|
678 | }
|
679 |
|
680 | task.next = task.previous = null;
|
681 | }
|
682 |
|
683 | function unstable_getCurrentPriorityLevel() {
|
684 | return currentPriorityLevel;
|
685 | }
|
686 |
|
687 | function unstable_shouldYield() {
|
688 | var currentTime = getCurrentTime();
|
689 | advanceTimers(currentTime);
|
690 | return currentTask !== null && firstTask !== null && firstTask.startTime <= currentTime && firstTask.expirationTime < currentTask.expirationTime || shouldYieldToHost();
|
691 | }
|
692 |
|
693 | var unstable_requestPaint = requestPaint;
|
694 |
|
695 | exports.unstable_flushAllWithoutAsserting = unstable_flushAllWithoutAsserting;
|
696 | exports.unstable_flushNumberOfYields = unstable_flushNumberOfYields;
|
697 | exports.unstable_flushExpired = unstable_flushExpired;
|
698 | exports.unstable_clearYields = unstable_clearYields;
|
699 | exports.unstable_flushUntilNextPaint = unstable_flushUntilNextPaint;
|
700 | exports.unstable_flushAll = unstable_flushAll;
|
701 | exports.unstable_yieldValue = unstable_yieldValue;
|
702 | exports.unstable_advanceTime = unstable_advanceTime;
|
703 | exports.unstable_ImmediatePriority = ImmediatePriority;
|
704 | exports.unstable_UserBlockingPriority = UserBlockingPriority;
|
705 | exports.unstable_NormalPriority = NormalPriority;
|
706 | exports.unstable_IdlePriority = IdlePriority;
|
707 | exports.unstable_LowPriority = LowPriority;
|
708 | exports.unstable_runWithPriority = unstable_runWithPriority;
|
709 | exports.unstable_next = unstable_next;
|
710 | exports.unstable_scheduleCallback = unstable_scheduleCallback;
|
711 | exports.unstable_cancelCallback = unstable_cancelCallback;
|
712 | exports.unstable_wrapCallback = unstable_wrapCallback;
|
713 | exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
|
714 | exports.unstable_shouldYield = unstable_shouldYield;
|
715 | exports.unstable_requestPaint = unstable_requestPaint;
|
716 | exports.unstable_continueExecution = unstable_continueExecution;
|
717 | exports.unstable_pauseExecution = unstable_pauseExecution;
|
718 | exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode;
|
719 | exports.unstable_now = getCurrentTime;
|
720 | exports.unstable_forceFrameRate = forceFrameRate;
|
721 |
|
722 | Object.defineProperty(exports, '__esModule', { value: true });
|
723 |
|
724 | })));
|