b32cf4c374
Install react-router-dom to support client-side navigation. This is a prerequisite for implementing the multi-step authentication flow and other routed features. Additionally, this commit includes minor copy improvements to the password reset forms for better clarity.
415 lines
13 KiB
JavaScript
415 lines
13 KiB
JavaScript
/**
|
|
* @license React
|
|
* scheduler-unstable_mock.development.js
|
|
*
|
|
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*/
|
|
|
|
"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;
|
|
|
|
) {
|
|
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 compare(a, b) {
|
|
var diff = a.sortIndex - b.sortIndex;
|
|
return 0 !== diff ? diff : a.id - b.id;
|
|
}
|
|
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), (scheduledCallback = flushWork);
|
|
else {
|
|
var firstTimer = peek(timerQueue);
|
|
null !== firstTimer &&
|
|
((currentTime = firstTimer.startTime - currentTime),
|
|
(scheduledTimeout = handleTimeout),
|
|
(timeoutTime = currentMockTime + currentTime));
|
|
}
|
|
}
|
|
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()));
|
|
|
|
) {
|
|
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;
|
|
}
|
|
}
|
|
return JSCompiler_inline_result;
|
|
} finally {
|
|
(currentTask = null),
|
|
(currentPriorityLevel = previousPriorityLevel),
|
|
(isPerformingWork = !1);
|
|
}
|
|
}
|
|
function shouldYieldToHost() {
|
|
return (0 === expectedNumberOfYields && null === yieldedValues) ||
|
|
(-1 !== expectedNumberOfYields &&
|
|
null !== yieldedValues &&
|
|
yieldedValues.length >= expectedNumberOfYields) ||
|
|
(shouldYieldForPaint && needsPaint)
|
|
? (didStop = !0)
|
|
: !1;
|
|
}
|
|
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;
|
|
}
|
|
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;
|
|
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_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;
|
|
}
|
|
}
|
|
};
|
|
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);
|
|
}
|
|
}
|
|
};
|
|
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 !1;
|
|
};
|
|
exports.unstable_forceFrameRate = function () {};
|
|
exports.unstable_getCurrentPriorityLevel = function () {
|
|
return currentPriorityLevel;
|
|
};
|
|
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_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;
|
|
}
|
|
};
|
|
};
|
|
})();
|