Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
scheduler
Advanced tools
scheduler - npm Package Compare versions
Comparing version 0.25.0-rc-6230622a1a-20240610 to 0.25.0-rc-64f89510-20241119
@@ -11,702 +11,414 @@ /** | ||
| 'use strict'; | ||
| if (process.env.NODE_ENV !== "production") { | ||
| (function() { | ||
| 'use strict'; | ||
| var enableSchedulerDebugging = false; | ||
| var enableProfiling = false; | ||
| function push(heap, node) { | ||
| var index = heap.length; | ||
| heap.push(node); | ||
| siftUp(heap, node, index); | ||
| } | ||
| function peek(heap) { | ||
| return heap.length === 0 ? null : heap[0]; | ||
| } | ||
| function pop(heap) { | ||
| if (heap.length === 0) { | ||
| return null; | ||
| } | ||
| var first = heap[0]; | ||
| var last = heap.pop(); | ||
| if (last !== first) { | ||
| heap[0] = last; | ||
| siftDown(heap, last, 0); | ||
| } | ||
| return first; | ||
| } | ||
| function siftUp(heap, node, i) { | ||
| var index = i; | ||
| while (index > 0) { | ||
| var parentIndex = index - 1 >>> 1; | ||
| var parent = heap[parentIndex]; | ||
| if (compare(parent, node) > 0) { | ||
| // The parent is larger. Swap positions. | ||
| heap[parentIndex] = node; | ||
| heap[index] = parent; | ||
| index = parentIndex; | ||
| } else { | ||
| // The parent is smaller. Exit. | ||
| return; | ||
| "use strict"; | ||
| "production" !== process.env.NODE_ENV && | ||
| (function () { | ||
| function push(heap, node) { | ||
| var index = heap.length; | ||
| heap.push(node); | ||
| a: for (; 0 < index; ) { | ||
| var parentIndex = (index - 1) >>> 1, | ||
| parent = heap[parentIndex]; | ||
| if (0 < compare(parent, node)) | ||
| (heap[parentIndex] = node), | ||
| (heap[index] = parent), | ||
| (index = parentIndex); | ||
| else break a; | ||
| } | ||
| } | ||
| } | ||
| } | ||
| function peek(heap) { | ||
| return 0 === heap.length ? null : heap[0]; | ||
| } | ||
| function pop(heap) { | ||
| if (0 === heap.length) return null; | ||
| var first = heap[0], | ||
| last = heap.pop(); | ||
| if (last !== first) { | ||
| heap[0] = last; | ||
| a: for ( | ||
| var index = 0, length = heap.length, halfLength = length >>> 1; | ||
| index < halfLength; | ||
| function siftDown(heap, node, i) { | ||
| var index = i; | ||
| var length = heap.length; | ||
| var halfLength = length >>> 1; | ||
| while (index < halfLength) { | ||
| var leftIndex = (index + 1) * 2 - 1; | ||
| var left = heap[leftIndex]; | ||
| var rightIndex = leftIndex + 1; | ||
| var right = heap[rightIndex]; // If the left or right node is smaller, swap with the smaller of those. | ||
| if (compare(left, node) < 0) { | ||
| if (rightIndex < length && compare(right, left) < 0) { | ||
| heap[index] = right; | ||
| heap[rightIndex] = node; | ||
| index = rightIndex; | ||
| } else { | ||
| heap[index] = left; | ||
| heap[leftIndex] = node; | ||
| index = leftIndex; | ||
| ) { | ||
| var leftIndex = 2 * (index + 1) - 1, | ||
| left = heap[leftIndex], | ||
| rightIndex = leftIndex + 1, | ||
| right = heap[rightIndex]; | ||
| if (0 > compare(left, last)) | ||
| rightIndex < length && 0 > compare(right, left) | ||
| ? ((heap[index] = right), | ||
| (heap[rightIndex] = last), | ||
| (index = rightIndex)) | ||
| : ((heap[index] = left), | ||
| (heap[leftIndex] = last), | ||
| (index = leftIndex)); | ||
| else if (rightIndex < length && 0 > compare(right, last)) | ||
| (heap[index] = right), | ||
| (heap[rightIndex] = last), | ||
| (index = rightIndex); | ||
| else break a; | ||
| } | ||
| } | ||
| } else if (rightIndex < length && compare(right, node) < 0) { | ||
| heap[index] = right; | ||
| heap[rightIndex] = node; | ||
| index = rightIndex; | ||
| } else { | ||
| // Neither child is smaller. Exit. | ||
| return; | ||
| return first; | ||
| } | ||
| } | ||
| } | ||
| function compare(a, b) { | ||
| // Compare sort index first, then task id. | ||
| var diff = a.sortIndex - b.sortIndex; | ||
| return diff !== 0 ? diff : a.id - b.id; | ||
| } | ||
| // TODO: Use symbols? | ||
| var ImmediatePriority = 1; | ||
| var UserBlockingPriority = 2; | ||
| var NormalPriority = 3; | ||
| var LowPriority = 4; | ||
| var IdlePriority = 5; | ||
| function markTaskErrored(task, ms) { | ||
| } | ||
| /* eslint-disable no-var */ | ||
| // Math.pow(2, 30) - 1 | ||
| // 0b111111111111111111111111111111 | ||
| var maxSigned31BitInt = 1073741823; // Times out immediately | ||
| var IMMEDIATE_PRIORITY_TIMEOUT = -1; // Eventually times out | ||
| var USER_BLOCKING_PRIORITY_TIMEOUT = 250; | ||
| var NORMAL_PRIORITY_TIMEOUT = 5000; | ||
| var LOW_PRIORITY_TIMEOUT = 10000; // Never times out | ||
| var IDLE_PRIORITY_TIMEOUT = maxSigned31BitInt; // Tasks are stored on a min heap | ||
| var taskQueue = []; | ||
| var timerQueue = []; // Incrementing id counter. Used to maintain insertion order. | ||
| var taskIdCounter = 1; // Pausing the scheduler is useful for debugging. | ||
| var currentTask = null; | ||
| var currentPriorityLevel = NormalPriority; // This is set while performing work, to prevent re-entrance. | ||
| var isPerformingWork = false; | ||
| var isHostCallbackScheduled = false; | ||
| var isHostTimeoutScheduled = false; | ||
| var currentMockTime = 0; | ||
| var scheduledCallback = null; | ||
| var scheduledTimeout = null; | ||
| var timeoutTime = -1; | ||
| var yieldedValues = null; | ||
| var expectedNumberOfYields = -1; | ||
| var didStop = false; | ||
| var isFlushing = false; | ||
| var needsPaint = false; | ||
| var shouldYieldForPaint = false; | ||
| var disableYieldValue = false; | ||
| function setDisableYieldValue(newValue) { | ||
| disableYieldValue = newValue; | ||
| } | ||
| function advanceTimers(currentTime) { | ||
| // Check for tasks that are no longer delayed and add them to the queue. | ||
| var timer = peek(timerQueue); | ||
| while (timer !== null) { | ||
| if (timer.callback === null) { | ||
| // Timer was cancelled. | ||
| pop(timerQueue); | ||
| } else if (timer.startTime <= currentTime) { | ||
| // Timer fired. Transfer to the task queue. | ||
| pop(timerQueue); | ||
| timer.sortIndex = timer.expirationTime; | ||
| push(taskQueue, timer); | ||
| } else { | ||
| // Remaining timers are pending. | ||
| return; | ||
| function compare(a, b) { | ||
| var diff = a.sortIndex - b.sortIndex; | ||
| return 0 !== diff ? diff : a.id - b.id; | ||
| } | ||
| timer = peek(timerQueue); | ||
| } | ||
| } | ||
| function handleTimeout(currentTime) { | ||
| isHostTimeoutScheduled = false; | ||
| advanceTimers(currentTime); | ||
| if (!isHostCallbackScheduled) { | ||
| if (peek(taskQueue) !== null) { | ||
| isHostCallbackScheduled = true; | ||
| requestHostCallback(flushWork); | ||
| } else { | ||
| var firstTimer = peek(timerQueue); | ||
| if (firstTimer !== null) { | ||
| requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime); | ||
| function advanceTimers(currentTime) { | ||
| for (var timer = peek(timerQueue); null !== timer; ) { | ||
| if (null === timer.callback) pop(timerQueue); | ||
| else if (timer.startTime <= currentTime) | ||
| pop(timerQueue), | ||
| (timer.sortIndex = timer.expirationTime), | ||
| push(taskQueue, timer); | ||
| else break; | ||
| timer = peek(timerQueue); | ||
| } | ||
| } | ||
| } | ||
| } | ||
| function flushWork(hasTimeRemaining, initialTime) { | ||
| isHostCallbackScheduled = false; | ||
| if (isHostTimeoutScheduled) { | ||
| // We scheduled a timeout but it's no longer needed. Cancel it. | ||
| isHostTimeoutScheduled = false; | ||
| cancelHostTimeout(); | ||
| } | ||
| isPerformingWork = true; | ||
| var previousPriorityLevel = currentPriorityLevel; | ||
| try { | ||
| var currentTime; if (enableProfiling) ; else { | ||
| // No catch in prod code path. | ||
| return workLoop(hasTimeRemaining, initialTime); | ||
| function handleTimeout(currentTime) { | ||
| isHostTimeoutScheduled = !1; | ||
| advanceTimers(currentTime); | ||
| if (!isHostCallbackScheduled) | ||
| if (null !== peek(taskQueue)) | ||
| (isHostCallbackScheduled = !0), (scheduledCallback = flushWork); | ||
| else { | ||
| var firstTimer = peek(timerQueue); | ||
| null !== firstTimer && | ||
| ((currentTime = firstTimer.startTime - currentTime), | ||
| (scheduledTimeout = handleTimeout), | ||
| (timeoutTime = currentMockTime + currentTime)); | ||
| } | ||
| } | ||
| } finally { | ||
| currentTask = null; | ||
| currentPriorityLevel = previousPriorityLevel; | ||
| isPerformingWork = false; | ||
| } | ||
| } | ||
| function flushWork(hasTimeRemaining, initialTime) { | ||
| isHostCallbackScheduled = !1; | ||
| isHostTimeoutScheduled && | ||
| ((isHostTimeoutScheduled = !1), | ||
| (scheduledTimeout = null), | ||
| (timeoutTime = -1)); | ||
| isPerformingWork = !0; | ||
| var previousPriorityLevel = currentPriorityLevel; | ||
| try { | ||
| a: { | ||
| advanceTimers(initialTime); | ||
| for ( | ||
| currentTask = peek(taskQueue); | ||
| null !== currentTask && | ||
| (!(currentTask.expirationTime > initialTime) || | ||
| (hasTimeRemaining && !shouldYieldToHost())); | ||
| function workLoop(hasTimeRemaining, initialTime) { | ||
| var currentTime = initialTime; | ||
| advanceTimers(currentTime); | ||
| currentTask = peek(taskQueue); | ||
| while (currentTask !== null && !(enableSchedulerDebugging )) { | ||
| if (currentTask.expirationTime > currentTime && (!hasTimeRemaining || shouldYieldToHost())) { | ||
| // This currentTask hasn't expired, and we've reached the deadline. | ||
| break; | ||
| } // $FlowFixMe[incompatible-use] found when upgrading Flow | ||
| var callback = currentTask.callback; | ||
| if (typeof callback === 'function') { | ||
| // $FlowFixMe[incompatible-use] found when upgrading Flow | ||
| currentTask.callback = null; // $FlowFixMe[incompatible-use] found when upgrading Flow | ||
| currentPriorityLevel = currentTask.priorityLevel; // $FlowFixMe[incompatible-use] found when upgrading Flow | ||
| var didUserCallbackTimeout = currentTask.expirationTime <= currentTime; | ||
| var continuationCallback = callback(didUserCallbackTimeout); | ||
| currentTime = getCurrentTime(); | ||
| if (typeof continuationCallback === 'function') { | ||
| // If a continuation is returned, immediately yield to the main thread | ||
| // regardless of how much time is left in the current time slice. | ||
| // $FlowFixMe[incompatible-use] found when upgrading Flow | ||
| currentTask.callback = continuationCallback; | ||
| advanceTimers(currentTime); | ||
| if (shouldYieldForPaint) { | ||
| needsPaint = true; | ||
| return true; | ||
| ) { | ||
| var callback = currentTask.callback; | ||
| if ("function" === typeof callback) { | ||
| currentTask.callback = null; | ||
| currentPriorityLevel = currentTask.priorityLevel; | ||
| var continuationCallback = callback( | ||
| currentTask.expirationTime <= initialTime | ||
| ); | ||
| initialTime = currentMockTime; | ||
| if ("function" === typeof continuationCallback) { | ||
| if ( | ||
| ((currentTask.callback = continuationCallback), | ||
| advanceTimers(initialTime), | ||
| shouldYieldForPaint) | ||
| ) { | ||
| var JSCompiler_inline_result = (needsPaint = !0); | ||
| break a; | ||
| } | ||
| } else | ||
| currentTask === peek(taskQueue) && pop(taskQueue), | ||
| advanceTimers(initialTime); | ||
| } else pop(taskQueue); | ||
| currentTask = peek(taskQueue); | ||
| } | ||
| if (null !== currentTask) JSCompiler_inline_result = !0; | ||
| else { | ||
| var firstTimer = peek(timerQueue); | ||
| if (null !== firstTimer) { | ||
| var ms = firstTimer.startTime - initialTime; | ||
| scheduledTimeout = handleTimeout; | ||
| timeoutTime = currentMockTime + ms; | ||
| } | ||
| JSCompiler_inline_result = !1; | ||
| } | ||
| } | ||
| } else { | ||
| if (currentTask === peek(taskQueue)) { | ||
| pop(taskQueue); | ||
| } | ||
| advanceTimers(currentTime); | ||
| return JSCompiler_inline_result; | ||
| } finally { | ||
| (currentTask = null), | ||
| (currentPriorityLevel = previousPriorityLevel), | ||
| (isPerformingWork = !1); | ||
| } | ||
| } else { | ||
| pop(taskQueue); | ||
| } | ||
| currentTask = peek(taskQueue); | ||
| } // Return whether there's additional work | ||
| if (currentTask !== null) { | ||
| return true; | ||
| } else { | ||
| var firstTimer = peek(timerQueue); | ||
| if (firstTimer !== null) { | ||
| requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime); | ||
| function shouldYieldToHost() { | ||
| return (0 === expectedNumberOfYields && null === yieldedValues) || | ||
| (-1 !== expectedNumberOfYields && | ||
| null !== yieldedValues && | ||
| yieldedValues.length >= expectedNumberOfYields) || | ||
| (shouldYieldForPaint && needsPaint) | ||
| ? (didStop = !0) | ||
| : !1; | ||
| } | ||
| return false; | ||
| } | ||
| } | ||
| function unstable_runWithPriority(priorityLevel, eventHandler) { | ||
| switch (priorityLevel) { | ||
| case ImmediatePriority: | ||
| case UserBlockingPriority: | ||
| case NormalPriority: | ||
| case LowPriority: | ||
| case IdlePriority: | ||
| break; | ||
| default: | ||
| priorityLevel = NormalPriority; | ||
| } | ||
| var previousPriorityLevel = currentPriorityLevel; | ||
| currentPriorityLevel = priorityLevel; | ||
| try { | ||
| return eventHandler(); | ||
| } finally { | ||
| currentPriorityLevel = previousPriorityLevel; | ||
| } | ||
| } | ||
| function unstable_next(eventHandler) { | ||
| var priorityLevel; | ||
| switch (currentPriorityLevel) { | ||
| case ImmediatePriority: | ||
| case UserBlockingPriority: | ||
| case NormalPriority: | ||
| // Shift down to normal priority | ||
| priorityLevel = NormalPriority; | ||
| break; | ||
| default: | ||
| // Anything lower than normal priority should remain at the current level. | ||
| priorityLevel = currentPriorityLevel; | ||
| break; | ||
| } | ||
| var previousPriorityLevel = currentPriorityLevel; | ||
| currentPriorityLevel = priorityLevel; | ||
| try { | ||
| return eventHandler(); | ||
| } finally { | ||
| currentPriorityLevel = previousPriorityLevel; | ||
| } | ||
| } | ||
| function unstable_wrapCallback(callback) { | ||
| var parentPriorityLevel = currentPriorityLevel; // $FlowFixMe[incompatible-return] | ||
| // $FlowFixMe[missing-this-annot] | ||
| return function () { | ||
| // This is a fork of runWithPriority, inlined for performance. | ||
| var previousPriorityLevel = currentPriorityLevel; | ||
| currentPriorityLevel = parentPriorityLevel; | ||
| try { | ||
| return callback.apply(this, arguments); | ||
| } finally { | ||
| currentPriorityLevel = previousPriorityLevel; | ||
| function unstable_flushAllWithoutAsserting() { | ||
| if (isFlushing) throw Error("Already flushing work."); | ||
| if (null !== scheduledCallback) { | ||
| var cb = scheduledCallback; | ||
| isFlushing = !0; | ||
| try { | ||
| var hasMoreWork = !0; | ||
| do hasMoreWork = cb(!0, currentMockTime); | ||
| while (hasMoreWork); | ||
| hasMoreWork || (scheduledCallback = null); | ||
| return !0; | ||
| } finally { | ||
| isFlushing = !1; | ||
| } | ||
| } else return !1; | ||
| } | ||
| }; | ||
| } | ||
| function unstable_scheduleCallback(priorityLevel, callback, options) { | ||
| var currentTime = getCurrentTime(); | ||
| var startTime; | ||
| if (typeof options === 'object' && options !== null) { | ||
| var delay = options.delay; | ||
| if (typeof delay === 'number' && delay > 0) { | ||
| startTime = currentTime + delay; | ||
| } else { | ||
| startTime = currentTime; | ||
| } | ||
| } else { | ||
| startTime = currentTime; | ||
| } | ||
| var timeout; | ||
| switch (priorityLevel) { | ||
| case ImmediatePriority: | ||
| timeout = IMMEDIATE_PRIORITY_TIMEOUT; | ||
| break; | ||
| case UserBlockingPriority: | ||
| timeout = USER_BLOCKING_PRIORITY_TIMEOUT; | ||
| break; | ||
| case IdlePriority: | ||
| timeout = IDLE_PRIORITY_TIMEOUT; | ||
| break; | ||
| case LowPriority: | ||
| timeout = LOW_PRIORITY_TIMEOUT; | ||
| break; | ||
| case NormalPriority: | ||
| default: | ||
| timeout = NORMAL_PRIORITY_TIMEOUT; | ||
| break; | ||
| } | ||
| var expirationTime = startTime + timeout; | ||
| var newTask = { | ||
| id: taskIdCounter++, | ||
| callback: callback, | ||
| priorityLevel: priorityLevel, | ||
| startTime: startTime, | ||
| expirationTime: expirationTime, | ||
| sortIndex: -1 | ||
| }; | ||
| if (startTime > currentTime) { | ||
| // This is a delayed task. | ||
| newTask.sortIndex = startTime; | ||
| push(timerQueue, newTask); | ||
| if (peek(taskQueue) === null && newTask === peek(timerQueue)) { | ||
| // All tasks are delayed, and this is the task with the earliest delay. | ||
| if (isHostTimeoutScheduled) { | ||
| // Cancel an existing timeout. | ||
| cancelHostTimeout(); | ||
| } else { | ||
| isHostTimeoutScheduled = true; | ||
| } // Schedule a timeout. | ||
| requestHostTimeout(handleTimeout, startTime - currentTime); | ||
| } | ||
| } else { | ||
| newTask.sortIndex = expirationTime; | ||
| push(taskQueue, newTask); | ||
| // wait until the next time we yield. | ||
| if (!isHostCallbackScheduled && !isPerformingWork) { | ||
| isHostCallbackScheduled = true; | ||
| requestHostCallback(flushWork); | ||
| } | ||
| } | ||
| return newTask; | ||
| } | ||
| function unstable_pauseExecution() { | ||
| } | ||
| function unstable_continueExecution() { | ||
| if (!isHostCallbackScheduled && !isPerformingWork) { | ||
| isHostCallbackScheduled = true; | ||
| requestHostCallback(flushWork); | ||
| } | ||
| } | ||
| function unstable_getFirstCallbackNode() { | ||
| return peek(taskQueue); | ||
| } | ||
| function unstable_cancelCallback(task) { | ||
| // remove from the queue because you can't remove arbitrary nodes from an | ||
| // array based heap, only the first one.) | ||
| task.callback = null; | ||
| } | ||
| function unstable_getCurrentPriorityLevel() { | ||
| return currentPriorityLevel; | ||
| } | ||
| function requestHostCallback(callback) { | ||
| scheduledCallback = callback; | ||
| } | ||
| function requestHostTimeout(callback, ms) { | ||
| scheduledTimeout = callback; | ||
| timeoutTime = currentMockTime + ms; | ||
| } | ||
| function cancelHostTimeout() { | ||
| scheduledTimeout = null; | ||
| timeoutTime = -1; | ||
| } | ||
| function shouldYieldToHost() { | ||
| if (expectedNumberOfYields === 0 && yieldedValues === null || expectedNumberOfYields !== -1 && yieldedValues !== null && yieldedValues.length >= expectedNumberOfYields || shouldYieldForPaint && needsPaint) { | ||
| // We yielded at least as many values as expected. Stop flushing. | ||
| didStop = true; | ||
| return true; | ||
| } | ||
| return false; | ||
| } | ||
| function getCurrentTime() { | ||
| return currentMockTime; | ||
| } | ||
| function forceFrameRate() {// No-op | ||
| } | ||
| function reset() { | ||
| if (isFlushing) { | ||
| throw new Error('Cannot reset while already flushing work.'); | ||
| } | ||
| currentMockTime = 0; | ||
| scheduledCallback = null; | ||
| scheduledTimeout = null; | ||
| timeoutTime = -1; | ||
| yieldedValues = null; | ||
| expectedNumberOfYields = -1; | ||
| didStop = false; | ||
| isFlushing = false; | ||
| needsPaint = false; | ||
| } // Should only be used via an assertion helper that inspects the yielded values. | ||
| function unstable_flushNumberOfYields(count) { | ||
| if (isFlushing) { | ||
| throw new Error('Already flushing work.'); | ||
| } | ||
| if (scheduledCallback !== null) { | ||
| var cb = scheduledCallback; | ||
| expectedNumberOfYields = count; | ||
| isFlushing = true; | ||
| try { | ||
| var hasMoreWork = true; | ||
| do { | ||
| hasMoreWork = cb(true, currentMockTime); | ||
| } while (hasMoreWork && !didStop); | ||
| if (!hasMoreWork) { | ||
| scheduledCallback = null; | ||
| } | ||
| } finally { | ||
| var taskQueue = [], | ||
| timerQueue = [], | ||
| taskIdCounter = 1, | ||
| currentTask = null, | ||
| currentPriorityLevel = 3, | ||
| isPerformingWork = !1, | ||
| isHostCallbackScheduled = !1, | ||
| isHostTimeoutScheduled = !1, | ||
| currentMockTime = 0, | ||
| scheduledCallback = null, | ||
| scheduledTimeout = null, | ||
| timeoutTime = -1, | ||
| yieldedValues = null, | ||
| expectedNumberOfYields = -1, | ||
| didStop = !1, | ||
| isFlushing = !1, | ||
| needsPaint = !1, | ||
| shouldYieldForPaint = !1, | ||
| disableYieldValue = !1; | ||
| exports.log = function (value) { | ||
| "disabledLog" === console.log.name || | ||
| disableYieldValue || | ||
| (null === yieldedValues | ||
| ? (yieldedValues = [value]) | ||
| : yieldedValues.push(value)); | ||
| }; | ||
| exports.reset = function () { | ||
| if (isFlushing) throw Error("Cannot reset while already flushing work."); | ||
| currentMockTime = 0; | ||
| scheduledTimeout = scheduledCallback = null; | ||
| timeoutTime = -1; | ||
| yieldedValues = null; | ||
| expectedNumberOfYields = -1; | ||
| didStop = false; | ||
| isFlushing = false; | ||
| } | ||
| } | ||
| } | ||
| function unstable_flushUntilNextPaint() { | ||
| if (isFlushing) { | ||
| throw new Error('Already flushing work.'); | ||
| } | ||
| if (scheduledCallback !== null) { | ||
| var cb = scheduledCallback; | ||
| shouldYieldForPaint = true; | ||
| needsPaint = false; | ||
| isFlushing = true; | ||
| try { | ||
| var hasMoreWork = true; | ||
| do { | ||
| hasMoreWork = cb(true, currentMockTime); | ||
| } while (hasMoreWork && !didStop); | ||
| if (!hasMoreWork) { | ||
| scheduledCallback = null; | ||
| needsPaint = isFlushing = didStop = !1; | ||
| }; | ||
| exports.unstable_IdlePriority = 5; | ||
| exports.unstable_ImmediatePriority = 1; | ||
| exports.unstable_LowPriority = 4; | ||
| exports.unstable_NormalPriority = 3; | ||
| exports.unstable_Profiling = null; | ||
| exports.unstable_UserBlockingPriority = 2; | ||
| exports.unstable_advanceTime = function (ms) { | ||
| "disabledLog" === console.log.name || | ||
| disableYieldValue || | ||
| ((currentMockTime += ms), | ||
| null !== scheduledTimeout && | ||
| timeoutTime <= currentMockTime && | ||
| (scheduledTimeout(currentMockTime), | ||
| (timeoutTime = -1), | ||
| (scheduledTimeout = null))); | ||
| }; | ||
| exports.unstable_cancelCallback = function (task) { | ||
| task.callback = null; | ||
| }; | ||
| exports.unstable_clearLog = function () { | ||
| if (null === yieldedValues) return []; | ||
| var values = yieldedValues; | ||
| yieldedValues = null; | ||
| return values; | ||
| }; | ||
| exports.unstable_continueExecution = function () { | ||
| isHostCallbackScheduled || | ||
| isPerformingWork || | ||
| ((isHostCallbackScheduled = !0), (scheduledCallback = flushWork)); | ||
| }; | ||
| exports.unstable_flushAll = function () { | ||
| if (null !== yieldedValues) | ||
| throw Error( | ||
| "Log is not empty. Assert on the log of yielded values before flushing additional work." | ||
| ); | ||
| unstable_flushAllWithoutAsserting(); | ||
| if (null !== yieldedValues) | ||
| throw 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([...])" | ||
| ); | ||
| }; | ||
| exports.unstable_flushAllWithoutAsserting = | ||
| unstable_flushAllWithoutAsserting; | ||
| exports.unstable_flushExpired = function () { | ||
| if (isFlushing) throw Error("Already flushing work."); | ||
| if (null !== scheduledCallback) { | ||
| isFlushing = !0; | ||
| try { | ||
| scheduledCallback(!1, currentMockTime) || (scheduledCallback = null); | ||
| } finally { | ||
| isFlushing = !1; | ||
| } | ||
| } | ||
| } finally { | ||
| shouldYieldForPaint = false; | ||
| didStop = false; | ||
| isFlushing = false; | ||
| } | ||
| } | ||
| return false; | ||
| } | ||
| function unstable_hasPendingWork() { | ||
| return scheduledCallback !== null; | ||
| } | ||
| function unstable_flushExpired() { | ||
| if (isFlushing) { | ||
| throw new Error('Already flushing work.'); | ||
| } | ||
| if (scheduledCallback !== null) { | ||
| isFlushing = true; | ||
| try { | ||
| var hasMoreWork = scheduledCallback(false, currentMockTime); | ||
| if (!hasMoreWork) { | ||
| scheduledCallback = null; | ||
| }; | ||
| exports.unstable_flushNumberOfYields = function (count) { | ||
| if (isFlushing) throw Error("Already flushing work."); | ||
| if (null !== scheduledCallback) { | ||
| var cb = scheduledCallback; | ||
| expectedNumberOfYields = count; | ||
| isFlushing = !0; | ||
| try { | ||
| count = !0; | ||
| do count = cb(!0, currentMockTime); | ||
| while (count && !didStop); | ||
| count || (scheduledCallback = null); | ||
| } finally { | ||
| (expectedNumberOfYields = -1), (isFlushing = didStop = !1); | ||
| } | ||
| } | ||
| } finally { | ||
| isFlushing = false; | ||
| } | ||
| } | ||
| } | ||
| function unstable_flushAllWithoutAsserting() { | ||
| // Returns false if no work was flushed. | ||
| if (isFlushing) { | ||
| throw new Error('Already flushing work.'); | ||
| } | ||
| if (scheduledCallback !== null) { | ||
| var cb = scheduledCallback; | ||
| isFlushing = true; | ||
| try { | ||
| var hasMoreWork = true; | ||
| do { | ||
| hasMoreWork = cb(true, currentMockTime); | ||
| } while (hasMoreWork); | ||
| if (!hasMoreWork) { | ||
| scheduledCallback = null; | ||
| }; | ||
| exports.unstable_flushUntilNextPaint = function () { | ||
| if (isFlushing) throw Error("Already flushing work."); | ||
| if (null !== scheduledCallback) { | ||
| var cb = scheduledCallback; | ||
| shouldYieldForPaint = !0; | ||
| needsPaint = !1; | ||
| isFlushing = !0; | ||
| try { | ||
| var hasMoreWork = !0; | ||
| do hasMoreWork = cb(!0, currentMockTime); | ||
| while (hasMoreWork && !didStop); | ||
| hasMoreWork || (scheduledCallback = null); | ||
| } finally { | ||
| isFlushing = didStop = shouldYieldForPaint = !1; | ||
| } | ||
| } | ||
| return true; | ||
| } finally { | ||
| isFlushing = false; | ||
| } | ||
| } else { | ||
| return false; | ||
| } | ||
| } | ||
| function unstable_clearLog() { | ||
| if (yieldedValues === null) { | ||
| return []; | ||
| } | ||
| var values = yieldedValues; | ||
| yieldedValues = null; | ||
| return values; | ||
| } | ||
| function unstable_flushAll() { | ||
| if (yieldedValues !== null) { | ||
| throw new Error('Log is not empty. Assert on the log of yielded values before ' + 'flushing additional work.'); | ||
| } | ||
| unstable_flushAllWithoutAsserting(); | ||
| if (yieldedValues !== null) { | ||
| 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([...])'); | ||
| } | ||
| } | ||
| function log(value) { | ||
| // eslint-disable-next-line react-internal/no-production-logging | ||
| if (console.log.name === 'disabledLog' || disableYieldValue) { | ||
| // If console.log has been patched, we assume we're in render | ||
| // replaying and we ignore any values yielding in the second pass. | ||
| return; | ||
| } | ||
| if (yieldedValues === null) { | ||
| yieldedValues = [value]; | ||
| } else { | ||
| yieldedValues.push(value); | ||
| } | ||
| } | ||
| function unstable_advanceTime(ms) { | ||
| // eslint-disable-next-line react-internal/no-production-logging | ||
| if (console.log.name === 'disabledLog' || disableYieldValue) { | ||
| // If console.log has been patched, we assume we're in render | ||
| // replaying and we ignore any time advancing in the second pass. | ||
| return; | ||
| } | ||
| currentMockTime += ms; | ||
| if (scheduledTimeout !== null && timeoutTime <= currentMockTime) { | ||
| scheduledTimeout(currentMockTime); | ||
| timeoutTime = -1; | ||
| scheduledTimeout = null; | ||
| } | ||
| } | ||
| function requestPaint() { | ||
| needsPaint = true; | ||
| } | ||
| var unstable_Profiling = null; | ||
| exports.log = log; | ||
| exports.reset = reset; | ||
| exports.unstable_IdlePriority = IdlePriority; | ||
| exports.unstable_ImmediatePriority = ImmediatePriority; | ||
| exports.unstable_LowPriority = LowPriority; | ||
| exports.unstable_NormalPriority = NormalPriority; | ||
| exports.unstable_Profiling = unstable_Profiling; | ||
| exports.unstable_UserBlockingPriority = UserBlockingPriority; | ||
| exports.unstable_advanceTime = unstable_advanceTime; | ||
| exports.unstable_cancelCallback = unstable_cancelCallback; | ||
| exports.unstable_clearLog = unstable_clearLog; | ||
| exports.unstable_continueExecution = unstable_continueExecution; | ||
| exports.unstable_flushAll = unstable_flushAll; | ||
| exports.unstable_flushAllWithoutAsserting = unstable_flushAllWithoutAsserting; | ||
| exports.unstable_flushExpired = unstable_flushExpired; | ||
| exports.unstable_flushNumberOfYields = unstable_flushNumberOfYields; | ||
| exports.unstable_flushUntilNextPaint = unstable_flushUntilNextPaint; | ||
| exports.unstable_forceFrameRate = forceFrameRate; | ||
| exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel; | ||
| exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode; | ||
| exports.unstable_hasPendingWork = unstable_hasPendingWork; | ||
| exports.unstable_next = unstable_next; | ||
| exports.unstable_now = getCurrentTime; | ||
| exports.unstable_pauseExecution = unstable_pauseExecution; | ||
| exports.unstable_requestPaint = requestPaint; | ||
| exports.unstable_runWithPriority = unstable_runWithPriority; | ||
| exports.unstable_scheduleCallback = unstable_scheduleCallback; | ||
| exports.unstable_setDisableYieldValue = setDisableYieldValue; | ||
| exports.unstable_shouldYield = shouldYieldToHost; | ||
| exports.unstable_wrapCallback = unstable_wrapCallback; | ||
| return !1; | ||
| }; | ||
| exports.unstable_forceFrameRate = function () {}; | ||
| exports.unstable_getCurrentPriorityLevel = function () { | ||
| return currentPriorityLevel; | ||
| }; | ||
| exports.unstable_getFirstCallbackNode = function () { | ||
| return peek(taskQueue); | ||
| }; | ||
| exports.unstable_hasPendingWork = function () { | ||
| return null !== scheduledCallback; | ||
| }; | ||
| exports.unstable_next = function (eventHandler) { | ||
| switch (currentPriorityLevel) { | ||
| case 1: | ||
| case 2: | ||
| case 3: | ||
| var priorityLevel = 3; | ||
| break; | ||
| default: | ||
| priorityLevel = currentPriorityLevel; | ||
| } | ||
| var previousPriorityLevel = currentPriorityLevel; | ||
| currentPriorityLevel = priorityLevel; | ||
| try { | ||
| return eventHandler(); | ||
| } finally { | ||
| currentPriorityLevel = previousPriorityLevel; | ||
| } | ||
| }; | ||
| exports.unstable_now = function () { | ||
| return currentMockTime; | ||
| }; | ||
| exports.unstable_pauseExecution = function () {}; | ||
| exports.unstable_requestPaint = function () { | ||
| needsPaint = !0; | ||
| }; | ||
| exports.unstable_runWithPriority = function (priorityLevel, eventHandler) { | ||
| switch (priorityLevel) { | ||
| case 1: | ||
| case 2: | ||
| case 3: | ||
| case 4: | ||
| case 5: | ||
| break; | ||
| default: | ||
| priorityLevel = 3; | ||
| } | ||
| var previousPriorityLevel = currentPriorityLevel; | ||
| currentPriorityLevel = priorityLevel; | ||
| try { | ||
| return eventHandler(); | ||
| } finally { | ||
| currentPriorityLevel = previousPriorityLevel; | ||
| } | ||
| }; | ||
| exports.unstable_scheduleCallback = function ( | ||
| priorityLevel, | ||
| callback, | ||
| options | ||
| ) { | ||
| var currentTime = currentMockTime; | ||
| "object" === typeof options && null !== options | ||
| ? ((options = options.delay), | ||
| (options = | ||
| "number" === typeof options && 0 < options | ||
| ? currentTime + options | ||
| : currentTime)) | ||
| : (options = currentTime); | ||
| switch (priorityLevel) { | ||
| case 1: | ||
| var timeout = -1; | ||
| break; | ||
| case 2: | ||
| timeout = 250; | ||
| break; | ||
| case 5: | ||
| timeout = 1073741823; | ||
| break; | ||
| case 4: | ||
| timeout = 1e4; | ||
| break; | ||
| default: | ||
| timeout = 5e3; | ||
| } | ||
| timeout = options + timeout; | ||
| priorityLevel = { | ||
| id: taskIdCounter++, | ||
| callback: callback, | ||
| priorityLevel: priorityLevel, | ||
| startTime: options, | ||
| expirationTime: timeout, | ||
| sortIndex: -1 | ||
| }; | ||
| options > currentTime | ||
| ? ((priorityLevel.sortIndex = options), | ||
| push(timerQueue, priorityLevel), | ||
| null === peek(taskQueue) && | ||
| priorityLevel === peek(timerQueue) && | ||
| (isHostTimeoutScheduled | ||
| ? ((scheduledTimeout = null), (timeoutTime = -1)) | ||
| : (isHostTimeoutScheduled = !0), | ||
| (scheduledTimeout = handleTimeout), | ||
| (timeoutTime = currentMockTime + (options - currentTime)))) | ||
| : ((priorityLevel.sortIndex = timeout), | ||
| push(taskQueue, priorityLevel), | ||
| isHostCallbackScheduled || | ||
| isPerformingWork || | ||
| ((isHostCallbackScheduled = !0), (scheduledCallback = flushWork))); | ||
| return priorityLevel; | ||
| }; | ||
| exports.unstable_setDisableYieldValue = function (newValue) { | ||
| disableYieldValue = newValue; | ||
| }; | ||
| exports.unstable_shouldYield = shouldYieldToHost; | ||
| exports.unstable_wrapCallback = function (callback) { | ||
| var parentPriorityLevel = currentPriorityLevel; | ||
| return function () { | ||
| var previousPriorityLevel = currentPriorityLevel; | ||
| currentPriorityLevel = parentPriorityLevel; | ||
| try { | ||
| return callback.apply(this, arguments); | ||
| } finally { | ||
| currentPriorityLevel = previousPriorityLevel; | ||
| } | ||
| }; | ||
| }; | ||
| })(); | ||
| } |
@@ -11,199 +11,146 @@ /** | ||
| 'use strict'; | ||
| if (process.env.NODE_ENV !== "production") { | ||
| (function() { | ||
| 'use strict'; | ||
| // TODO: Use symbols? | ||
| var ImmediatePriority = 1; | ||
| var UserBlockingPriority = 2; | ||
| var NormalPriority = 3; | ||
| var LowPriority = 4; | ||
| var IdlePriority = 5; | ||
| var perf = window.performance; | ||
| var setTimeout = window.setTimeout; // Use experimental Chrome Scheduler postTask API. | ||
| var scheduler = global.scheduler; | ||
| var getCurrentTime = perf.now.bind(perf); | ||
| var unstable_now = getCurrentTime; // Scheduler periodically yields in case there is other work on the main | ||
| // thread, like user events. By default, it yields multiple times per frame. | ||
| // It does not attempt to align with frame boundaries, since most tasks don't | ||
| // need to be frame aligned; for those that do, use requestAnimationFrame. | ||
| var yieldInterval = 5; | ||
| var deadline = 0; | ||
| var currentPriorityLevel_DEPRECATED = NormalPriority; // Always yield at the end of the frame. | ||
| function unstable_shouldYield() { | ||
| return getCurrentTime() >= deadline; | ||
| } | ||
| function unstable_requestPaint() {// Since we yield every frame regardless, `requestPaint` has no effect. | ||
| } | ||
| function unstable_scheduleCallback(priorityLevel, callback, options) { | ||
| var postTaskPriority; | ||
| switch (priorityLevel) { | ||
| case ImmediatePriority: | ||
| case UserBlockingPriority: | ||
| postTaskPriority = 'user-blocking'; | ||
| break; | ||
| case LowPriority: | ||
| case NormalPriority: | ||
| postTaskPriority = 'user-visible'; | ||
| break; | ||
| case IdlePriority: | ||
| postTaskPriority = 'background'; | ||
| break; | ||
| default: | ||
| postTaskPriority = 'user-visible'; | ||
| break; | ||
| } | ||
| var controller = new TaskController({ | ||
| priority: postTaskPriority | ||
| }); | ||
| var postTaskOptions = { | ||
| delay: typeof options === 'object' && options !== null ? options.delay : 0, | ||
| signal: controller.signal | ||
| }; | ||
| var node = { | ||
| _controller: controller | ||
| }; | ||
| scheduler.postTask(runTask.bind(null, priorityLevel, postTaskPriority, node, callback), postTaskOptions).catch(handleAbortError); | ||
| return node; | ||
| } | ||
| function runTask(priorityLevel, postTaskPriority, node, callback) { | ||
| deadline = getCurrentTime() + yieldInterval; | ||
| try { | ||
| currentPriorityLevel_DEPRECATED = priorityLevel; | ||
| var didTimeout_DEPRECATED = false; | ||
| var result = callback(didTimeout_DEPRECATED); | ||
| if (typeof result === 'function') { | ||
| // Assume this is a continuation | ||
| var continuation = result; | ||
| var continuationOptions = { | ||
| signal: node._controller.signal | ||
| }; | ||
| var nextTask = runTask.bind(null, priorityLevel, postTaskPriority, node, continuation); | ||
| if (scheduler.yield !== undefined) { | ||
| scheduler.yield(continuationOptions).then(nextTask).catch(handleAbortError); | ||
| } else { | ||
| scheduler.postTask(nextTask, continuationOptions).catch(handleAbortError); | ||
| "use strict"; | ||
| "production" !== process.env.NODE_ENV && | ||
| (function () { | ||
| function runTask(priorityLevel, postTaskPriority, node, callback) { | ||
| deadline = getCurrentTime() + 5; | ||
| try { | ||
| currentPriorityLevel_DEPRECATED = priorityLevel; | ||
| var result = callback(!1); | ||
| if ("function" === typeof result) { | ||
| var continuationOptions = { signal: node._controller.signal }, | ||
| nextTask = runTask.bind( | ||
| null, | ||
| priorityLevel, | ||
| postTaskPriority, | ||
| node, | ||
| result | ||
| ); | ||
| void 0 !== scheduler.yield | ||
| ? scheduler | ||
| .yield(continuationOptions) | ||
| .then(nextTask) | ||
| .catch(handleAbortError) | ||
| : scheduler | ||
| .postTask(nextTask, continuationOptions) | ||
| .catch(handleAbortError); | ||
| } | ||
| } catch (error) { | ||
| setTimeout(function () { | ||
| throw error; | ||
| }); | ||
| } finally { | ||
| currentPriorityLevel_DEPRECATED = 3; | ||
| } | ||
| } | ||
| } catch (error) { | ||
| // We're inside a `postTask` promise. If we don't handle this error, then it | ||
| // will trigger an "Unhandled promise rejection" error. We don't want that, | ||
| // but we do want the default error reporting behavior that normal | ||
| // (non-Promise) tasks get for unhandled errors. | ||
| // | ||
| // So we'll re-throw the error inside a regular browser task. | ||
| setTimeout(function () { | ||
| throw error; | ||
| }); | ||
| } finally { | ||
| currentPriorityLevel_DEPRECATED = NormalPriority; | ||
| } | ||
| } | ||
| function handleAbortError(error) {// Abort errors are an implementation detail. We don't expose the | ||
| // TaskController to the user, nor do we expose the promise that is returned | ||
| // from `postTask`. So we should suppress them, since there's no way for the | ||
| // user to handle them. | ||
| } | ||
| function unstable_cancelCallback(node) { | ||
| var controller = node._controller; | ||
| controller.abort(); | ||
| } | ||
| function unstable_runWithPriority(priorityLevel, callback) { | ||
| var previousPriorityLevel = currentPriorityLevel_DEPRECATED; | ||
| currentPriorityLevel_DEPRECATED = priorityLevel; | ||
| try { | ||
| return callback(); | ||
| } finally { | ||
| currentPriorityLevel_DEPRECATED = previousPriorityLevel; | ||
| } | ||
| } | ||
| function unstable_getCurrentPriorityLevel() { | ||
| return currentPriorityLevel_DEPRECATED; | ||
| } | ||
| function unstable_next(callback) { | ||
| var priorityLevel; | ||
| switch (currentPriorityLevel_DEPRECATED) { | ||
| case ImmediatePriority: | ||
| case UserBlockingPriority: | ||
| case NormalPriority: | ||
| // Shift down to normal priority | ||
| priorityLevel = NormalPriority; | ||
| break; | ||
| default: | ||
| // Anything lower than normal priority should remain at the current level. | ||
| priorityLevel = currentPriorityLevel_DEPRECATED; | ||
| break; | ||
| } | ||
| var previousPriorityLevel = currentPriorityLevel_DEPRECATED; | ||
| currentPriorityLevel_DEPRECATED = priorityLevel; | ||
| try { | ||
| return callback(); | ||
| } finally { | ||
| currentPriorityLevel_DEPRECATED = previousPriorityLevel; | ||
| } | ||
| } | ||
| function unstable_wrapCallback(callback) { | ||
| var parentPriorityLevel = currentPriorityLevel_DEPRECATED; | ||
| return function () { | ||
| var previousPriorityLevel = currentPriorityLevel_DEPRECATED; | ||
| currentPriorityLevel_DEPRECATED = parentPriorityLevel; | ||
| try { | ||
| return callback(); | ||
| } finally { | ||
| currentPriorityLevel_DEPRECATED = previousPriorityLevel; | ||
| } | ||
| }; | ||
| } | ||
| function unstable_forceFrameRate() {} | ||
| function unstable_pauseExecution() {} | ||
| function unstable_continueExecution() {} | ||
| function unstable_getFirstCallbackNode() { | ||
| return null; | ||
| } // Currently no profiling build | ||
| var unstable_Profiling = null; | ||
| exports.unstable_IdlePriority = IdlePriority; | ||
| exports.unstable_ImmediatePriority = ImmediatePriority; | ||
| exports.unstable_LowPriority = LowPriority; | ||
| exports.unstable_NormalPriority = NormalPriority; | ||
| exports.unstable_Profiling = unstable_Profiling; | ||
| exports.unstable_UserBlockingPriority = UserBlockingPriority; | ||
| exports.unstable_cancelCallback = unstable_cancelCallback; | ||
| exports.unstable_continueExecution = unstable_continueExecution; | ||
| exports.unstable_forceFrameRate = unstable_forceFrameRate; | ||
| exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel; | ||
| exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode; | ||
| exports.unstable_next = unstable_next; | ||
| exports.unstable_now = unstable_now; | ||
| exports.unstable_pauseExecution = unstable_pauseExecution; | ||
| exports.unstable_requestPaint = unstable_requestPaint; | ||
| exports.unstable_runWithPriority = unstable_runWithPriority; | ||
| exports.unstable_scheduleCallback = unstable_scheduleCallback; | ||
| exports.unstable_shouldYield = unstable_shouldYield; | ||
| exports.unstable_wrapCallback = unstable_wrapCallback; | ||
| function handleAbortError() {} | ||
| var perf = window.performance, | ||
| setTimeout = window.setTimeout, | ||
| scheduler = global.scheduler, | ||
| getCurrentTime = perf.now.bind(perf), | ||
| deadline = 0, | ||
| currentPriorityLevel_DEPRECATED = 3; | ||
| exports.unstable_IdlePriority = 5; | ||
| exports.unstable_ImmediatePriority = 1; | ||
| exports.unstable_LowPriority = 4; | ||
| exports.unstable_NormalPriority = 3; | ||
| exports.unstable_Profiling = null; | ||
| exports.unstable_UserBlockingPriority = 2; | ||
| exports.unstable_cancelCallback = function (node) { | ||
| node._controller.abort(); | ||
| }; | ||
| exports.unstable_continueExecution = function () {}; | ||
| exports.unstable_forceFrameRate = function () {}; | ||
| exports.unstable_getCurrentPriorityLevel = function () { | ||
| return currentPriorityLevel_DEPRECATED; | ||
| }; | ||
| exports.unstable_getFirstCallbackNode = function () { | ||
| return null; | ||
| }; | ||
| exports.unstable_next = function (callback) { | ||
| switch (currentPriorityLevel_DEPRECATED) { | ||
| case 1: | ||
| case 2: | ||
| case 3: | ||
| var priorityLevel = 3; | ||
| break; | ||
| default: | ||
| priorityLevel = currentPriorityLevel_DEPRECATED; | ||
| } | ||
| var previousPriorityLevel = currentPriorityLevel_DEPRECATED; | ||
| currentPriorityLevel_DEPRECATED = priorityLevel; | ||
| try { | ||
| return callback(); | ||
| } finally { | ||
| currentPriorityLevel_DEPRECATED = previousPriorityLevel; | ||
| } | ||
| }; | ||
| exports.unstable_now = getCurrentTime; | ||
| exports.unstable_pauseExecution = function () {}; | ||
| exports.unstable_requestPaint = function () {}; | ||
| exports.unstable_runWithPriority = function (priorityLevel, callback) { | ||
| var previousPriorityLevel = currentPriorityLevel_DEPRECATED; | ||
| currentPriorityLevel_DEPRECATED = priorityLevel; | ||
| try { | ||
| return callback(); | ||
| } finally { | ||
| currentPriorityLevel_DEPRECATED = previousPriorityLevel; | ||
| } | ||
| }; | ||
| exports.unstable_scheduleCallback = function ( | ||
| priorityLevel, | ||
| callback, | ||
| options | ||
| ) { | ||
| switch (priorityLevel) { | ||
| case 1: | ||
| case 2: | ||
| var postTaskPriority = "user-blocking"; | ||
| break; | ||
| case 4: | ||
| case 3: | ||
| postTaskPriority = "user-visible"; | ||
| break; | ||
| case 5: | ||
| postTaskPriority = "background"; | ||
| break; | ||
| default: | ||
| postTaskPriority = "user-visible"; | ||
| } | ||
| var controller = new TaskController({ priority: postTaskPriority }); | ||
| options = { | ||
| delay: | ||
| "object" === typeof options && null !== options ? options.delay : 0, | ||
| signal: controller.signal | ||
| }; | ||
| controller = { _controller: controller }; | ||
| scheduler | ||
| .postTask( | ||
| runTask.bind( | ||
| null, | ||
| priorityLevel, | ||
| postTaskPriority, | ||
| controller, | ||
| callback | ||
| ), | ||
| options | ||
| ) | ||
| .catch(handleAbortError); | ||
| return controller; | ||
| }; | ||
| exports.unstable_shouldYield = function () { | ||
| return getCurrentTime() >= deadline; | ||
| }; | ||
| exports.unstable_wrapCallback = function (callback) { | ||
| var parentPriorityLevel = currentPriorityLevel_DEPRECATED; | ||
| return function () { | ||
| var previousPriorityLevel = currentPriorityLevel_DEPRECATED; | ||
| currentPriorityLevel_DEPRECATED = parentPriorityLevel; | ||
| try { | ||
| return callback(); | ||
| } finally { | ||
| currentPriorityLevel_DEPRECATED = previousPriorityLevel; | ||
| } | ||
| }; | ||
| }; | ||
| })(); | ||
| } |
@@ -11,612 +11,355 @@ /** | ||
| 'use strict'; | ||
| "use strict"; | ||
| "production" !== process.env.NODE_ENV && | ||
| (function () { | ||
| function performWorkUntilDeadline() { | ||
| if (isMessageLoopRunning) { | ||
| var currentTime = exports.unstable_now(); | ||
| startTime = currentTime; | ||
| var hasMoreWork = !0; | ||
| try { | ||
| a: { | ||
| isHostCallbackScheduled = !1; | ||
| isHostTimeoutScheduled && | ||
| ((isHostTimeoutScheduled = !1), | ||
| localClearTimeout(taskTimeoutID), | ||
| (taskTimeoutID = -1)); | ||
| isPerformingWork = !0; | ||
| var previousPriorityLevel = currentPriorityLevel; | ||
| try { | ||
| b: { | ||
| advanceTimers(currentTime); | ||
| for ( | ||
| currentTask = peek(taskQueue); | ||
| null !== currentTask && | ||
| !( | ||
| currentTask.expirationTime > currentTime && | ||
| shouldYieldToHost() | ||
| ); | ||
| if (process.env.NODE_ENV !== "production") { | ||
| (function() { | ||
| 'use strict'; | ||
| if ( | ||
| typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' && | ||
| typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === | ||
| 'function' | ||
| ) { | ||
| __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error()); | ||
| } | ||
| var enableSchedulerDebugging = false; | ||
| var enableProfiling = false; | ||
| var frameYieldMs = 5; | ||
| var userBlockingPriorityTimeout = 250; | ||
| var normalPriorityTimeout = 5000; | ||
| var lowPriorityTimeout = 10000; | ||
| function push(heap, node) { | ||
| var index = heap.length; | ||
| heap.push(node); | ||
| siftUp(heap, node, index); | ||
| } | ||
| function peek(heap) { | ||
| return heap.length === 0 ? null : heap[0]; | ||
| } | ||
| function pop(heap) { | ||
| if (heap.length === 0) { | ||
| return null; | ||
| } | ||
| var first = heap[0]; | ||
| var last = heap.pop(); | ||
| if (last !== first) { | ||
| heap[0] = last; | ||
| siftDown(heap, last, 0); | ||
| } | ||
| return first; | ||
| } | ||
| function siftUp(heap, node, i) { | ||
| var index = i; | ||
| while (index > 0) { | ||
| var parentIndex = index - 1 >>> 1; | ||
| var parent = heap[parentIndex]; | ||
| if (compare(parent, node) > 0) { | ||
| // The parent is larger. Swap positions. | ||
| heap[parentIndex] = node; | ||
| heap[index] = parent; | ||
| index = parentIndex; | ||
| } else { | ||
| // The parent is smaller. Exit. | ||
| return; | ||
| ) { | ||
| var callback = currentTask.callback; | ||
| if ("function" === typeof callback) { | ||
| currentTask.callback = null; | ||
| currentPriorityLevel = currentTask.priorityLevel; | ||
| var continuationCallback = callback( | ||
| currentTask.expirationTime <= currentTime | ||
| ); | ||
| currentTime = exports.unstable_now(); | ||
| if ("function" === typeof continuationCallback) { | ||
| currentTask.callback = continuationCallback; | ||
| advanceTimers(currentTime); | ||
| hasMoreWork = !0; | ||
| break b; | ||
| } | ||
| currentTask === peek(taskQueue) && pop(taskQueue); | ||
| advanceTimers(currentTime); | ||
| } else pop(taskQueue); | ||
| currentTask = peek(taskQueue); | ||
| } | ||
| if (null !== currentTask) hasMoreWork = !0; | ||
| else { | ||
| var firstTimer = peek(timerQueue); | ||
| null !== firstTimer && | ||
| requestHostTimeout( | ||
| handleTimeout, | ||
| firstTimer.startTime - currentTime | ||
| ); | ||
| hasMoreWork = !1; | ||
| } | ||
| } | ||
| break a; | ||
| } finally { | ||
| (currentTask = null), | ||
| (currentPriorityLevel = previousPriorityLevel), | ||
| (isPerformingWork = !1); | ||
| } | ||
| hasMoreWork = void 0; | ||
| } | ||
| } finally { | ||
| hasMoreWork | ||
| ? schedulePerformWorkUntilDeadline() | ||
| : (isMessageLoopRunning = !1); | ||
| } | ||
| } | ||
| } | ||
| } | ||
| } | ||
| function siftDown(heap, node, i) { | ||
| var index = i; | ||
| var length = heap.length; | ||
| var halfLength = length >>> 1; | ||
| while (index < halfLength) { | ||
| var leftIndex = (index + 1) * 2 - 1; | ||
| var left = heap[leftIndex]; | ||
| var rightIndex = leftIndex + 1; | ||
| var right = heap[rightIndex]; // If the left or right node is smaller, swap with the smaller of those. | ||
| if (compare(left, node) < 0) { | ||
| if (rightIndex < length && compare(right, left) < 0) { | ||
| heap[index] = right; | ||
| heap[rightIndex] = node; | ||
| index = rightIndex; | ||
| } else { | ||
| heap[index] = left; | ||
| heap[leftIndex] = node; | ||
| index = leftIndex; | ||
| function push(heap, node) { | ||
| var index = heap.length; | ||
| heap.push(node); | ||
| a: for (; 0 < index; ) { | ||
| var parentIndex = (index - 1) >>> 1, | ||
| parent = heap[parentIndex]; | ||
| if (0 < compare(parent, node)) | ||
| (heap[parentIndex] = node), | ||
| (heap[index] = parent), | ||
| (index = parentIndex); | ||
| else break a; | ||
| } | ||
| } else if (rightIndex < length && compare(right, node) < 0) { | ||
| heap[index] = right; | ||
| heap[rightIndex] = node; | ||
| index = rightIndex; | ||
| } else { | ||
| // Neither child is smaller. Exit. | ||
| return; | ||
| } | ||
| } | ||
| } | ||
| function compare(a, b) { | ||
| // Compare sort index first, then task id. | ||
| var diff = a.sortIndex - b.sortIndex; | ||
| return diff !== 0 ? diff : a.id - b.id; | ||
| } | ||
| // TODO: Use symbols? | ||
| var ImmediatePriority = 1; | ||
| var UserBlockingPriority = 2; | ||
| var NormalPriority = 3; | ||
| var LowPriority = 4; | ||
| var IdlePriority = 5; | ||
| function markTaskErrored(task, ms) { | ||
| } | ||
| /* eslint-disable no-var */ | ||
| exports.unstable_now = void 0; | ||
| var hasPerformanceNow = // $FlowFixMe[method-unbinding] | ||
| typeof performance === 'object' && typeof performance.now === 'function'; | ||
| if (hasPerformanceNow) { | ||
| var localPerformance = performance; | ||
| exports.unstable_now = function () { | ||
| return localPerformance.now(); | ||
| }; | ||
| } else { | ||
| var localDate = Date; | ||
| var initialTime = localDate.now(); | ||
| exports.unstable_now = function () { | ||
| return localDate.now() - initialTime; | ||
| }; | ||
| } // Max 31 bit integer. The max integer size in V8 for 32-bit systems. | ||
| // Math.pow(2, 30) - 1 | ||
| // 0b111111111111111111111111111111 | ||
| var maxSigned31BitInt = 1073741823; // Tasks are stored on a min heap | ||
| var taskQueue = []; | ||
| var timerQueue = []; // Incrementing id counter. Used to maintain insertion order. | ||
| var taskIdCounter = 1; // Pausing the scheduler is useful for debugging. | ||
| var currentTask = null; | ||
| var currentPriorityLevel = NormalPriority; // This is set while performing work, to prevent re-entrance. | ||
| var isPerformingWork = false; | ||
| var isHostCallbackScheduled = false; | ||
| var isHostTimeoutScheduled = false; // Capture local references to native APIs, in case a polyfill overrides them. | ||
| var localSetTimeout = typeof setTimeout === 'function' ? setTimeout : null; | ||
| var localClearTimeout = typeof clearTimeout === 'function' ? clearTimeout : null; | ||
| var localSetImmediate = typeof setImmediate !== 'undefined' ? setImmediate : null; // IE and Node.js + jsdom | ||
| function advanceTimers(currentTime) { | ||
| // Check for tasks that are no longer delayed and add them to the queue. | ||
| var timer = peek(timerQueue); | ||
| while (timer !== null) { | ||
| if (timer.callback === null) { | ||
| // Timer was cancelled. | ||
| pop(timerQueue); | ||
| } else if (timer.startTime <= currentTime) { | ||
| // Timer fired. Transfer to the task queue. | ||
| pop(timerQueue); | ||
| timer.sortIndex = timer.expirationTime; | ||
| push(taskQueue, timer); | ||
| } else { | ||
| // Remaining timers are pending. | ||
| return; | ||
| function peek(heap) { | ||
| return 0 === heap.length ? null : heap[0]; | ||
| } | ||
| function pop(heap) { | ||
| if (0 === heap.length) return null; | ||
| var first = heap[0], | ||
| last = heap.pop(); | ||
| if (last !== first) { | ||
| heap[0] = last; | ||
| a: for ( | ||
| var index = 0, length = heap.length, halfLength = length >>> 1; | ||
| index < halfLength; | ||
| timer = peek(timerQueue); | ||
| } | ||
| } | ||
| function handleTimeout(currentTime) { | ||
| isHostTimeoutScheduled = false; | ||
| advanceTimers(currentTime); | ||
| if (!isHostCallbackScheduled) { | ||
| if (peek(taskQueue) !== null) { | ||
| isHostCallbackScheduled = true; | ||
| requestHostCallback(); | ||
| } else { | ||
| var firstTimer = peek(timerQueue); | ||
| if (firstTimer !== null) { | ||
| requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime); | ||
| ) { | ||
| var leftIndex = 2 * (index + 1) - 1, | ||
| left = heap[leftIndex], | ||
| rightIndex = leftIndex + 1, | ||
| right = heap[rightIndex]; | ||
| if (0 > compare(left, last)) | ||
| rightIndex < length && 0 > compare(right, left) | ||
| ? ((heap[index] = right), | ||
| (heap[rightIndex] = last), | ||
| (index = rightIndex)) | ||
| : ((heap[index] = left), | ||
| (heap[leftIndex] = last), | ||
| (index = leftIndex)); | ||
| else if (rightIndex < length && 0 > compare(right, last)) | ||
| (heap[index] = right), | ||
| (heap[rightIndex] = last), | ||
| (index = rightIndex); | ||
| else break a; | ||
| } | ||
| } | ||
| return first; | ||
| } | ||
| } | ||
| } | ||
| function flushWork(initialTime) { | ||
| isHostCallbackScheduled = false; | ||
| if (isHostTimeoutScheduled) { | ||
| // We scheduled a timeout but it's no longer needed. Cancel it. | ||
| isHostTimeoutScheduled = false; | ||
| cancelHostTimeout(); | ||
| } | ||
| isPerformingWork = true; | ||
| var previousPriorityLevel = currentPriorityLevel; | ||
| try { | ||
| var currentTime; if (enableProfiling) ; else { | ||
| // No catch in prod code path. | ||
| return workLoop(initialTime); | ||
| function compare(a, b) { | ||
| var diff = a.sortIndex - b.sortIndex; | ||
| return 0 !== diff ? diff : a.id - b.id; | ||
| } | ||
| } finally { | ||
| currentTask = null; | ||
| currentPriorityLevel = previousPriorityLevel; | ||
| isPerformingWork = false; | ||
| } | ||
| } | ||
| function workLoop(initialTime) { | ||
| var currentTime = initialTime; | ||
| advanceTimers(currentTime); | ||
| currentTask = peek(taskQueue); | ||
| while (currentTask !== null && !(enableSchedulerDebugging )) { | ||
| if (currentTask.expirationTime > currentTime && shouldYieldToHost()) { | ||
| // This currentTask hasn't expired, and we've reached the deadline. | ||
| break; | ||
| } // $FlowFixMe[incompatible-use] found when upgrading Flow | ||
| var callback = currentTask.callback; | ||
| if (typeof callback === 'function') { | ||
| // $FlowFixMe[incompatible-use] found when upgrading Flow | ||
| currentTask.callback = null; // $FlowFixMe[incompatible-use] found when upgrading Flow | ||
| currentPriorityLevel = currentTask.priorityLevel; // $FlowFixMe[incompatible-use] found when upgrading Flow | ||
| var didUserCallbackTimeout = currentTask.expirationTime <= currentTime; | ||
| var continuationCallback = callback(didUserCallbackTimeout); | ||
| currentTime = exports.unstable_now(); | ||
| if (typeof continuationCallback === 'function') { | ||
| // If a continuation is returned, immediately yield to the main thread | ||
| // regardless of how much time is left in the current time slice. | ||
| // $FlowFixMe[incompatible-use] found when upgrading Flow | ||
| currentTask.callback = continuationCallback; | ||
| advanceTimers(currentTime); | ||
| return true; | ||
| } else { | ||
| if (currentTask === peek(taskQueue)) { | ||
| pop(taskQueue); | ||
| } | ||
| advanceTimers(currentTime); | ||
| function advanceTimers(currentTime) { | ||
| for (var timer = peek(timerQueue); null !== timer; ) { | ||
| if (null === timer.callback) pop(timerQueue); | ||
| else if (timer.startTime <= currentTime) | ||
| pop(timerQueue), | ||
| (timer.sortIndex = timer.expirationTime), | ||
| push(taskQueue, timer); | ||
| else break; | ||
| timer = peek(timerQueue); | ||
| } | ||
| } else { | ||
| pop(taskQueue); | ||
| } | ||
| currentTask = peek(taskQueue); | ||
| } // Return whether there's additional work | ||
| if (currentTask !== null) { | ||
| return true; | ||
| } else { | ||
| var firstTimer = peek(timerQueue); | ||
| if (firstTimer !== null) { | ||
| requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime); | ||
| function handleTimeout(currentTime) { | ||
| isHostTimeoutScheduled = !1; | ||
| advanceTimers(currentTime); | ||
| if (!isHostCallbackScheduled) | ||
| if (null !== peek(taskQueue)) | ||
| (isHostCallbackScheduled = !0), requestHostCallback(); | ||
| else { | ||
| var firstTimer = peek(timerQueue); | ||
| null !== firstTimer && | ||
| requestHostTimeout( | ||
| handleTimeout, | ||
| firstTimer.startTime - currentTime | ||
| ); | ||
| } | ||
| } | ||
| return false; | ||
| } | ||
| } | ||
| function unstable_runWithPriority(priorityLevel, eventHandler) { | ||
| switch (priorityLevel) { | ||
| case ImmediatePriority: | ||
| case UserBlockingPriority: | ||
| case NormalPriority: | ||
| case LowPriority: | ||
| case IdlePriority: | ||
| break; | ||
| default: | ||
| priorityLevel = NormalPriority; | ||
| } | ||
| var previousPriorityLevel = currentPriorityLevel; | ||
| currentPriorityLevel = priorityLevel; | ||
| try { | ||
| return eventHandler(); | ||
| } finally { | ||
| currentPriorityLevel = previousPriorityLevel; | ||
| } | ||
| } | ||
| function unstable_next(eventHandler) { | ||
| var priorityLevel; | ||
| switch (currentPriorityLevel) { | ||
| case ImmediatePriority: | ||
| case UserBlockingPriority: | ||
| case NormalPriority: | ||
| // Shift down to normal priority | ||
| priorityLevel = NormalPriority; | ||
| break; | ||
| default: | ||
| // Anything lower than normal priority should remain at the current level. | ||
| priorityLevel = currentPriorityLevel; | ||
| break; | ||
| } | ||
| var previousPriorityLevel = currentPriorityLevel; | ||
| currentPriorityLevel = priorityLevel; | ||
| try { | ||
| return eventHandler(); | ||
| } finally { | ||
| currentPriorityLevel = previousPriorityLevel; | ||
| } | ||
| } | ||
| function unstable_wrapCallback(callback) { | ||
| var parentPriorityLevel = currentPriorityLevel; // $FlowFixMe[incompatible-return] | ||
| // $FlowFixMe[missing-this-annot] | ||
| return function () { | ||
| // This is a fork of runWithPriority, inlined for performance. | ||
| var previousPriorityLevel = currentPriorityLevel; | ||
| currentPriorityLevel = parentPriorityLevel; | ||
| try { | ||
| return callback.apply(this, arguments); | ||
| } finally { | ||
| currentPriorityLevel = previousPriorityLevel; | ||
| function shouldYieldToHost() { | ||
| return exports.unstable_now() - startTime < frameInterval ? !1 : !0; | ||
| } | ||
| }; | ||
| } | ||
| function unstable_scheduleCallback(priorityLevel, callback, options) { | ||
| var currentTime = exports.unstable_now(); | ||
| var startTime; | ||
| if (typeof options === 'object' && options !== null) { | ||
| var delay = options.delay; | ||
| if (typeof delay === 'number' && delay > 0) { | ||
| startTime = currentTime + delay; | ||
| } else { | ||
| startTime = currentTime; | ||
| function requestHostCallback() { | ||
| isMessageLoopRunning || | ||
| ((isMessageLoopRunning = !0), schedulePerformWorkUntilDeadline()); | ||
| } | ||
| } else { | ||
| startTime = currentTime; | ||
| } | ||
| var timeout; | ||
| switch (priorityLevel) { | ||
| case ImmediatePriority: | ||
| // Times out immediately | ||
| timeout = -1; | ||
| break; | ||
| case UserBlockingPriority: | ||
| // Eventually times out | ||
| timeout = userBlockingPriorityTimeout; | ||
| break; | ||
| case IdlePriority: | ||
| // Never times out | ||
| timeout = maxSigned31BitInt; | ||
| break; | ||
| case LowPriority: | ||
| // Eventually times out | ||
| timeout = lowPriorityTimeout; | ||
| break; | ||
| case NormalPriority: | ||
| default: | ||
| // Eventually times out | ||
| timeout = normalPriorityTimeout; | ||
| break; | ||
| } | ||
| var expirationTime = startTime + timeout; | ||
| var newTask = { | ||
| id: taskIdCounter++, | ||
| callback: callback, | ||
| priorityLevel: priorityLevel, | ||
| startTime: startTime, | ||
| expirationTime: expirationTime, | ||
| sortIndex: -1 | ||
| }; | ||
| if (startTime > currentTime) { | ||
| // This is a delayed task. | ||
| newTask.sortIndex = startTime; | ||
| push(timerQueue, newTask); | ||
| if (peek(taskQueue) === null && newTask === peek(timerQueue)) { | ||
| // All tasks are delayed, and this is the task with the earliest delay. | ||
| if (isHostTimeoutScheduled) { | ||
| // Cancel an existing timeout. | ||
| cancelHostTimeout(); | ||
| } else { | ||
| isHostTimeoutScheduled = true; | ||
| } // Schedule a timeout. | ||
| requestHostTimeout(handleTimeout, startTime - currentTime); | ||
| function requestHostTimeout(callback, ms) { | ||
| taskTimeoutID = localSetTimeout(function () { | ||
| callback(exports.unstable_now()); | ||
| }, ms); | ||
| } | ||
| } else { | ||
| newTask.sortIndex = expirationTime; | ||
| push(taskQueue, newTask); | ||
| // wait until the next time we yield. | ||
| if (!isHostCallbackScheduled && !isPerformingWork) { | ||
| isHostCallbackScheduled = true; | ||
| requestHostCallback(); | ||
| "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && | ||
| "function" === | ||
| typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && | ||
| __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error()); | ||
| exports.unstable_now = void 0; | ||
| if ( | ||
| "object" === typeof performance && | ||
| "function" === typeof performance.now | ||
| ) { | ||
| var localPerformance = performance; | ||
| exports.unstable_now = function () { | ||
| return localPerformance.now(); | ||
| }; | ||
| } else { | ||
| var localDate = Date, | ||
| initialTime = localDate.now(); | ||
| exports.unstable_now = function () { | ||
| return localDate.now() - initialTime; | ||
| }; | ||
| } | ||
| } | ||
| return newTask; | ||
| } | ||
| function unstable_pauseExecution() { | ||
| } | ||
| function unstable_continueExecution() { | ||
| if (!isHostCallbackScheduled && !isPerformingWork) { | ||
| isHostCallbackScheduled = true; | ||
| requestHostCallback(); | ||
| } | ||
| } | ||
| function unstable_getFirstCallbackNode() { | ||
| return peek(taskQueue); | ||
| } | ||
| function unstable_cancelCallback(task) { | ||
| // remove from the queue because you can't remove arbitrary nodes from an | ||
| // array based heap, only the first one.) | ||
| task.callback = null; | ||
| } | ||
| function unstable_getCurrentPriorityLevel() { | ||
| return currentPriorityLevel; | ||
| } | ||
| var isMessageLoopRunning = false; | ||
| var taskTimeoutID = -1; // Scheduler periodically yields in case there is other work on the main | ||
| // thread, like user events. By default, it yields multiple times per frame. | ||
| // It does not attempt to align with frame boundaries, since most tasks don't | ||
| // need to be frame aligned; for those that do, use requestAnimationFrame. | ||
| var frameInterval = frameYieldMs; | ||
| var startTime = -1; | ||
| function shouldYieldToHost() { | ||
| var timeElapsed = exports.unstable_now() - startTime; | ||
| if (timeElapsed < frameInterval) { | ||
| // The main thread has only been blocked for a really short amount of time; | ||
| // smaller than a single frame. Don't yield yet. | ||
| return false; | ||
| } // Yield now. | ||
| return true; | ||
| } | ||
| function requestPaint() {} | ||
| function forceFrameRate(fps) { | ||
| if (fps < 0 || fps > 125) { | ||
| // Using console['error'] to evade Babel and ESLint | ||
| console['error']('forceFrameRate takes a positive int between 0 and 125, ' + 'forcing frame rates higher than 125 fps is not supported'); | ||
| return; | ||
| } | ||
| if (fps > 0) { | ||
| frameInterval = Math.floor(1000 / fps); | ||
| } else { | ||
| // reset the framerate | ||
| frameInterval = frameYieldMs; | ||
| } | ||
| } | ||
| var performWorkUntilDeadline = function () { | ||
| if (isMessageLoopRunning) { | ||
| var currentTime = exports.unstable_now(); // Keep track of the start time so we can measure how long the main thread | ||
| // has been blocked. | ||
| startTime = currentTime; // If a scheduler task throws, exit the current browser task so the | ||
| // error can be observed. | ||
| // | ||
| // Intentionally not using a try-catch, since that makes some debugging | ||
| // techniques harder. Instead, if `flushWork` errors, then `hasMoreWork` will | ||
| // remain true, and we'll continue the work loop. | ||
| var hasMoreWork = true; | ||
| try { | ||
| hasMoreWork = flushWork(currentTime); | ||
| } finally { | ||
| if (hasMoreWork) { | ||
| // If there's more work, schedule the next message event at the end | ||
| // of the preceding one. | ||
| schedulePerformWorkUntilDeadline(); | ||
| } else { | ||
| isMessageLoopRunning = false; | ||
| var taskQueue = [], | ||
| timerQueue = [], | ||
| taskIdCounter = 1, | ||
| currentTask = null, | ||
| currentPriorityLevel = 3, | ||
| isPerformingWork = !1, | ||
| isHostCallbackScheduled = !1, | ||
| isHostTimeoutScheduled = !1, | ||
| localSetTimeout = "function" === typeof setTimeout ? setTimeout : null, | ||
| localClearTimeout = | ||
| "function" === typeof clearTimeout ? clearTimeout : null, | ||
| localSetImmediate = | ||
| "undefined" !== typeof setImmediate ? setImmediate : null, | ||
| isMessageLoopRunning = !1, | ||
| taskTimeoutID = -1, | ||
| frameInterval = 5, | ||
| startTime = -1; | ||
| if ("function" === typeof localSetImmediate) | ||
| var schedulePerformWorkUntilDeadline = function () { | ||
| localSetImmediate(performWorkUntilDeadline); | ||
| }; | ||
| else if ("undefined" !== typeof MessageChannel) { | ||
| var channel = new MessageChannel(), | ||
| port = channel.port2; | ||
| channel.port1.onmessage = performWorkUntilDeadline; | ||
| schedulePerformWorkUntilDeadline = function () { | ||
| port.postMessage(null); | ||
| }; | ||
| } else | ||
| schedulePerformWorkUntilDeadline = function () { | ||
| localSetTimeout(performWorkUntilDeadline, 0); | ||
| }; | ||
| exports.unstable_IdlePriority = 5; | ||
| exports.unstable_ImmediatePriority = 1; | ||
| exports.unstable_LowPriority = 4; | ||
| exports.unstable_NormalPriority = 3; | ||
| exports.unstable_Profiling = null; | ||
| exports.unstable_UserBlockingPriority = 2; | ||
| exports.unstable_cancelCallback = function (task) { | ||
| task.callback = null; | ||
| }; | ||
| exports.unstable_continueExecution = function () { | ||
| isHostCallbackScheduled || | ||
| isPerformingWork || | ||
| ((isHostCallbackScheduled = !0), requestHostCallback()); | ||
| }; | ||
| exports.unstable_forceFrameRate = function (fps) { | ||
| 0 > fps || 125 < fps | ||
| ? console.error( | ||
| "forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported" | ||
| ) | ||
| : (frameInterval = 0 < fps ? Math.floor(1e3 / fps) : 5); | ||
| }; | ||
| exports.unstable_getCurrentPriorityLevel = function () { | ||
| return currentPriorityLevel; | ||
| }; | ||
| exports.unstable_getFirstCallbackNode = function () { | ||
| return peek(taskQueue); | ||
| }; | ||
| exports.unstable_next = function (eventHandler) { | ||
| switch (currentPriorityLevel) { | ||
| case 1: | ||
| case 2: | ||
| case 3: | ||
| var priorityLevel = 3; | ||
| break; | ||
| default: | ||
| priorityLevel = currentPriorityLevel; | ||
| } | ||
| } | ||
| } | ||
| }; | ||
| var schedulePerformWorkUntilDeadline; | ||
| if (typeof localSetImmediate === 'function') { | ||
| // Node.js and old IE. | ||
| // There's a few reasons for why we prefer setImmediate. | ||
| // | ||
| // Unlike MessageChannel, it doesn't prevent a Node.js process from exiting. | ||
| // (Even though this is a DOM fork of the Scheduler, you could get here | ||
| // with a mix of Node.js 15+, which has a MessageChannel, and jsdom.) | ||
| // https://github.com/facebook/react/issues/20756 | ||
| // | ||
| // But also, it runs earlier which is the semantic we want. | ||
| // If other browsers ever implement it, it's better to use it. | ||
| // Although both of these would be inferior to native scheduling. | ||
| schedulePerformWorkUntilDeadline = function () { | ||
| localSetImmediate(performWorkUntilDeadline); | ||
| }; | ||
| } else if (typeof MessageChannel !== 'undefined') { | ||
| // DOM and Worker environments. | ||
| // We prefer MessageChannel because of the 4ms setTimeout clamping. | ||
| var channel = new MessageChannel(); | ||
| var port = channel.port2; | ||
| channel.port1.onmessage = performWorkUntilDeadline; | ||
| schedulePerformWorkUntilDeadline = function () { | ||
| port.postMessage(null); | ||
| }; | ||
| } else { | ||
| // We should only fallback here in non-browser environments. | ||
| schedulePerformWorkUntilDeadline = function () { | ||
| // $FlowFixMe[not-a-function] nullable value | ||
| localSetTimeout(performWorkUntilDeadline, 0); | ||
| }; | ||
| } | ||
| function requestHostCallback() { | ||
| if (!isMessageLoopRunning) { | ||
| isMessageLoopRunning = true; | ||
| schedulePerformWorkUntilDeadline(); | ||
| } | ||
| } | ||
| function requestHostTimeout(callback, ms) { | ||
| // $FlowFixMe[not-a-function] nullable value | ||
| taskTimeoutID = localSetTimeout(function () { | ||
| callback(exports.unstable_now()); | ||
| }, ms); | ||
| } | ||
| function cancelHostTimeout() { | ||
| // $FlowFixMe[not-a-function] nullable value | ||
| localClearTimeout(taskTimeoutID); | ||
| taskTimeoutID = -1; | ||
| } | ||
| var unstable_Profiling = null; | ||
| exports.unstable_IdlePriority = IdlePriority; | ||
| exports.unstable_ImmediatePriority = ImmediatePriority; | ||
| exports.unstable_LowPriority = LowPriority; | ||
| exports.unstable_NormalPriority = NormalPriority; | ||
| exports.unstable_Profiling = unstable_Profiling; | ||
| exports.unstable_UserBlockingPriority = UserBlockingPriority; | ||
| exports.unstable_cancelCallback = unstable_cancelCallback; | ||
| exports.unstable_continueExecution = unstable_continueExecution; | ||
| exports.unstable_forceFrameRate = forceFrameRate; | ||
| exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel; | ||
| exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode; | ||
| exports.unstable_next = unstable_next; | ||
| exports.unstable_pauseExecution = unstable_pauseExecution; | ||
| exports.unstable_requestPaint = requestPaint; | ||
| exports.unstable_runWithPriority = unstable_runWithPriority; | ||
| exports.unstable_scheduleCallback = unstable_scheduleCallback; | ||
| exports.unstable_shouldYield = shouldYieldToHost; | ||
| exports.unstable_wrapCallback = unstable_wrapCallback; | ||
| if ( | ||
| typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' && | ||
| typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === | ||
| 'function' | ||
| ) { | ||
| __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error()); | ||
| } | ||
| var previousPriorityLevel = currentPriorityLevel; | ||
| currentPriorityLevel = priorityLevel; | ||
| try { | ||
| return eventHandler(); | ||
| } finally { | ||
| currentPriorityLevel = previousPriorityLevel; | ||
| } | ||
| }; | ||
| exports.unstable_pauseExecution = function () {}; | ||
| exports.unstable_requestPaint = function () {}; | ||
| exports.unstable_runWithPriority = function (priorityLevel, eventHandler) { | ||
| switch (priorityLevel) { | ||
| case 1: | ||
| case 2: | ||
| case 3: | ||
| case 4: | ||
| case 5: | ||
| break; | ||
| default: | ||
| priorityLevel = 3; | ||
| } | ||
| var previousPriorityLevel = currentPriorityLevel; | ||
| currentPriorityLevel = priorityLevel; | ||
| try { | ||
| return eventHandler(); | ||
| } finally { | ||
| currentPriorityLevel = previousPriorityLevel; | ||
| } | ||
| }; | ||
| exports.unstable_scheduleCallback = function ( | ||
| priorityLevel, | ||
| callback, | ||
| options | ||
| ) { | ||
| var currentTime = exports.unstable_now(); | ||
| "object" === typeof options && null !== options | ||
| ? ((options = options.delay), | ||
| (options = | ||
| "number" === typeof options && 0 < options | ||
| ? currentTime + options | ||
| : currentTime)) | ||
| : (options = currentTime); | ||
| switch (priorityLevel) { | ||
| case 1: | ||
| var timeout = -1; | ||
| break; | ||
| case 2: | ||
| timeout = 250; | ||
| break; | ||
| case 5: | ||
| timeout = 1073741823; | ||
| break; | ||
| case 4: | ||
| timeout = 1e4; | ||
| break; | ||
| default: | ||
| timeout = 5e3; | ||
| } | ||
| timeout = options + timeout; | ||
| priorityLevel = { | ||
| id: taskIdCounter++, | ||
| callback: callback, | ||
| priorityLevel: priorityLevel, | ||
| startTime: options, | ||
| expirationTime: timeout, | ||
| sortIndex: -1 | ||
| }; | ||
| options > currentTime | ||
| ? ((priorityLevel.sortIndex = options), | ||
| push(timerQueue, priorityLevel), | ||
| null === peek(taskQueue) && | ||
| priorityLevel === peek(timerQueue) && | ||
| (isHostTimeoutScheduled | ||
| ? (localClearTimeout(taskTimeoutID), (taskTimeoutID = -1)) | ||
| : (isHostTimeoutScheduled = !0), | ||
| requestHostTimeout(handleTimeout, options - currentTime))) | ||
| : ((priorityLevel.sortIndex = timeout), | ||
| push(taskQueue, priorityLevel), | ||
| isHostCallbackScheduled || | ||
| isPerformingWork || | ||
| ((isHostCallbackScheduled = !0), requestHostCallback())); | ||
| return priorityLevel; | ||
| }; | ||
| exports.unstable_shouldYield = shouldYieldToHost; | ||
| exports.unstable_wrapCallback = function (callback) { | ||
| var parentPriorityLevel = currentPriorityLevel; | ||
| return function () { | ||
| var previousPriorityLevel = currentPriorityLevel; | ||
| currentPriorityLevel = parentPriorityLevel; | ||
| try { | ||
| return callback.apply(this, arguments); | ||
| } finally { | ||
| currentPriorityLevel = previousPriorityLevel; | ||
| } | ||
| }; | ||
| }; | ||
| "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && | ||
| "function" === | ||
| typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && | ||
| __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error()); | ||
| })(); | ||
| } |
@@ -11,529 +11,336 @@ /** | ||
| 'use strict'; | ||
| "use strict"; | ||
| "production" !== process.env.NODE_ENV && | ||
| (function () { | ||
| function performWorkUntilDeadline() { | ||
| if (isMessageLoopRunning) { | ||
| var currentTime = getCurrentTime(); | ||
| startTime = currentTime; | ||
| var hasMoreWork = !0; | ||
| try { | ||
| a: { | ||
| isHostCallbackScheduled = !1; | ||
| isHostTimeoutScheduled && | ||
| ((isHostTimeoutScheduled = !1), | ||
| localClearTimeout(taskTimeoutID), | ||
| (taskTimeoutID = -1)); | ||
| isPerformingWork = !0; | ||
| var previousPriorityLevel = currentPriorityLevel; | ||
| try { | ||
| b: { | ||
| advanceTimers(currentTime); | ||
| for ( | ||
| currentTask = peek(taskQueue); | ||
| null !== currentTask && | ||
| !( | ||
| currentTask.expirationTime > currentTime && | ||
| shouldYieldToHost() | ||
| ); | ||
| if (process.env.NODE_ENV !== "production") { | ||
| (function() { | ||
| 'use strict'; | ||
| var enableSchedulerDebugging = false; | ||
| var enableProfiling = false; | ||
| var frameYieldMs = 5; | ||
| var userBlockingPriorityTimeout = 250; | ||
| var normalPriorityTimeout = 5000; | ||
| var lowPriorityTimeout = 10000; | ||
| function push(heap, node) { | ||
| var index = heap.length; | ||
| heap.push(node); | ||
| siftUp(heap, node, index); | ||
| } | ||
| function peek(heap) { | ||
| return heap.length === 0 ? null : heap[0]; | ||
| } | ||
| function pop(heap) { | ||
| if (heap.length === 0) { | ||
| return null; | ||
| } | ||
| var first = heap[0]; | ||
| var last = heap.pop(); | ||
| if (last !== first) { | ||
| heap[0] = last; | ||
| siftDown(heap, last, 0); | ||
| } | ||
| return first; | ||
| } | ||
| function siftUp(heap, node, i) { | ||
| var index = i; | ||
| while (index > 0) { | ||
| var parentIndex = index - 1 >>> 1; | ||
| var parent = heap[parentIndex]; | ||
| if (compare(parent, node) > 0) { | ||
| // The parent is larger. Swap positions. | ||
| heap[parentIndex] = node; | ||
| heap[index] = parent; | ||
| index = parentIndex; | ||
| } else { | ||
| // The parent is smaller. Exit. | ||
| return; | ||
| ) { | ||
| var callback = currentTask.callback; | ||
| if ("function" === typeof callback) { | ||
| currentTask.callback = null; | ||
| currentPriorityLevel = currentTask.priorityLevel; | ||
| var continuationCallback = callback( | ||
| currentTask.expirationTime <= currentTime | ||
| ); | ||
| currentTime = getCurrentTime(); | ||
| if ("function" === typeof continuationCallback) { | ||
| currentTask.callback = continuationCallback; | ||
| advanceTimers(currentTime); | ||
| hasMoreWork = !0; | ||
| break b; | ||
| } | ||
| currentTask === peek(taskQueue) && pop(taskQueue); | ||
| advanceTimers(currentTime); | ||
| } else pop(taskQueue); | ||
| currentTask = peek(taskQueue); | ||
| } | ||
| if (null !== currentTask) hasMoreWork = !0; | ||
| else { | ||
| var firstTimer = peek(timerQueue); | ||
| null !== firstTimer && | ||
| requestHostTimeout( | ||
| handleTimeout, | ||
| firstTimer.startTime - currentTime | ||
| ); | ||
| hasMoreWork = !1; | ||
| } | ||
| } | ||
| break a; | ||
| } finally { | ||
| (currentTask = null), | ||
| (currentPriorityLevel = previousPriorityLevel), | ||
| (isPerformingWork = !1); | ||
| } | ||
| hasMoreWork = void 0; | ||
| } | ||
| } finally { | ||
| hasMoreWork | ||
| ? schedulePerformWorkUntilDeadline() | ||
| : (isMessageLoopRunning = !1); | ||
| } | ||
| } | ||
| } | ||
| } | ||
| } | ||
| function siftDown(heap, node, i) { | ||
| var index = i; | ||
| var length = heap.length; | ||
| var halfLength = length >>> 1; | ||
| while (index < halfLength) { | ||
| var leftIndex = (index + 1) * 2 - 1; | ||
| var left = heap[leftIndex]; | ||
| var rightIndex = leftIndex + 1; | ||
| var right = heap[rightIndex]; // If the left or right node is smaller, swap with the smaller of those. | ||
| if (compare(left, node) < 0) { | ||
| if (rightIndex < length && compare(right, left) < 0) { | ||
| heap[index] = right; | ||
| heap[rightIndex] = node; | ||
| index = rightIndex; | ||
| } else { | ||
| heap[index] = left; | ||
| heap[leftIndex] = node; | ||
| index = leftIndex; | ||
| function push(heap, node) { | ||
| var index = heap.length; | ||
| heap.push(node); | ||
| a: for (; 0 < index; ) { | ||
| var parentIndex = (index - 1) >>> 1, | ||
| parent = heap[parentIndex]; | ||
| if (0 < compare(parent, node)) | ||
| (heap[parentIndex] = node), | ||
| (heap[index] = parent), | ||
| (index = parentIndex); | ||
| else break a; | ||
| } | ||
| } else if (rightIndex < length && compare(right, node) < 0) { | ||
| heap[index] = right; | ||
| heap[rightIndex] = node; | ||
| index = rightIndex; | ||
| } else { | ||
| // Neither child is smaller. Exit. | ||
| return; | ||
| } | ||
| } | ||
| } | ||
| function compare(a, b) { | ||
| // Compare sort index first, then task id. | ||
| var diff = a.sortIndex - b.sortIndex; | ||
| return diff !== 0 ? diff : a.id - b.id; | ||
| } | ||
| // TODO: Use symbols? | ||
| var ImmediatePriority = 1; | ||
| var UserBlockingPriority = 2; | ||
| var NormalPriority = 3; | ||
| var LowPriority = 4; | ||
| var IdlePriority = 5; | ||
| function markTaskErrored(task, ms) { | ||
| } | ||
| /* eslint-disable no-var */ | ||
| var getCurrentTime; | ||
| var hasPerformanceNow = // $FlowFixMe[method-unbinding] | ||
| typeof performance === 'object' && typeof performance.now === 'function'; | ||
| if (hasPerformanceNow) { | ||
| var localPerformance = performance; | ||
| getCurrentTime = function () { | ||
| return localPerformance.now(); | ||
| }; | ||
| } else { | ||
| var localDate = Date; | ||
| var initialTime = localDate.now(); | ||
| getCurrentTime = function () { | ||
| return localDate.now() - initialTime; | ||
| }; | ||
| } // Max 31 bit integer. The max integer size in V8 for 32-bit systems. | ||
| // Math.pow(2, 30) - 1 | ||
| // 0b111111111111111111111111111111 | ||
| var maxSigned31BitInt = 1073741823; // Tasks are stored on a min heap | ||
| var taskQueue = []; | ||
| var timerQueue = []; // Incrementing id counter. Used to maintain insertion order. | ||
| var taskIdCounter = 1; // Pausing the scheduler is useful for debugging. | ||
| var currentTask = null; | ||
| var currentPriorityLevel = NormalPriority; // This is set while performing work, to prevent re-entrance. | ||
| var isPerformingWork = false; | ||
| var isHostCallbackScheduled = false; | ||
| var isHostTimeoutScheduled = false; // Capture local references to native APIs, in case a polyfill overrides them. | ||
| var localSetTimeout = typeof setTimeout === 'function' ? setTimeout : null; | ||
| var localClearTimeout = typeof clearTimeout === 'function' ? clearTimeout : null; | ||
| var localSetImmediate = typeof setImmediate !== 'undefined' ? setImmediate : null; // IE and Node.js + jsdom | ||
| function advanceTimers(currentTime) { | ||
| // Check for tasks that are no longer delayed and add them to the queue. | ||
| var timer = peek(timerQueue); | ||
| while (timer !== null) { | ||
| if (timer.callback === null) { | ||
| // Timer was cancelled. | ||
| pop(timerQueue); | ||
| } else if (timer.startTime <= currentTime) { | ||
| // Timer fired. Transfer to the task queue. | ||
| pop(timerQueue); | ||
| timer.sortIndex = timer.expirationTime; | ||
| push(taskQueue, timer); | ||
| } else { | ||
| // Remaining timers are pending. | ||
| return; | ||
| function peek(heap) { | ||
| return 0 === heap.length ? null : heap[0]; | ||
| } | ||
| function pop(heap) { | ||
| if (0 === heap.length) return null; | ||
| var first = heap[0], | ||
| last = heap.pop(); | ||
| if (last !== first) { | ||
| heap[0] = last; | ||
| a: for ( | ||
| var index = 0, length = heap.length, halfLength = length >>> 1; | ||
| index < halfLength; | ||
| timer = peek(timerQueue); | ||
| } | ||
| } | ||
| function handleTimeout(currentTime) { | ||
| isHostTimeoutScheduled = false; | ||
| advanceTimers(currentTime); | ||
| if (!isHostCallbackScheduled) { | ||
| if (peek(taskQueue) !== null) { | ||
| isHostCallbackScheduled = true; | ||
| requestHostCallback(); | ||
| } else { | ||
| var firstTimer = peek(timerQueue); | ||
| if (firstTimer !== null) { | ||
| requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime); | ||
| ) { | ||
| var leftIndex = 2 * (index + 1) - 1, | ||
| left = heap[leftIndex], | ||
| rightIndex = leftIndex + 1, | ||
| right = heap[rightIndex]; | ||
| if (0 > compare(left, last)) | ||
| rightIndex < length && 0 > compare(right, left) | ||
| ? ((heap[index] = right), | ||
| (heap[rightIndex] = last), | ||
| (index = rightIndex)) | ||
| : ((heap[index] = left), | ||
| (heap[leftIndex] = last), | ||
| (index = leftIndex)); | ||
| else if (rightIndex < length && 0 > compare(right, last)) | ||
| (heap[index] = right), | ||
| (heap[rightIndex] = last), | ||
| (index = rightIndex); | ||
| else break a; | ||
| } | ||
| } | ||
| return first; | ||
| } | ||
| } | ||
| } | ||
| function flushWork(initialTime) { | ||
| isHostCallbackScheduled = false; | ||
| if (isHostTimeoutScheduled) { | ||
| // We scheduled a timeout but it's no longer needed. Cancel it. | ||
| isHostTimeoutScheduled = false; | ||
| cancelHostTimeout(); | ||
| } | ||
| isPerformingWork = true; | ||
| var previousPriorityLevel = currentPriorityLevel; | ||
| try { | ||
| var currentTime; if (enableProfiling) ; else { | ||
| // No catch in prod code path. | ||
| return workLoop(initialTime); | ||
| function compare(a, b) { | ||
| var diff = a.sortIndex - b.sortIndex; | ||
| return 0 !== diff ? diff : a.id - b.id; | ||
| } | ||
| } finally { | ||
| currentTask = null; | ||
| currentPriorityLevel = previousPriorityLevel; | ||
| isPerformingWork = false; | ||
| } | ||
| } | ||
| function workLoop(initialTime) { | ||
| var currentTime = initialTime; | ||
| advanceTimers(currentTime); | ||
| currentTask = peek(taskQueue); | ||
| while (currentTask !== null && !(enableSchedulerDebugging )) { | ||
| if (currentTask.expirationTime > currentTime && shouldYieldToHost()) { | ||
| // This currentTask hasn't expired, and we've reached the deadline. | ||
| break; | ||
| } // $FlowFixMe[incompatible-use] found when upgrading Flow | ||
| var callback = currentTask.callback; | ||
| if (typeof callback === 'function') { | ||
| // $FlowFixMe[incompatible-use] found when upgrading Flow | ||
| currentTask.callback = null; // $FlowFixMe[incompatible-use] found when upgrading Flow | ||
| currentPriorityLevel = currentTask.priorityLevel; // $FlowFixMe[incompatible-use] found when upgrading Flow | ||
| var didUserCallbackTimeout = currentTask.expirationTime <= currentTime; | ||
| var continuationCallback = callback(didUserCallbackTimeout); | ||
| currentTime = getCurrentTime(); | ||
| if (typeof continuationCallback === 'function') { | ||
| // If a continuation is returned, immediately yield to the main thread | ||
| // regardless of how much time is left in the current time slice. | ||
| // $FlowFixMe[incompatible-use] found when upgrading Flow | ||
| currentTask.callback = continuationCallback; | ||
| advanceTimers(currentTime); | ||
| return true; | ||
| } else { | ||
| if (currentTask === peek(taskQueue)) { | ||
| pop(taskQueue); | ||
| function advanceTimers(currentTime) { | ||
| for (var timer = peek(timerQueue); null !== timer; ) { | ||
| if (null === timer.callback) pop(timerQueue); | ||
| else if (timer.startTime <= currentTime) | ||
| pop(timerQueue), | ||
| (timer.sortIndex = timer.expirationTime), | ||
| push(taskQueue, timer); | ||
| else break; | ||
| timer = peek(timerQueue); | ||
| } | ||
| } | ||
| function handleTimeout(currentTime) { | ||
| isHostTimeoutScheduled = !1; | ||
| advanceTimers(currentTime); | ||
| if (!isHostCallbackScheduled) | ||
| if (null !== peek(taskQueue)) | ||
| (isHostCallbackScheduled = !0), | ||
| isMessageLoopRunning || | ||
| ((isMessageLoopRunning = !0), schedulePerformWorkUntilDeadline()); | ||
| else { | ||
| var firstTimer = peek(timerQueue); | ||
| null !== firstTimer && | ||
| requestHostTimeout( | ||
| handleTimeout, | ||
| firstTimer.startTime - currentTime | ||
| ); | ||
| } | ||
| advanceTimers(currentTime); | ||
| } | ||
| function unstable_scheduleCallback$1(priorityLevel, callback, options) { | ||
| var currentTime = getCurrentTime(); | ||
| "object" === typeof options && null !== options | ||
| ? ((options = options.delay), | ||
| (options = | ||
| "number" === typeof options && 0 < options | ||
| ? currentTime + options | ||
| : currentTime)) | ||
| : (options = currentTime); | ||
| switch (priorityLevel) { | ||
| case 1: | ||
| var timeout = -1; | ||
| break; | ||
| case 2: | ||
| timeout = 250; | ||
| break; | ||
| case 5: | ||
| timeout = 1073741823; | ||
| break; | ||
| case 4: | ||
| timeout = 1e4; | ||
| break; | ||
| default: | ||
| timeout = 5e3; | ||
| } | ||
| } else { | ||
| pop(taskQueue); | ||
| timeout = options + timeout; | ||
| priorityLevel = { | ||
| id: taskIdCounter++, | ||
| callback: callback, | ||
| priorityLevel: priorityLevel, | ||
| startTime: options, | ||
| expirationTime: timeout, | ||
| sortIndex: -1 | ||
| }; | ||
| options > currentTime | ||
| ? ((priorityLevel.sortIndex = options), | ||
| push(timerQueue, priorityLevel), | ||
| null === peek(taskQueue) && | ||
| priorityLevel === peek(timerQueue) && | ||
| (isHostTimeoutScheduled | ||
| ? (localClearTimeout(taskTimeoutID), (taskTimeoutID = -1)) | ||
| : (isHostTimeoutScheduled = !0), | ||
| requestHostTimeout(handleTimeout, options - currentTime))) | ||
| : ((priorityLevel.sortIndex = timeout), | ||
| push(taskQueue, priorityLevel), | ||
| isHostCallbackScheduled || | ||
| isPerformingWork || | ||
| ((isHostCallbackScheduled = !0), | ||
| isMessageLoopRunning || | ||
| ((isMessageLoopRunning = !0), | ||
| schedulePerformWorkUntilDeadline()))); | ||
| return priorityLevel; | ||
| } | ||
| currentTask = peek(taskQueue); | ||
| } // Return whether there's additional work | ||
| if (currentTask !== null) { | ||
| return true; | ||
| } else { | ||
| var firstTimer = peek(timerQueue); | ||
| if (firstTimer !== null) { | ||
| requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime); | ||
| function unstable_cancelCallback$1(task) { | ||
| task.callback = null; | ||
| } | ||
| return false; | ||
| } | ||
| } | ||
| function unstable_scheduleCallback$1(priorityLevel, callback, options) { | ||
| var currentTime = getCurrentTime(); | ||
| var startTime; | ||
| if (typeof options === 'object' && options !== null) { | ||
| var delay = options.delay; | ||
| if (typeof delay === 'number' && delay > 0) { | ||
| startTime = currentTime + delay; | ||
| } else { | ||
| startTime = currentTime; | ||
| function unstable_getCurrentPriorityLevel$1() { | ||
| return currentPriorityLevel; | ||
| } | ||
| } else { | ||
| startTime = currentTime; | ||
| } | ||
| var timeout; | ||
| switch (priorityLevel) { | ||
| case ImmediatePriority: | ||
| // Times out immediately | ||
| timeout = -1; | ||
| break; | ||
| case UserBlockingPriority: | ||
| // Eventually times out | ||
| timeout = userBlockingPriorityTimeout; | ||
| break; | ||
| case IdlePriority: | ||
| // Never times out | ||
| timeout = maxSigned31BitInt; | ||
| break; | ||
| case LowPriority: | ||
| // Eventually times out | ||
| timeout = lowPriorityTimeout; | ||
| break; | ||
| case NormalPriority: | ||
| default: | ||
| // Eventually times out | ||
| timeout = normalPriorityTimeout; | ||
| break; | ||
| } | ||
| var expirationTime = startTime + timeout; | ||
| var newTask = { | ||
| id: taskIdCounter++, | ||
| callback: callback, | ||
| priorityLevel: priorityLevel, | ||
| startTime: startTime, | ||
| expirationTime: expirationTime, | ||
| sortIndex: -1 | ||
| }; | ||
| if (startTime > currentTime) { | ||
| // This is a delayed task. | ||
| newTask.sortIndex = startTime; | ||
| push(timerQueue, newTask); | ||
| if (peek(taskQueue) === null && newTask === peek(timerQueue)) { | ||
| // All tasks are delayed, and this is the task with the earliest delay. | ||
| if (isHostTimeoutScheduled) { | ||
| // Cancel an existing timeout. | ||
| cancelHostTimeout(); | ||
| } else { | ||
| isHostTimeoutScheduled = true; | ||
| } // Schedule a timeout. | ||
| requestHostTimeout(handleTimeout, startTime - currentTime); | ||
| function shouldYieldToHost() { | ||
| return getCurrentTime() - startTime < frameInterval ? !1 : !0; | ||
| } | ||
| } else { | ||
| newTask.sortIndex = expirationTime; | ||
| push(taskQueue, newTask); | ||
| // wait until the next time we yield. | ||
| if (!isHostCallbackScheduled && !isPerformingWork) { | ||
| isHostCallbackScheduled = true; | ||
| requestHostCallback(); | ||
| function requestPaint() {} | ||
| function requestHostTimeout(callback, ms) { | ||
| taskTimeoutID = localSetTimeout(function () { | ||
| callback(getCurrentTime()); | ||
| }, ms); | ||
| } | ||
| } | ||
| return newTask; | ||
| } | ||
| function unstable_cancelCallback$1(task) { | ||
| // remove from the queue because you can't remove arbitrary nodes from an | ||
| // array based heap, only the first one.) | ||
| task.callback = null; | ||
| } | ||
| function unstable_getCurrentPriorityLevel$1() { | ||
| return currentPriorityLevel; | ||
| } | ||
| var isMessageLoopRunning = false; | ||
| var taskTimeoutID = -1; // Scheduler periodically yields in case there is other work on the main | ||
| // thread, like user events. By default, it yields multiple times per frame. | ||
| // It does not attempt to align with frame boundaries, since most tasks don't | ||
| // need to be frame aligned; for those that do, use requestAnimationFrame. | ||
| var frameInterval = frameYieldMs; | ||
| var startTime = -1; | ||
| function shouldYieldToHost() { | ||
| var timeElapsed = getCurrentTime() - startTime; | ||
| if (timeElapsed < frameInterval) { | ||
| // The main thread has only been blocked for a really short amount of time; | ||
| // smaller than a single frame. Don't yield yet. | ||
| return false; | ||
| } // Yield now. | ||
| return true; | ||
| } | ||
| function requestPaint() {} | ||
| var performWorkUntilDeadline = function () { | ||
| if (isMessageLoopRunning) { | ||
| var currentTime = getCurrentTime(); // Keep track of the start time so we can measure how long the main thread | ||
| // has been blocked. | ||
| startTime = currentTime; // If a scheduler task throws, exit the current browser task so the | ||
| // error can be observed. | ||
| // | ||
| // Intentionally not using a try-catch, since that makes some debugging | ||
| // techniques harder. Instead, if `flushWork` errors, then `hasMoreWork` will | ||
| // remain true, and we'll continue the work loop. | ||
| var hasMoreWork = true; | ||
| try { | ||
| hasMoreWork = flushWork(currentTime); | ||
| } finally { | ||
| if (hasMoreWork) { | ||
| // If there's more work, schedule the next message event at the end | ||
| // of the preceding one. | ||
| schedulePerformWorkUntilDeadline(); | ||
| } else { | ||
| isMessageLoopRunning = false; | ||
| } | ||
| function throwNotImplemented() { | ||
| throw Error("Not implemented."); | ||
| } | ||
| } | ||
| }; | ||
| var schedulePerformWorkUntilDeadline; | ||
| if (typeof localSetImmediate === 'function') { | ||
| // Node.js and old IE. | ||
| // There's a few reasons for why we prefer setImmediate. | ||
| // | ||
| // Unlike MessageChannel, it doesn't prevent a Node.js process from exiting. | ||
| // (Even though this is a DOM fork of the Scheduler, you could get here | ||
| // with a mix of Node.js 15+, which has a MessageChannel, and jsdom.) | ||
| // https://github.com/facebook/react/issues/20756 | ||
| // | ||
| // But also, it runs earlier which is the semantic we want. | ||
| // If other browsers ever implement it, it's better to use it. | ||
| // Although both of these would be inferior to native scheduling. | ||
| schedulePerformWorkUntilDeadline = function () { | ||
| localSetImmediate(performWorkUntilDeadline); | ||
| }; | ||
| } else if (typeof MessageChannel !== 'undefined') { | ||
| // DOM and Worker environments. | ||
| // We prefer MessageChannel because of the 4ms setTimeout clamping. | ||
| var channel = new MessageChannel(); | ||
| var port = channel.port2; | ||
| channel.port1.onmessage = performWorkUntilDeadline; | ||
| schedulePerformWorkUntilDeadline = function () { | ||
| port.postMessage(null); | ||
| }; | ||
| } else { | ||
| // We should only fallback here in non-browser environments. | ||
| schedulePerformWorkUntilDeadline = function () { | ||
| // $FlowFixMe[not-a-function] nullable value | ||
| localSetTimeout(performWorkUntilDeadline, 0); | ||
| }; | ||
| } | ||
| function requestHostCallback() { | ||
| if (!isMessageLoopRunning) { | ||
| isMessageLoopRunning = true; | ||
| schedulePerformWorkUntilDeadline(); | ||
| } | ||
| } | ||
| function requestHostTimeout(callback, ms) { | ||
| // $FlowFixMe[not-a-function] nullable value | ||
| taskTimeoutID = localSetTimeout(function () { | ||
| callback(getCurrentTime()); | ||
| }, ms); | ||
| } | ||
| function cancelHostTimeout() { | ||
| // $FlowFixMe[not-a-function] nullable value | ||
| localClearTimeout(taskTimeoutID); | ||
| taskTimeoutID = -1; | ||
| } | ||
| // https://github.com/facebook/react-native/blob/main/packages/react-native/ReactCommon/react/renderer/runtimescheduler/RuntimeSchedulerBinding.cpp | ||
| var unstable_UserBlockingPriority = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_UserBlockingPriority : UserBlockingPriority; | ||
| var unstable_NormalPriority = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_NormalPriority : NormalPriority; | ||
| var unstable_IdlePriority = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_IdlePriority : IdlePriority; | ||
| var unstable_LowPriority = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_LowPriority : LowPriority; | ||
| var unstable_ImmediatePriority = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_ImmediatePriority : ImmediatePriority; | ||
| var unstable_scheduleCallback = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_scheduleCallback : unstable_scheduleCallback$1; | ||
| var unstable_cancelCallback = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_cancelCallback : unstable_cancelCallback$1; | ||
| var unstable_getCurrentPriorityLevel = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_getCurrentPriorityLevel : unstable_getCurrentPriorityLevel$1; | ||
| var unstable_shouldYield = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_shouldYield : shouldYieldToHost; | ||
| var unstable_requestPaint = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_requestPaint : requestPaint; | ||
| var unstable_now = typeof nativeRuntimeScheduler !== 'undefined' ? nativeRuntimeScheduler.unstable_now : getCurrentTime; // These were never implemented on the native scheduler because React never calls them. | ||
| // For consistency, let's disable them altogether and make them throw. | ||
| var unstable_next = throwNotImplemented; | ||
| var unstable_runWithPriority = throwNotImplemented; | ||
| var unstable_wrapCallback = throwNotImplemented; | ||
| var unstable_continueExecution = throwNotImplemented; | ||
| var unstable_pauseExecution = throwNotImplemented; | ||
| var unstable_getFirstCallbackNode = throwNotImplemented; | ||
| var unstable_forceFrameRate = throwNotImplemented; | ||
| var unstable_Profiling = null; | ||
| function throwNotImplemented() { | ||
| throw Error('Not implemented.'); | ||
| } // Flow magic to verify the exports of this file match the original version. | ||
| exports.unstable_IdlePriority = unstable_IdlePriority; | ||
| exports.unstable_ImmediatePriority = unstable_ImmediatePriority; | ||
| exports.unstable_LowPriority = unstable_LowPriority; | ||
| exports.unstable_NormalPriority = unstable_NormalPriority; | ||
| exports.unstable_Profiling = unstable_Profiling; | ||
| exports.unstable_UserBlockingPriority = unstable_UserBlockingPriority; | ||
| exports.unstable_cancelCallback = unstable_cancelCallback; | ||
| exports.unstable_continueExecution = unstable_continueExecution; | ||
| exports.unstable_forceFrameRate = unstable_forceFrameRate; | ||
| exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel; | ||
| exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode; | ||
| exports.unstable_next = unstable_next; | ||
| exports.unstable_now = unstable_now; | ||
| exports.unstable_pauseExecution = unstable_pauseExecution; | ||
| exports.unstable_requestPaint = unstable_requestPaint; | ||
| exports.unstable_runWithPriority = unstable_runWithPriority; | ||
| exports.unstable_scheduleCallback = unstable_scheduleCallback; | ||
| exports.unstable_shouldYield = unstable_shouldYield; | ||
| exports.unstable_wrapCallback = unstable_wrapCallback; | ||
| if ( | ||
| "object" === typeof performance && | ||
| "function" === typeof performance.now | ||
| ) { | ||
| var localPerformance = performance; | ||
| var getCurrentTime = function () { | ||
| return localPerformance.now(); | ||
| }; | ||
| } else { | ||
| var localDate = Date, | ||
| initialTime = localDate.now(); | ||
| getCurrentTime = function () { | ||
| return localDate.now() - initialTime; | ||
| }; | ||
| } | ||
| var taskQueue = [], | ||
| timerQueue = [], | ||
| taskIdCounter = 1, | ||
| currentTask = null, | ||
| currentPriorityLevel = 3, | ||
| isPerformingWork = !1, | ||
| isHostCallbackScheduled = !1, | ||
| isHostTimeoutScheduled = !1, | ||
| localSetTimeout = "function" === typeof setTimeout ? setTimeout : null, | ||
| localClearTimeout = | ||
| "function" === typeof clearTimeout ? clearTimeout : null, | ||
| localSetImmediate = | ||
| "undefined" !== typeof setImmediate ? setImmediate : null, | ||
| isMessageLoopRunning = !1, | ||
| taskTimeoutID = -1, | ||
| frameInterval = 5, | ||
| startTime = -1; | ||
| if ("function" === typeof localSetImmediate) | ||
| var schedulePerformWorkUntilDeadline = function () { | ||
| localSetImmediate(performWorkUntilDeadline); | ||
| }; | ||
| else if ("undefined" !== typeof MessageChannel) { | ||
| var channel = new MessageChannel(), | ||
| port = channel.port2; | ||
| channel.port1.onmessage = performWorkUntilDeadline; | ||
| schedulePerformWorkUntilDeadline = function () { | ||
| port.postMessage(null); | ||
| }; | ||
| } else | ||
| schedulePerformWorkUntilDeadline = function () { | ||
| localSetTimeout(performWorkUntilDeadline, 0); | ||
| }; | ||
| channel = | ||
| "undefined" !== typeof nativeRuntimeScheduler | ||
| ? nativeRuntimeScheduler.unstable_UserBlockingPriority | ||
| : 2; | ||
| var unstable_NormalPriority = | ||
| "undefined" !== typeof nativeRuntimeScheduler | ||
| ? nativeRuntimeScheduler.unstable_NormalPriority | ||
| : 3, | ||
| unstable_LowPriority = | ||
| "undefined" !== typeof nativeRuntimeScheduler | ||
| ? nativeRuntimeScheduler.unstable_LowPriority | ||
| : 4, | ||
| unstable_ImmediatePriority = | ||
| "undefined" !== typeof nativeRuntimeScheduler | ||
| ? nativeRuntimeScheduler.unstable_ImmediatePriority | ||
| : 1, | ||
| unstable_scheduleCallback = | ||
| "undefined" !== typeof nativeRuntimeScheduler | ||
| ? nativeRuntimeScheduler.unstable_scheduleCallback | ||
| : unstable_scheduleCallback$1, | ||
| unstable_cancelCallback = | ||
| "undefined" !== typeof nativeRuntimeScheduler | ||
| ? nativeRuntimeScheduler.unstable_cancelCallback | ||
| : unstable_cancelCallback$1, | ||
| unstable_getCurrentPriorityLevel = | ||
| "undefined" !== typeof nativeRuntimeScheduler | ||
| ? nativeRuntimeScheduler.unstable_getCurrentPriorityLevel | ||
| : unstable_getCurrentPriorityLevel$1, | ||
| unstable_shouldYield = | ||
| "undefined" !== typeof nativeRuntimeScheduler | ||
| ? nativeRuntimeScheduler.unstable_shouldYield | ||
| : shouldYieldToHost, | ||
| unstable_requestPaint = | ||
| "undefined" !== typeof nativeRuntimeScheduler | ||
| ? nativeRuntimeScheduler.unstable_requestPaint | ||
| : requestPaint, | ||
| unstable_now = | ||
| "undefined" !== typeof nativeRuntimeScheduler | ||
| ? nativeRuntimeScheduler.unstable_now | ||
| : getCurrentTime; | ||
| exports.unstable_IdlePriority = | ||
| "undefined" !== typeof nativeRuntimeScheduler | ||
| ? nativeRuntimeScheduler.unstable_IdlePriority | ||
| : 5; | ||
| exports.unstable_ImmediatePriority = unstable_ImmediatePriority; | ||
| exports.unstable_LowPriority = unstable_LowPriority; | ||
| exports.unstable_NormalPriority = unstable_NormalPriority; | ||
| exports.unstable_Profiling = null; | ||
| exports.unstable_UserBlockingPriority = channel; | ||
| exports.unstable_cancelCallback = unstable_cancelCallback; | ||
| exports.unstable_continueExecution = throwNotImplemented; | ||
| exports.unstable_forceFrameRate = throwNotImplemented; | ||
| exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel; | ||
| exports.unstable_getFirstCallbackNode = throwNotImplemented; | ||
| exports.unstable_next = throwNotImplemented; | ||
| exports.unstable_now = unstable_now; | ||
| exports.unstable_pauseExecution = throwNotImplemented; | ||
| exports.unstable_requestPaint = unstable_requestPaint; | ||
| exports.unstable_runWithPriority = throwNotImplemented; | ||
| exports.unstable_scheduleCallback = unstable_scheduleCallback; | ||
| exports.unstable_shouldYield = unstable_shouldYield; | ||
| exports.unstable_wrapCallback = throwNotImplemented; | ||
| })(); | ||
| } |
| { | ||
| "name": "scheduler", | ||
| "version": "0.25.0-rc-6230622a1a-20240610", | ||
| "version": "0.25.0-rc-64f89510-20241119", | ||
| "description": "Cooperative scheduler for the browser environment.", | ||
@@ -5,0 +5,0 @@ "repository": { |
New alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Fixed alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Worsened metrics
- Total package byte prevSize
- decreased by-15.05%
84190
- Lines of code
- decreased by-14.54%
2521
No dependency changes