the-forest/client/node_modules/@jest/fake-timers/build/legacyFakeTimers.js
2024-09-17 20:35:18 -04:00

674 lines
16 KiB
JavaScript

'use strict';
Object.defineProperty(exports, '__esModule', {
value: true
});
exports.default = void 0;
function _util() {
const data = _interopRequireDefault(require('util'));
_util = function () {
return data;
};
return data;
}
function _jestMessageUtil() {
const data = require('jest-message-util');
_jestMessageUtil = function () {
return data;
};
return data;
}
function _jestUtil() {
const data = require('jest-util');
_jestUtil = function () {
return data;
};
return data;
}
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {default: obj};
}
function _defineProperty(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
const MS_IN_A_YEAR = 31536000000;
class FakeTimers {
constructor({global, moduleMocker, timerConfig, config, maxLoops}) {
_defineProperty(this, '_cancelledTicks', void 0);
_defineProperty(this, '_config', void 0);
_defineProperty(this, '_disposed', void 0);
_defineProperty(this, '_fakeTimerAPIs', void 0);
_defineProperty(this, '_global', void 0);
_defineProperty(this, '_immediates', void 0);
_defineProperty(this, '_maxLoops', void 0);
_defineProperty(this, '_moduleMocker', void 0);
_defineProperty(this, '_now', void 0);
_defineProperty(this, '_ticks', void 0);
_defineProperty(this, '_timerAPIs', void 0);
_defineProperty(this, '_timers', void 0);
_defineProperty(this, '_uuidCounter', void 0);
_defineProperty(this, '_timerConfig', void 0);
this._global = global;
this._timerConfig = timerConfig;
this._config = config;
this._maxLoops = maxLoops || 100000;
this._uuidCounter = 1;
this._moduleMocker = moduleMocker; // Store original timer APIs for future reference
this._timerAPIs = {
cancelAnimationFrame: global.cancelAnimationFrame,
clearImmediate: global.clearImmediate,
clearInterval: global.clearInterval,
clearTimeout: global.clearTimeout,
nextTick: global.process && global.process.nextTick,
requestAnimationFrame: global.requestAnimationFrame,
setImmediate: global.setImmediate,
setInterval: global.setInterval,
setTimeout: global.setTimeout
};
this.reset();
}
clearAllTimers() {
this._immediates = [];
this._timers.clear();
}
dispose() {
this._disposed = true;
this.clearAllTimers();
}
reset() {
this._cancelledTicks = {};
this._now = 0;
this._ticks = [];
this._immediates = [];
this._timers = new Map();
}
runAllTicks() {
this._checkFakeTimers(); // Only run a generous number of ticks and then bail.
// This is just to help avoid recursive loops
let i;
for (i = 0; i < this._maxLoops; i++) {
const tick = this._ticks.shift();
if (tick === undefined) {
break;
}
if (!this._cancelledTicks.hasOwnProperty(tick.uuid)) {
// Callback may throw, so update the map prior calling.
this._cancelledTicks[tick.uuid] = true;
tick.callback();
}
}
if (i === this._maxLoops) {
throw new Error(
'Ran ' +
this._maxLoops +
' ticks, and there are still more! ' +
"Assuming we've hit an infinite recursion and bailing out..."
);
}
}
runAllImmediates() {
this._checkFakeTimers(); // Only run a generous number of immediates and then bail.
let i;
for (i = 0; i < this._maxLoops; i++) {
const immediate = this._immediates.shift();
if (immediate === undefined) {
break;
}
this._runImmediate(immediate);
}
if (i === this._maxLoops) {
throw new Error(
'Ran ' +
this._maxLoops +
' immediates, and there are still more! Assuming ' +
"we've hit an infinite recursion and bailing out..."
);
}
}
_runImmediate(immediate) {
try {
immediate.callback();
} finally {
this._fakeClearImmediate(immediate.uuid);
}
}
runAllTimers() {
this._checkFakeTimers();
this.runAllTicks();
this.runAllImmediates(); // Only run a generous number of timers and then bail.
// This is just to help avoid recursive loops
let i;
for (i = 0; i < this._maxLoops; i++) {
const nextTimerHandle = this._getNextTimerHandle(); // If there are no more timer handles, stop!
if (nextTimerHandle === null) {
break;
}
this._runTimerHandle(nextTimerHandle); // Some of the immediate calls could be enqueued
// during the previous handling of the timers, we should
// run them as well.
if (this._immediates.length) {
this.runAllImmediates();
}
if (this._ticks.length) {
this.runAllTicks();
}
}
if (i === this._maxLoops) {
throw new Error(
'Ran ' +
this._maxLoops +
' timers, and there are still more! ' +
"Assuming we've hit an infinite recursion and bailing out..."
);
}
}
runOnlyPendingTimers() {
// We need to hold the current shape of `this._timers` because existing
// timers can add new ones to the map and hence would run more than necessary.
// See https://github.com/facebook/jest/pull/4608 for details
const timerEntries = Array.from(this._timers.entries());
this._checkFakeTimers();
this._immediates.forEach(this._runImmediate, this);
timerEntries
.sort(([, left], [, right]) => left.expiry - right.expiry)
.forEach(([timerHandle]) => this._runTimerHandle(timerHandle));
}
advanceTimersToNextTimer(steps = 1) {
if (steps < 1) {
return;
}
const nextExpiry = Array.from(this._timers.values()).reduce(
(minExpiry, timer) => {
if (minExpiry === null || timer.expiry < minExpiry) return timer.expiry;
return minExpiry;
},
null
);
if (nextExpiry !== null) {
this.advanceTimersByTime(nextExpiry - this._now);
this.advanceTimersToNextTimer(steps - 1);
}
}
advanceTimersByTime(msToRun) {
this._checkFakeTimers(); // Only run a generous number of timers and then bail.
// This is just to help avoid recursive loops
let i;
for (i = 0; i < this._maxLoops; i++) {
const timerHandle = this._getNextTimerHandle(); // If there are no more timer handles, stop!
if (timerHandle === null) {
break;
}
const timerValue = this._timers.get(timerHandle);
if (timerValue === undefined) {
break;
}
const nextTimerExpiry = timerValue.expiry;
if (this._now + msToRun < nextTimerExpiry) {
// There are no timers between now and the target we're running to, so
// adjust our time cursor and quit
this._now += msToRun;
break;
} else {
msToRun -= nextTimerExpiry - this._now;
this._now = nextTimerExpiry;
this._runTimerHandle(timerHandle);
}
}
if (i === this._maxLoops) {
throw new Error(
'Ran ' +
this._maxLoops +
' timers, and there are still more! ' +
"Assuming we've hit an infinite recursion and bailing out..."
);
}
}
runWithRealTimers(cb) {
const prevClearImmediate = this._global.clearImmediate;
const prevClearInterval = this._global.clearInterval;
const prevClearTimeout = this._global.clearTimeout;
const prevNextTick = this._global.process.nextTick;
const prevSetImmediate = this._global.setImmediate;
const prevSetInterval = this._global.setInterval;
const prevSetTimeout = this._global.setTimeout;
this.useRealTimers();
let cbErr = null;
let errThrown = false;
try {
cb();
} catch (e) {
errThrown = true;
cbErr = e;
}
this._global.clearImmediate = prevClearImmediate;
this._global.clearInterval = prevClearInterval;
this._global.clearTimeout = prevClearTimeout;
this._global.process.nextTick = prevNextTick;
this._global.setImmediate = prevSetImmediate;
this._global.setInterval = prevSetInterval;
this._global.setTimeout = prevSetTimeout;
if (errThrown) {
throw cbErr;
}
}
useRealTimers() {
const global = this._global;
if (typeof global.cancelAnimationFrame === 'function') {
(0, _jestUtil().setGlobal)(
global,
'cancelAnimationFrame',
this._timerAPIs.cancelAnimationFrame
);
}
if (typeof global.clearImmediate === 'function') {
(0, _jestUtil().setGlobal)(
global,
'clearImmediate',
this._timerAPIs.clearImmediate
);
}
(0, _jestUtil().setGlobal)(
global,
'clearInterval',
this._timerAPIs.clearInterval
);
(0, _jestUtil().setGlobal)(
global,
'clearTimeout',
this._timerAPIs.clearTimeout
);
if (typeof global.requestAnimationFrame === 'function') {
(0, _jestUtil().setGlobal)(
global,
'requestAnimationFrame',
this._timerAPIs.requestAnimationFrame
);
}
if (typeof global.setImmediate === 'function') {
(0, _jestUtil().setGlobal)(
global,
'setImmediate',
this._timerAPIs.setImmediate
);
}
(0, _jestUtil().setGlobal)(
global,
'setInterval',
this._timerAPIs.setInterval
);
(0, _jestUtil().setGlobal)(
global,
'setTimeout',
this._timerAPIs.setTimeout
);
global.process.nextTick = this._timerAPIs.nextTick;
}
useFakeTimers() {
this._createMocks();
const global = this._global;
if (typeof global.cancelAnimationFrame === 'function') {
(0, _jestUtil().setGlobal)(
global,
'cancelAnimationFrame',
this._fakeTimerAPIs.cancelAnimationFrame
);
}
if (typeof global.clearImmediate === 'function') {
(0, _jestUtil().setGlobal)(
global,
'clearImmediate',
this._fakeTimerAPIs.clearImmediate
);
}
(0, _jestUtil().setGlobal)(
global,
'clearInterval',
this._fakeTimerAPIs.clearInterval
);
(0, _jestUtil().setGlobal)(
global,
'clearTimeout',
this._fakeTimerAPIs.clearTimeout
);
if (typeof global.requestAnimationFrame === 'function') {
(0, _jestUtil().setGlobal)(
global,
'requestAnimationFrame',
this._fakeTimerAPIs.requestAnimationFrame
);
}
if (typeof global.setImmediate === 'function') {
(0, _jestUtil().setGlobal)(
global,
'setImmediate',
this._fakeTimerAPIs.setImmediate
);
}
(0, _jestUtil().setGlobal)(
global,
'setInterval',
this._fakeTimerAPIs.setInterval
);
(0, _jestUtil().setGlobal)(
global,
'setTimeout',
this._fakeTimerAPIs.setTimeout
);
global.process.nextTick = this._fakeTimerAPIs.nextTick;
}
getTimerCount() {
this._checkFakeTimers();
return this._timers.size + this._immediates.length + this._ticks.length;
}
_checkFakeTimers() {
var _this$_fakeTimerAPIs;
if (
this._global.setTimeout !==
((_this$_fakeTimerAPIs = this._fakeTimerAPIs) === null ||
_this$_fakeTimerAPIs === void 0
? void 0
: _this$_fakeTimerAPIs.setTimeout)
) {
this._global.console.warn(
'A function to advance timers was called but the timers API is not ' +
'mocked with fake timers. Call `jest.useFakeTimers()` in this ' +
'test or enable fake timers globally by setting ' +
'`"timers": "fake"` in ' +
'the configuration file. This warning is likely a result of a ' +
'default configuration change in Jest 15.\n\n' +
'Release Blog Post: https://jestjs.io/blog/2016/09/01/jest-15\n' +
'Stack Trace:\n' +
(0, _jestMessageUtil().formatStackTrace)(
new Error().stack,
this._config,
{
noStackTrace: false
}
)
);
}
}
_createMocks() {
const fn = (
impl // @ts-expect-error TODO: figure out better typings here
) => this._moduleMocker.fn().mockImplementation(impl);
const promisifiableFakeSetTimeout = fn(this._fakeSetTimeout.bind(this)); // @ts-expect-error TODO: figure out better typings here
promisifiableFakeSetTimeout[_util().default.promisify.custom] = (
delay,
arg
) =>
new Promise(resolve => promisifiableFakeSetTimeout(resolve, delay, arg)); // TODO: add better typings; these are mocks, but typed as regular timers
this._fakeTimerAPIs = {
cancelAnimationFrame: fn(this._fakeClearTimer.bind(this)),
clearImmediate: fn(this._fakeClearImmediate.bind(this)),
clearInterval: fn(this._fakeClearTimer.bind(this)),
clearTimeout: fn(this._fakeClearTimer.bind(this)),
nextTick: fn(this._fakeNextTick.bind(this)),
// @ts-expect-error TODO: figure out better typings here
requestAnimationFrame: fn(this._fakeRequestAnimationFrame.bind(this)),
// @ts-expect-error TODO: figure out better typings here
setImmediate: fn(this._fakeSetImmediate.bind(this)),
// @ts-expect-error TODO: figure out better typings here
setInterval: fn(this._fakeSetInterval.bind(this)),
// @ts-expect-error TODO: figure out better typings here
setTimeout: promisifiableFakeSetTimeout
};
}
_fakeClearTimer(timerRef) {
const uuid = this._timerConfig.refToId(timerRef);
if (uuid) {
this._timers.delete(String(uuid));
}
}
_fakeClearImmediate(uuid) {
this._immediates = this._immediates.filter(
immediate => immediate.uuid !== uuid
);
}
_fakeNextTick(callback, ...args) {
if (this._disposed) {
return;
}
const uuid = String(this._uuidCounter++);
this._ticks.push({
callback: () => callback.apply(null, args),
uuid
});
const cancelledTicks = this._cancelledTicks;
this._timerAPIs.nextTick(() => {
if (!cancelledTicks.hasOwnProperty(uuid)) {
// Callback may throw, so update the map prior calling.
cancelledTicks[uuid] = true;
callback.apply(null, args);
}
});
}
_fakeRequestAnimationFrame(callback) {
return this._fakeSetTimeout(() => {
// TODO: Use performance.now() once it's mocked
callback(this._now);
}, 1000 / 60);
}
_fakeSetImmediate(callback, ...args) {
if (this._disposed) {
return null;
}
const uuid = String(this._uuidCounter++);
this._immediates.push({
callback: () => callback.apply(null, args),
uuid
});
this._timerAPIs.setImmediate(() => {
if (this._immediates.find(x => x.uuid === uuid)) {
try {
callback.apply(null, args);
} finally {
this._fakeClearImmediate(uuid);
}
}
});
return uuid;
}
_fakeSetInterval(callback, intervalDelay, ...args) {
if (this._disposed) {
return null;
}
if (intervalDelay == null) {
intervalDelay = 0;
}
const uuid = this._uuidCounter++;
this._timers.set(String(uuid), {
callback: () => callback.apply(null, args),
expiry: this._now + intervalDelay,
interval: intervalDelay,
type: 'interval'
});
return this._timerConfig.idToRef(uuid);
}
_fakeSetTimeout(callback, delay, ...args) {
if (this._disposed) {
return null;
} // eslint-disable-next-line no-bitwise
delay = Number(delay) | 0;
const uuid = this._uuidCounter++;
this._timers.set(String(uuid), {
callback: () => callback.apply(null, args),
expiry: this._now + delay,
interval: undefined,
type: 'timeout'
});
return this._timerConfig.idToRef(uuid);
}
_getNextTimerHandle() {
let nextTimerHandle = null;
let soonestTime = MS_IN_A_YEAR;
this._timers.forEach((timer, uuid) => {
if (timer.expiry < soonestTime) {
soonestTime = timer.expiry;
nextTimerHandle = uuid;
}
});
return nextTimerHandle;
}
_runTimerHandle(timerHandle) {
const timer = this._timers.get(timerHandle);
if (!timer) {
return;
}
switch (timer.type) {
case 'timeout':
this._timers.delete(timerHandle);
timer.callback();
break;
case 'interval':
timer.expiry = this._now + (timer.interval || 0);
timer.callback();
break;
default:
throw new Error('Unexpected timer type: ' + timer.type);
}
}
}
exports.default = FakeTimers;