File size: 5,299 Bytes
74bd15c | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 | /**
* {@link TimeoutManager} does not support passing arguments to the callback.
*
* `(_: void)` is the argument type inferred by TypeScript's default typings for
* `setTimeout(cb, number)`.
* If we don't accept a single void argument, then
* `new Promise(resolve => timeoutManager.setTimeout(resolve, N))` is a type error.
*/
export type TimeoutCallback = (_: void) => void
/**
* Wrapping `setTimeout` is awkward from a typing perspective because platform
* typings may extend the return type of `setTimeout`. For example, NodeJS
* typings add `NodeJS.Timeout`; but a non-default `timeoutManager` may not be
* able to return such a type.
*/
export type ManagedTimerId = number | { [Symbol.toPrimitive]: () => number }
/**
* Backend for timer functions.
*/
export type TimeoutProvider<TTimerId extends ManagedTimerId = ManagedTimerId> =
{
readonly setTimeout: (callback: TimeoutCallback, delay: number) => TTimerId
readonly clearTimeout: (timeoutId: TTimerId | undefined) => void
readonly setInterval: (callback: TimeoutCallback, delay: number) => TTimerId
readonly clearInterval: (intervalId: TTimerId | undefined) => void
}
type SystemTimerId = ReturnType<typeof setTimeout>
export const defaultTimeoutProvider: TimeoutProvider = {
// We need the wrapper function syntax below instead of direct references to
// global setTimeout etc.
//
// BAD: `setTimeout: setTimeout`
// GOOD: `setTimeout: (cb, delay) => setTimeout(cb, delay)`
//
// If we use direct references here, then anything that wants to spy on or
// replace the global setTimeout (like tests) won't work since we'll already
// have a hard reference to the original implementation at the time when this
// file was imported.
setTimeout: (callback, delay) => setTimeout(callback, delay),
clearTimeout: (timeoutId) =>
clearTimeout(timeoutId as SystemTimerId | undefined),
setInterval: (callback, delay) => setInterval(callback, delay),
clearInterval: (intervalId) =>
clearInterval(intervalId as SystemTimerId | undefined),
}
/**
* Allows customization of how timeouts are created.
*
* @tanstack/query-core makes liberal use of timeouts to implement `staleTime`
* and `gcTime`. The default TimeoutManager provider uses the platform's global
* `setTimeout` implementation, which is known to have scalability issues with
* thousands of timeouts on the event loop.
*
* If you hit this limitation, consider providing a custom TimeoutProvider that
* coalesces timeouts.
*/
export class TimeoutManager implements Omit<TimeoutProvider, 'name'> {
// We cannot have TimeoutManager<T> as we must instantiate it with a concrete
// type at app boot; and if we leave that type, then any new timer provider
// would need to support the default provider's concrete timer ID, which is
// infeasible across environments.
//
// We settle for type safety for the TimeoutProvider type, and accept that
// this class is unsafe internally to allow for extension.
#provider: TimeoutProvider<any> = defaultTimeoutProvider
#providerCalled = false
setTimeoutProvider<TTimerId extends ManagedTimerId>(
provider: TimeoutProvider<TTimerId>,
): void {
if (process.env.NODE_ENV !== 'production') {
if (this.#providerCalled && provider !== this.#provider) {
// After changing providers, `clearTimeout` will not work as expected for
// timeouts from the previous provider.
//
// Since they may allocate the same timeout ID, clearTimeout may cancel an
// arbitrary different timeout, or unexpected no-op.
//
// We could protect against this by mixing the timeout ID bits
// deterministically with some per-provider bits.
//
// We could internally queue `setTimeout` calls to `TimeoutManager` until
// some API call to set the initial provider.
console.error(
`[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.`,
{ previous: this.#provider, provider },
)
}
}
this.#provider = provider
if (process.env.NODE_ENV !== 'production') {
this.#providerCalled = false
}
}
setTimeout(callback: TimeoutCallback, delay: number): ManagedTimerId {
if (process.env.NODE_ENV !== 'production') {
this.#providerCalled = true
}
return this.#provider.setTimeout(callback, delay)
}
clearTimeout(timeoutId: ManagedTimerId | undefined): void {
this.#provider.clearTimeout(timeoutId)
}
setInterval(callback: TimeoutCallback, delay: number): ManagedTimerId {
if (process.env.NODE_ENV !== 'production') {
this.#providerCalled = true
}
return this.#provider.setInterval(callback, delay)
}
clearInterval(intervalId: ManagedTimerId | undefined): void {
this.#provider.clearInterval(intervalId)
}
}
export const timeoutManager = new TimeoutManager()
/**
* In many cases code wants to delay to the next event loop tick; this is not
* mediated by {@link timeoutManager}.
*
* This function is provided to make auditing the `tanstack/query-core` for
* incorrect use of system `setTimeout` easier.
*/
export function systemSetTimeoutZero(callback: TimeoutCallback): void {
setTimeout(callback, 0)
}
|