@tanstack/query-core 5.101.3 → 5.102.0

package/build/legacy/subscribable.js

@@ -1,28 +1,24 @@
-import "./chunk-PXG64RU4.js";
-
-// src/subscribable.ts
+//#region src/subscribable.ts
 var Subscribable = class {
-  constructor() {
-    this.listeners = /* @__PURE__ */ new Set();
-    this.subscribe = this.subscribe.bind(this);
-  }
-  subscribe(listener) {
-    this.listeners.add(listener);
-    this.onSubscribe();
-    return () => {
-      this.listeners.delete(listener);
-      this.onUnsubscribe();
-    };
-  }
-  hasListeners() {
-    return this.listeners.size > 0;
-  }
-  onSubscribe() {
-  }
-  onUnsubscribe() {
-  }
-};
-export {
-  Subscribable
+	constructor() {
+		this.listeners = /* @__PURE__ */ new Set();
+		this.subscribe = this.subscribe.bind(this);
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		this.onSubscribe();
+		return () => {
+			this.listeners.delete(listener);
+			this.onUnsubscribe();
+		};
+	}
+	hasListeners() {
+		return this.listeners.size > 0;
+	}
+	onSubscribe() {}
+	onUnsubscribe() {}
 };
+//#endregion
+export { Subscribable };
+
 //# sourceMappingURL=subscribable.js.map

package/build/legacy/subscribable.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/subscribable.ts"],"sourcesContent":["export class Subscribable<TListener extends Function> {\n  protected listeners = new Set<TListener>()\n\n  constructor() {\n    this.subscribe = this.subscribe.bind(this)\n  }\n\n  subscribe(listener: TListener): () => void {\n    this.listeners.add(listener)\n\n    this.onSubscribe()\n\n    return () => {\n      this.listeners.delete(listener)\n      this.onUnsubscribe()\n    }\n  }\n\n  hasListeners(): boolean {\n    return this.listeners.size > 0\n  }\n\n  protected onSubscribe(): void {\n    // Do nothing\n  }\n\n  protected onUnsubscribe(): void {\n    // Do nothing\n  }\n}\n"],"mappings":";;;AAAO,IAAM,eAAN,MAA+C;AAAA,EAGpD,cAAc;AAFd,SAAU,YAAY,oBAAI,IAAe;AAGvC,SAAK,YAAY,KAAK,UAAU,KAAK,IAAI;AAAA,EAC3C;AAAA,EAEA,UAAU,UAAiC;AACzC,SAAK,UAAU,IAAI,QAAQ;AAE3B,SAAK,YAAY;AAEjB,WAAO,MAAM;AACX,WAAK,UAAU,OAAO,QAAQ;AAC9B,WAAK,cAAc;AAAA,IACrB;AAAA,EACF;AAAA,EAEA,eAAwB;AACtB,WAAO,KAAK,UAAU,OAAO;AAAA,EAC/B;AAAA,EAEU,cAAoB;AAAA,EAE9B;AAAA,EAEU,gBAAsB;AAAA,EAEhC;AACF;","names":[]}
+{"version":3,"file":"subscribable.js","names":[],"sources":["../../src/subscribable.ts"],"sourcesContent":["export class Subscribable<TListener extends Function> {\n  protected listeners = new Set<TListener>()\n\n  constructor() {\n    this.subscribe = this.subscribe.bind(this)\n  }\n\n  subscribe(listener: TListener): () => void {\n    this.listeners.add(listener)\n\n    this.onSubscribe()\n\n    return () => {\n      this.listeners.delete(listener)\n      this.onUnsubscribe()\n    }\n  }\n\n  hasListeners(): boolean {\n    return this.listeners.size > 0\n  }\n\n  protected onSubscribe(): void {\n    // Do nothing\n  }\n\n  protected onUnsubscribe(): void {\n    // Do nothing\n  }\n}\n"],"mappings":";AAAA,IAAa,eAAb,MAAsD;CAGpD,cAAc;EAFd,KAAU,4BAAY,IAAI,IAAe;EAGvC,KAAK,YAAY,KAAK,UAAU,KAAK,IAAI;CAC3C;CAEA,UAAU,UAAiC;EACzC,KAAK,UAAU,IAAI,QAAQ;EAE3B,KAAK,YAAY;EAEjB,aAAa;GACX,KAAK,UAAU,OAAO,QAAQ;GAC9B,KAAK,cAAc;EACrB;CACF;CAEA,eAAwB;EACtB,OAAO,KAAK,UAAU,OAAO;CAC/B;CAEA,cAA8B,CAE9B;CAEA,gBAAgC,CAEhC;AACF"}

package/build/legacy/timeoutManager.cjs

@@ -1,111 +1,70 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __typeError = (msg) => {
-  throw TypeError(msg);
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_classPrivateFieldSet2 = require("./classPrivateFieldSet2-Bo0ZyOIv.cjs");
+//#region src/timeoutManager.ts
+const defaultTimeoutProvider = {
+	setTimeout: (callback, delay) => setTimeout(callback, delay),
+	clearTimeout: (timeoutId) => clearTimeout(timeoutId),
+	setInterval: (callback, delay) => setInterval(callback, delay),
+	clearInterval: (intervalId) => clearInterval(intervalId)
 };
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-
-// src/timeoutManager.ts
-var timeoutManager_exports = {};
-__export(timeoutManager_exports, {
-  TimeoutManager: () => TimeoutManager,
-  defaultTimeoutProvider: () => defaultTimeoutProvider,
-  systemSetTimeoutZero: () => systemSetTimeoutZero,
-  timeoutManager: () => timeoutManager
-});
-module.exports = __toCommonJS(timeoutManager_exports);
-var defaultTimeoutProvider = {
-  // 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),
-  setInterval: (callback, delay) => setInterval(callback, delay),
-  clearInterval: (intervalId) => clearInterval(intervalId)
-};
-var _provider, _providerCalled;
+var _provider = /* @__PURE__ */ new WeakMap();
+var _providerCalled = /* @__PURE__ */ new WeakMap();
+/**
+* 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.
+*/
 var TimeoutManager = class {
-  constructor() {
-    // 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.
-    __privateAdd(this, _provider, defaultTimeoutProvider);
-    __privateAdd(this, _providerCalled, false);
-  }
-  setTimeoutProvider(provider) {
-    if (process.env.NODE_ENV !== "production") {
-      if (__privateGet(this, _providerCalled) && provider !== __privateGet(this, _provider)) {
-        console.error(
-          `[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.`,
-          { previous: __privateGet(this, _provider), provider }
-        );
-      }
-    }
-    __privateSet(this, _provider, provider);
-    if (process.env.NODE_ENV !== "production") {
-      __privateSet(this, _providerCalled, false);
-    }
-  }
-  setTimeout(callback, delay) {
-    if (process.env.NODE_ENV !== "production") {
-      __privateSet(this, _providerCalled, true);
-    }
-    return __privateGet(this, _provider).setTimeout(callback, delay);
-  }
-  clearTimeout(timeoutId) {
-    __privateGet(this, _provider).clearTimeout(timeoutId);
-  }
-  setInterval(callback, delay) {
-    if (process.env.NODE_ENV !== "production") {
-      __privateSet(this, _providerCalled, true);
-    }
-    return __privateGet(this, _provider).setInterval(callback, delay);
-  }
-  clearInterval(intervalId) {
-    __privateGet(this, _provider).clearInterval(intervalId);
-  }
+	constructor() {
+		require_classPrivateFieldSet2._classPrivateFieldInitSpec(this, _provider, defaultTimeoutProvider);
+		require_classPrivateFieldSet2._classPrivateFieldInitSpec(this, _providerCalled, false);
+	}
+	setTimeoutProvider(provider) {
+		if (process.env.NODE_ENV !== "production") {
+			if (require_classPrivateFieldSet2._classPrivateFieldGet2(_providerCalled, this) && provider !== require_classPrivateFieldSet2._classPrivateFieldGet2(_provider, this)) console.error(`[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.`, {
+				previous: require_classPrivateFieldSet2._classPrivateFieldGet2(_provider, this),
+				provider
+			});
+		}
+		require_classPrivateFieldSet2._classPrivateFieldSet2(_provider, this, provider);
+		if (process.env.NODE_ENV !== "production") require_classPrivateFieldSet2._classPrivateFieldSet2(_providerCalled, this, false);
+	}
+	setTimeout(callback, delay) {
+		if (process.env.NODE_ENV !== "production") require_classPrivateFieldSet2._classPrivateFieldSet2(_providerCalled, this, true);
+		return require_classPrivateFieldSet2._classPrivateFieldGet2(_provider, this).setTimeout(callback, delay);
+	}
+	clearTimeout(timeoutId) {
+		require_classPrivateFieldSet2._classPrivateFieldGet2(_provider, this).clearTimeout(timeoutId);
+	}
+	setInterval(callback, delay) {
+		if (process.env.NODE_ENV !== "production") require_classPrivateFieldSet2._classPrivateFieldSet2(_providerCalled, this, true);
+		return require_classPrivateFieldSet2._classPrivateFieldGet2(_provider, this).setInterval(callback, delay);
+	}
+	clearInterval(intervalId) {
+		require_classPrivateFieldSet2._classPrivateFieldGet2(_provider, this).clearInterval(intervalId);
+	}
 };
-_provider = new WeakMap();
-_providerCalled = new WeakMap();
-var timeoutManager = new TimeoutManager();
+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.
+*/
 function systemSetTimeoutZero(callback) {
-  setTimeout(callback, 0);
+	setTimeout(callback, 0);
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  TimeoutManager,
-  defaultTimeoutProvider,
-  systemSetTimeoutZero,
-  timeoutManager
-});
+//#endregion
+exports.TimeoutManager = TimeoutManager;
+exports.defaultTimeoutProvider = defaultTimeoutProvider;
+exports.systemSetTimeoutZero = systemSetTimeoutZero;
+exports.timeoutManager = timeoutManager;
+
 //# sourceMappingURL=timeoutManager.cjs.map

package/build/legacy/timeoutManager.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/timeoutManager.ts"],"sourcesContent":["/**\n * {@link TimeoutManager} does not support passing arguments to the callback.\n *\n * `(_: void)` is the argument type inferred by TypeScript's default typings for\n * `setTimeout(cb, number)`.\n * If we don't accept a single void argument, then\n * `new Promise(resolve => timeoutManager.setTimeout(resolve, N))` is a type error.\n */\nexport type TimeoutCallback = (_: void) => void\n\n/**\n * Wrapping `setTimeout` is awkward from a typing perspective because platform\n * typings may extend the return type of `setTimeout`. For example, NodeJS\n * typings add `NodeJS.Timeout`; but a non-default `timeoutManager` may not be\n * able to return such a type.\n */\nexport type ManagedTimerId = number | { [Symbol.toPrimitive]: () => number }\n\n/**\n * Backend for timer functions.\n */\nexport type TimeoutProvider<TTimerId extends ManagedTimerId = ManagedTimerId> =\n  {\n    readonly setTimeout: (callback: TimeoutCallback, delay: number) => TTimerId\n    readonly clearTimeout: (timeoutId: TTimerId | undefined) => void\n\n    readonly setInterval: (callback: TimeoutCallback, delay: number) => TTimerId\n    readonly clearInterval: (intervalId: TTimerId | undefined) => void\n  }\n\ntype SystemTimerId = ReturnType<typeof setTimeout>\n\nexport const defaultTimeoutProvider: TimeoutProvider = {\n  // We need the wrapper function syntax below instead of direct references to\n  // global setTimeout etc.\n  //\n  // BAD: `setTimeout: setTimeout`\n  // GOOD: `setTimeout: (cb, delay) => setTimeout(cb, delay)`\n  //\n  // If we use direct references here, then anything that wants to spy on or\n  // replace the global setTimeout (like tests) won't work since we'll already\n  // have a hard reference to the original implementation at the time when this\n  // file was imported.\n  setTimeout: (callback, delay) => setTimeout(callback, delay),\n  clearTimeout: (timeoutId) =>\n    clearTimeout(timeoutId as SystemTimerId | undefined),\n\n  setInterval: (callback, delay) => setInterval(callback, delay),\n  clearInterval: (intervalId) =>\n    clearInterval(intervalId as SystemTimerId | undefined),\n}\n\n/**\n * Allows customization of how timeouts are created.\n *\n * @tanstack/query-core makes liberal use of timeouts to implement `staleTime`\n * and `gcTime`. The default TimeoutManager provider uses the platform's global\n * `setTimeout` implementation, which is known to have scalability issues with\n * thousands of timeouts on the event loop.\n *\n * If you hit this limitation, consider providing a custom TimeoutProvider that\n * coalesces timeouts.\n */\nexport class TimeoutManager implements Omit<TimeoutProvider, 'name'> {\n  // We cannot have TimeoutManager<T> as we must instantiate it with a concrete\n  // type at app boot; and if we leave that type, then any new timer provider\n  // would need to support the default provider's concrete timer ID, which is\n  // infeasible across environments.\n  //\n  // We settle for type safety for the TimeoutProvider type, and accept that\n  // this class is unsafe internally to allow for extension.\n  #provider: TimeoutProvider<any> = defaultTimeoutProvider\n  #providerCalled = false\n\n  setTimeoutProvider<TTimerId extends ManagedTimerId>(\n    provider: TimeoutProvider<TTimerId>,\n  ): void {\n    if (process.env.NODE_ENV !== 'production') {\n      if (this.#providerCalled && provider !== this.#provider) {\n        // After changing providers, `clearTimeout` will not work as expected for\n        // timeouts from the previous provider.\n        //\n        // Since they may allocate the same timeout ID, clearTimeout may cancel an\n        // arbitrary different timeout, or unexpected no-op.\n        //\n        // We could protect against this by mixing the timeout ID bits\n        // deterministically with some per-provider bits.\n        //\n        // We could internally queue `setTimeout` calls to `TimeoutManager` until\n        // some API call to set the initial provider.\n        console.error(\n          `[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.`,\n          { previous: this.#provider, provider },\n        )\n      }\n    }\n\n    this.#provider = provider\n    if (process.env.NODE_ENV !== 'production') {\n      this.#providerCalled = false\n    }\n  }\n\n  setTimeout(callback: TimeoutCallback, delay: number): ManagedTimerId {\n    if (process.env.NODE_ENV !== 'production') {\n      this.#providerCalled = true\n    }\n    return this.#provider.setTimeout(callback, delay)\n  }\n\n  clearTimeout(timeoutId: ManagedTimerId | undefined): void {\n    this.#provider.clearTimeout(timeoutId)\n  }\n\n  setInterval(callback: TimeoutCallback, delay: number): ManagedTimerId {\n    if (process.env.NODE_ENV !== 'production') {\n      this.#providerCalled = true\n    }\n    return this.#provider.setInterval(callback, delay)\n  }\n\n  clearInterval(intervalId: ManagedTimerId | undefined): void {\n    this.#provider.clearInterval(intervalId)\n  }\n}\n\nexport const timeoutManager = new TimeoutManager()\n\n/**\n * In many cases code wants to delay to the next event loop tick; this is not\n * mediated by {@link timeoutManager}.\n *\n * This function is provided to make auditing the `tanstack/query-core` for\n * incorrect use of system `setTimeout` easier.\n */\nexport function systemSetTimeoutZero(callback: TimeoutCallback): void {\n  setTimeout(callback, 0)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgCO,IAAM,yBAA0C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWrD,YAAY,CAAC,UAAU,UAAU,WAAW,UAAU,KAAK;AAAA,EAC3D,cAAc,CAAC,cACb,aAAa,SAAsC;AAAA,EAErD,aAAa,CAAC,UAAU,UAAU,YAAY,UAAU,KAAK;AAAA,EAC7D,eAAe,CAAC,eACd,cAAc,UAAuC;AACzD;AAlDA;AA+DO,IAAM,iBAAN,MAA8D;AAAA,EAA9D;AAQL;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kCAAkC;AAClC,wCAAkB;AAAA;AAAA,EAElB,mBACE,UACM;AACN,QAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,UAAI,mBAAK,oBAAmB,aAAa,mBAAK,YAAW;AAYvD,gBAAQ;AAAA,UACN;AAAA,UACA,EAAE,UAAU,mBAAK,YAAW,SAAS;AAAA,QACvC;AAAA,MACF;AAAA,IACF;AAEA,uBAAK,WAAY;AACjB,QAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,yBAAK,iBAAkB;AAAA,IACzB;AAAA,EACF;AAAA,EAEA,WAAW,UAA2B,OAA+B;AACnE,QAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,yBAAK,iBAAkB;AAAA,IACzB;AACA,WAAO,mBAAK,WAAU,WAAW,UAAU,KAAK;AAAA,EAClD;AAAA,EAEA,aAAa,WAA6C;AACxD,uBAAK,WAAU,aAAa,SAAS;AAAA,EACvC;AAAA,EAEA,YAAY,UAA2B,OAA+B;AACpE,QAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,yBAAK,iBAAkB;AAAA,IACzB;AACA,WAAO,mBAAK,WAAU,YAAY,UAAU,KAAK;AAAA,EACnD;AAAA,EAEA,cAAc,YAA8C;AAC1D,uBAAK,WAAU,cAAc,UAAU;AAAA,EACzC;AACF;AArDE;AACA;AAsDK,IAAM,iBAAiB,IAAI,eAAe;AAS1C,SAAS,qBAAqB,UAAiC;AACpE,aAAW,UAAU,CAAC;AACxB;","names":[]}
+{"version":3,"file":"timeoutManager.cjs","names":[],"sources":["../../src/timeoutManager.ts"],"sourcesContent":["/**\n * {@link TimeoutManager} does not support passing arguments to the callback.\n *\n * `(_: void)` is the argument type inferred by TypeScript's default typings for\n * `setTimeout(cb, number)`.\n * If we don't accept a single void argument, then\n * `new Promise(resolve => timeoutManager.setTimeout(resolve, N))` is a type error.\n */\nexport type TimeoutCallback = (_: void) => void\n\n/**\n * Wrapping `setTimeout` is awkward from a typing perspective because platform\n * typings may extend the return type of `setTimeout`. For example, NodeJS\n * typings add `NodeJS.Timeout`; but a non-default `timeoutManager` may not be\n * able to return such a type.\n */\nexport type ManagedTimerId = number | { [Symbol.toPrimitive]: () => number }\n\n/**\n * Backend for timer functions.\n */\nexport type TimeoutProvider<TTimerId extends ManagedTimerId = ManagedTimerId> =\n  {\n    readonly setTimeout: (callback: TimeoutCallback, delay: number) => TTimerId\n    readonly clearTimeout: (timeoutId: TTimerId | undefined) => void\n\n    readonly setInterval: (callback: TimeoutCallback, delay: number) => TTimerId\n    readonly clearInterval: (intervalId: TTimerId | undefined) => void\n  }\n\ntype SystemTimerId = ReturnType<typeof setTimeout>\n\nexport const defaultTimeoutProvider: TimeoutProvider = {\n  // We need the wrapper function syntax below instead of direct references to\n  // global setTimeout etc.\n  //\n  // BAD: `setTimeout: setTimeout`\n  // GOOD: `setTimeout: (cb, delay) => setTimeout(cb, delay)`\n  //\n  // If we use direct references here, then anything that wants to spy on or\n  // replace the global setTimeout (like tests) won't work since we'll already\n  // have a hard reference to the original implementation at the time when this\n  // file was imported.\n  setTimeout: (callback, delay) => setTimeout(callback, delay),\n  clearTimeout: (timeoutId) =>\n    clearTimeout(timeoutId as SystemTimerId | undefined),\n\n  setInterval: (callback, delay) => setInterval(callback, delay),\n  clearInterval: (intervalId) =>\n    clearInterval(intervalId as SystemTimerId | undefined),\n}\n\n/**\n * Allows customization of how timeouts are created.\n *\n * @tanstack/query-core makes liberal use of timeouts to implement `staleTime`\n * and `gcTime`. The default TimeoutManager provider uses the platform's global\n * `setTimeout` implementation, which is known to have scalability issues with\n * thousands of timeouts on the event loop.\n *\n * If you hit this limitation, consider providing a custom TimeoutProvider that\n * coalesces timeouts.\n */\nexport class TimeoutManager implements Omit<TimeoutProvider, 'name'> {\n  // We cannot have TimeoutManager<T> as we must instantiate it with a concrete\n  // type at app boot; and if we leave that type, then any new timer provider\n  // would need to support the default provider's concrete timer ID, which is\n  // infeasible across environments.\n  //\n  // We settle for type safety for the TimeoutProvider type, and accept that\n  // this class is unsafe internally to allow for extension.\n  #provider: TimeoutProvider<any> = defaultTimeoutProvider\n  #providerCalled = false\n\n  setTimeoutProvider<TTimerId extends ManagedTimerId>(\n    provider: TimeoutProvider<TTimerId>,\n  ): void {\n    if (process.env.NODE_ENV !== 'production') {\n      if (this.#providerCalled && provider !== this.#provider) {\n        // After changing providers, `clearTimeout` will not work as expected for\n        // timeouts from the previous provider.\n        //\n        // Since they may allocate the same timeout ID, clearTimeout may cancel an\n        // arbitrary different timeout, or unexpected no-op.\n        //\n        // We could protect against this by mixing the timeout ID bits\n        // deterministically with some per-provider bits.\n        //\n        // We could internally queue `setTimeout` calls to `TimeoutManager` until\n        // some API call to set the initial provider.\n        console.error(\n          `[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.`,\n          { previous: this.#provider, provider },\n        )\n      }\n    }\n\n    this.#provider = provider\n    if (process.env.NODE_ENV !== 'production') {\n      this.#providerCalled = false\n    }\n  }\n\n  setTimeout(callback: TimeoutCallback, delay: number): ManagedTimerId {\n    if (process.env.NODE_ENV !== 'production') {\n      this.#providerCalled = true\n    }\n    return this.#provider.setTimeout(callback, delay)\n  }\n\n  clearTimeout(timeoutId: ManagedTimerId | undefined): void {\n    this.#provider.clearTimeout(timeoutId)\n  }\n\n  setInterval(callback: TimeoutCallback, delay: number): ManagedTimerId {\n    if (process.env.NODE_ENV !== 'production') {\n      this.#providerCalled = true\n    }\n    return this.#provider.setInterval(callback, delay)\n  }\n\n  clearInterval(intervalId: ManagedTimerId | undefined): void {\n    this.#provider.clearInterval(intervalId)\n  }\n}\n\nexport const timeoutManager = new TimeoutManager()\n\n/**\n * In many cases code wants to delay to the next event loop tick; this is not\n * mediated by {@link timeoutManager}.\n *\n * This function is provided to make auditing the `tanstack/query-core` for\n * incorrect use of system `setTimeout` easier.\n */\nexport function systemSetTimeoutZero(callback: TimeoutCallback): void {\n  setTimeout(callback, 0)\n}\n"],"mappings":";;;AAgCA,MAAa,yBAA0C;CAWrD,aAAa,UAAU,UAAU,WAAW,UAAU,KAAK;CAC3D,eAAe,cACb,aAAa,SAAsC;CAErD,cAAc,UAAU,UAAU,YAAY,UAAU,KAAK;CAC7D,gBAAgB,eACd,cAAc,UAAuC;AACzD;;;;;;;;;;;;;;AAaA,IAAa,iBAAb,MAAqE;;EAQjC,8BAAA,2BAAA,MAAA,WAAA,sBAAA;EAChB,8BAAA,2BAAA,MAAA,iBAAA,KAAA;;CAElB,mBACE,UACM;EACN,IAAI,QAAQ,IAAI,aAAa,cACvB;OAAA,8BAAA,uBAAA,iBAAA,IAAA,KAAwB,aAAA,8BAAA,uBAAA,WAAa,IAAA,GAYvC,QAAQ,MACN,8GACA;IAAE,UAAA,8BAAA,uBAAA,WAAU,IAAA;IAAgB;GAAS,CACvC;EAAA;EAIJ,8BAAA,uBAAA,WAAA,MAAiB,QAAA;EACjB,IAAI,QAAQ,IAAI,aAAa,cAC3B,8BAAA,uBAAA,iBAAA,MAAuB,KAAA;CAE3B;CAEA,WAAW,UAA2B,OAA+B;EACnE,IAAI,QAAQ,IAAI,aAAa,cAC3B,8BAAA,uBAAA,iBAAA,MAAuB,IAAA;EAEzB,OAAA,8BAAA,uBAAA,WAAO,IAAA,CAAA,CAAe,WAAW,UAAU,KAAK;CAClD;CAEA,aAAa,WAA6C;EACxD,8BAAA,uBAAA,WAAA,IAAA,CAAA,CAAe,aAAa,SAAS;CACvC;CAEA,YAAY,UAA2B,OAA+B;EACpE,IAAI,QAAQ,IAAI,aAAa,cAC3B,8BAAA,uBAAA,iBAAA,MAAuB,IAAA;EAEzB,OAAA,8BAAA,uBAAA,WAAO,IAAA,CAAA,CAAe,YAAY,UAAU,KAAK;CACnD;CAEA,cAAc,YAA8C;EAC1D,8BAAA,uBAAA,WAAA,IAAA,CAAA,CAAe,cAAc,UAAU;CACzC;AACF;AAEA,MAAa,iBAAiB,IAAI,eAAe;;;;;;;;AASjD,SAAgB,qBAAqB,UAAiC;CACpE,WAAW,UAAU,CAAC;AACxB"}

package/build/legacy/timeoutManager.d.cts

@@ -1,7 +1,60 @@
-export { systemSetTimeoutZero } from './_tsup-dts-rollup.cjs';
-export { TimeoutCallback_alias_1 as TimeoutCallback } from './_tsup-dts-rollup.cjs';
-export { ManagedTimerId_alias_1 as ManagedTimerId } from './_tsup-dts-rollup.cjs';
-export { TimeoutProvider_alias_1 as TimeoutProvider } from './_tsup-dts-rollup.cjs';
-export { defaultTimeoutProvider } from './_tsup-dts-rollup.cjs';
-export { TimeoutManager } from './_tsup-dts-rollup.cjs';
-export { timeoutManager_alias_1 as timeoutManager } from './_tsup-dts-rollup.cjs';
+//#region src/timeoutManager.d.ts
+/**
+ * {@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.
+ */
+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.
+ */
+type ManagedTimerId = number | {
+  [Symbol.toPrimitive]: () => number;
+};
+/**
+ * Backend for timer functions.
+ */
+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;
+};
+declare const defaultTimeoutProvider: TimeoutProvider;
+/**
+ * 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.
+ */
+declare class TimeoutManager implements Omit<TimeoutProvider, 'name'> {
+  #private;
+  setTimeoutProvider<TTimerId extends ManagedTimerId>(provider: TimeoutProvider<TTimerId>): void;
+  setTimeout(callback: TimeoutCallback, delay: number): ManagedTimerId;
+  clearTimeout(timeoutId: ManagedTimerId | undefined): void;
+  setInterval(callback: TimeoutCallback, delay: number): ManagedTimerId;
+  clearInterval(intervalId: ManagedTimerId | undefined): void;
+}
+declare const timeoutManager: 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.
+ */
+declare function systemSetTimeoutZero(callback: TimeoutCallback): void;
+//#endregion
+export { ManagedTimerId, TimeoutCallback, TimeoutManager, TimeoutProvider, defaultTimeoutProvider, systemSetTimeoutZero, timeoutManager };
+//# sourceMappingURL=timeoutManager.d.cts.map

package/build/legacy/timeoutManager.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeoutManager.d.cts","names":[],"sources":["../../src/timeoutManager.ts"],"mappings":";;;;;;;;;KAQY,mBAAmB;;;;;;;KAQnB;GAA6B,OAAO;;;;;KAKpC,gBAAgB,iBAAiB,iBAAiB;WAEjD,aAAa,UAAU,iBAAiB,kBAAkB;WAC1D,eAAe,WAAW;WAE1B,cAAc,UAAU,iBAAiB,kBAAkB;WAC3D,gBAAgB,YAAY;;cAK5B,wBAAwB;;;;;;;;;;;;cA+BxB,0BAA0B,KAAK;;EAW1C,mBAAmB,iBAAiB,gBAClC,UAAU,gBAAgB;EA4B5B,WAAW,UAAU,iBAAiB,gBAAgB;EAOtD,aAAa,WAAW;EAIxB,YAAY,UAAU,iBAAiB,gBAAgB;EAOvD,cAAc,YAAY;;cAKf,gBAAc;;;;;;;;iBASX,qBAAqB,UAAU"}

package/build/legacy/timeoutManager.d.ts

@@ -1,7 +1,60 @@
-export { systemSetTimeoutZero } from './_tsup-dts-rollup.js';
-export { TimeoutCallback_alias_1 as TimeoutCallback } from './_tsup-dts-rollup.js';
-export { ManagedTimerId_alias_1 as ManagedTimerId } from './_tsup-dts-rollup.js';
-export { TimeoutProvider_alias_1 as TimeoutProvider } from './_tsup-dts-rollup.js';
-export { defaultTimeoutProvider } from './_tsup-dts-rollup.js';
-export { TimeoutManager } from './_tsup-dts-rollup.js';
-export { timeoutManager_alias_1 as timeoutManager } from './_tsup-dts-rollup.js';
+//#region src/timeoutManager.d.ts
+/**
+ * {@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.
+ */
+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.
+ */
+type ManagedTimerId = number | {
+  [Symbol.toPrimitive]: () => number;
+};
+/**
+ * Backend for timer functions.
+ */
+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;
+};
+declare const defaultTimeoutProvider: TimeoutProvider;
+/**
+ * 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.
+ */
+declare class TimeoutManager implements Omit<TimeoutProvider, 'name'> {
+  #private;
+  setTimeoutProvider<TTimerId extends ManagedTimerId>(provider: TimeoutProvider<TTimerId>): void;
+  setTimeout(callback: TimeoutCallback, delay: number): ManagedTimerId;
+  clearTimeout(timeoutId: ManagedTimerId | undefined): void;
+  setInterval(callback: TimeoutCallback, delay: number): ManagedTimerId;
+  clearInterval(intervalId: ManagedTimerId | undefined): void;
+}
+declare const timeoutManager: 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.
+ */
+declare function systemSetTimeoutZero(callback: TimeoutCallback): void;
+//#endregion
+export { ManagedTimerId, TimeoutCallback, TimeoutManager, TimeoutProvider, defaultTimeoutProvider, systemSetTimeoutZero, timeoutManager };
+//# sourceMappingURL=timeoutManager.d.ts.map

package/build/legacy/timeoutManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeoutManager.d.ts","names":[],"sources":["../../src/timeoutManager.ts"],"mappings":";;;;;;;;;KAQY,mBAAmB;;;;;;;KAQnB;GAA6B,OAAO;;;;;KAKpC,gBAAgB,iBAAiB,iBAAiB;WAEjD,aAAa,UAAU,iBAAiB,kBAAkB;WAC1D,eAAe,WAAW;WAE1B,cAAc,UAAU,iBAAiB,kBAAkB;WAC3D,gBAAgB,YAAY;;cAK5B,wBAAwB;;;;;;;;;;;;cA+BxB,0BAA0B,KAAK;;EAW1C,mBAAmB,iBAAiB,gBAClC,UAAU,gBAAgB;EA4B5B,WAAW,UAAU,iBAAiB,gBAAgB;EAOtD,aAAa,WAAW;EAIxB,YAAY,UAAU,iBAAiB,gBAAgB;EAOvD,cAAc,YAAY;;cAKf,gBAAc;;;;;;;;iBASX,qBAAqB,UAAU"}

package/build/legacy/timeoutManager.js

@@ -1,82 +1,66 @@
-import {
-  __privateAdd,
-  __privateGet,
-  __privateSet
-} from "./chunk-PXG64RU4.js";
-
-// src/timeoutManager.ts
-var defaultTimeoutProvider = {
-  // 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),
-  setInterval: (callback, delay) => setInterval(callback, delay),
-  clearInterval: (intervalId) => clearInterval(intervalId)
+import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldGet2, t as _classPrivateFieldSet2 } from "./classPrivateFieldSet2-CV7wyte-.js";
+//#region src/timeoutManager.ts
+const defaultTimeoutProvider = {
+	setTimeout: (callback, delay) => setTimeout(callback, delay),
+	clearTimeout: (timeoutId) => clearTimeout(timeoutId),
+	setInterval: (callback, delay) => setInterval(callback, delay),
+	clearInterval: (intervalId) => clearInterval(intervalId)
 };
-var _provider, _providerCalled;
+var _provider = /* @__PURE__ */ new WeakMap();
+var _providerCalled = /* @__PURE__ */ new WeakMap();
+/**
+* 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.
+*/
 var TimeoutManager = class {
-  constructor() {
-    // 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.
-    __privateAdd(this, _provider, defaultTimeoutProvider);
-    __privateAdd(this, _providerCalled, false);
-  }
-  setTimeoutProvider(provider) {
-    if (process.env.NODE_ENV !== "production") {
-      if (__privateGet(this, _providerCalled) && provider !== __privateGet(this, _provider)) {
-        console.error(
-          `[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.`,
-          { previous: __privateGet(this, _provider), provider }
-        );
-      }
-    }
-    __privateSet(this, _provider, provider);
-    if (process.env.NODE_ENV !== "production") {
-      __privateSet(this, _providerCalled, false);
-    }
-  }
-  setTimeout(callback, delay) {
-    if (process.env.NODE_ENV !== "production") {
-      __privateSet(this, _providerCalled, true);
-    }
-    return __privateGet(this, _provider).setTimeout(callback, delay);
-  }
-  clearTimeout(timeoutId) {
-    __privateGet(this, _provider).clearTimeout(timeoutId);
-  }
-  setInterval(callback, delay) {
-    if (process.env.NODE_ENV !== "production") {
-      __privateSet(this, _providerCalled, true);
-    }
-    return __privateGet(this, _provider).setInterval(callback, delay);
-  }
-  clearInterval(intervalId) {
-    __privateGet(this, _provider).clearInterval(intervalId);
-  }
+	constructor() {
+		_classPrivateFieldInitSpec(this, _provider, defaultTimeoutProvider);
+		_classPrivateFieldInitSpec(this, _providerCalled, false);
+	}
+	setTimeoutProvider(provider) {
+		if (process.env.NODE_ENV !== "production") {
+			if (_classPrivateFieldGet2(_providerCalled, this) && provider !== _classPrivateFieldGet2(_provider, this)) console.error(`[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.`, {
+				previous: _classPrivateFieldGet2(_provider, this),
+				provider
+			});
+		}
+		_classPrivateFieldSet2(_provider, this, provider);
+		if (process.env.NODE_ENV !== "production") _classPrivateFieldSet2(_providerCalled, this, false);
+	}
+	setTimeout(callback, delay) {
+		if (process.env.NODE_ENV !== "production") _classPrivateFieldSet2(_providerCalled, this, true);
+		return _classPrivateFieldGet2(_provider, this).setTimeout(callback, delay);
+	}
+	clearTimeout(timeoutId) {
+		_classPrivateFieldGet2(_provider, this).clearTimeout(timeoutId);
+	}
+	setInterval(callback, delay) {
+		if (process.env.NODE_ENV !== "production") _classPrivateFieldSet2(_providerCalled, this, true);
+		return _classPrivateFieldGet2(_provider, this).setInterval(callback, delay);
+	}
+	clearInterval(intervalId) {
+		_classPrivateFieldGet2(_provider, this).clearInterval(intervalId);
+	}
 };
-_provider = new WeakMap();
-_providerCalled = new WeakMap();
-var timeoutManager = new TimeoutManager();
+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.
+*/
 function systemSetTimeoutZero(callback) {
-  setTimeout(callback, 0);
+	setTimeout(callback, 0);
 }
-export {
-  TimeoutManager,
-  defaultTimeoutProvider,
-  systemSetTimeoutZero,
-  timeoutManager
-};
+//#endregion
+export { TimeoutManager, defaultTimeoutProvider, systemSetTimeoutZero, timeoutManager };
+
 //# sourceMappingURL=timeoutManager.js.map

package/build/legacy/timeoutManager.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/timeoutManager.ts"],"sourcesContent":["/**\n * {@link TimeoutManager} does not support passing arguments to the callback.\n *\n * `(_: void)` is the argument type inferred by TypeScript's default typings for\n * `setTimeout(cb, number)`.\n * If we don't accept a single void argument, then\n * `new Promise(resolve => timeoutManager.setTimeout(resolve, N))` is a type error.\n */\nexport type TimeoutCallback = (_: void) => void\n\n/**\n * Wrapping `setTimeout` is awkward from a typing perspective because platform\n * typings may extend the return type of `setTimeout`. For example, NodeJS\n * typings add `NodeJS.Timeout`; but a non-default `timeoutManager` may not be\n * able to return such a type.\n */\nexport type ManagedTimerId = number | { [Symbol.toPrimitive]: () => number }\n\n/**\n * Backend for timer functions.\n */\nexport type TimeoutProvider<TTimerId extends ManagedTimerId = ManagedTimerId> =\n  {\n    readonly setTimeout: (callback: TimeoutCallback, delay: number) => TTimerId\n    readonly clearTimeout: (timeoutId: TTimerId | undefined) => void\n\n    readonly setInterval: (callback: TimeoutCallback, delay: number) => TTimerId\n    readonly clearInterval: (intervalId: TTimerId | undefined) => void\n  }\n\ntype SystemTimerId = ReturnType<typeof setTimeout>\n\nexport const defaultTimeoutProvider: TimeoutProvider = {\n  // We need the wrapper function syntax below instead of direct references to\n  // global setTimeout etc.\n  //\n  // BAD: `setTimeout: setTimeout`\n  // GOOD: `setTimeout: (cb, delay) => setTimeout(cb, delay)`\n  //\n  // If we use direct references here, then anything that wants to spy on or\n  // replace the global setTimeout (like tests) won't work since we'll already\n  // have a hard reference to the original implementation at the time when this\n  // file was imported.\n  setTimeout: (callback, delay) => setTimeout(callback, delay),\n  clearTimeout: (timeoutId) =>\n    clearTimeout(timeoutId as SystemTimerId | undefined),\n\n  setInterval: (callback, delay) => setInterval(callback, delay),\n  clearInterval: (intervalId) =>\n    clearInterval(intervalId as SystemTimerId | undefined),\n}\n\n/**\n * Allows customization of how timeouts are created.\n *\n * @tanstack/query-core makes liberal use of timeouts to implement `staleTime`\n * and `gcTime`. The default TimeoutManager provider uses the platform's global\n * `setTimeout` implementation, which is known to have scalability issues with\n * thousands of timeouts on the event loop.\n *\n * If you hit this limitation, consider providing a custom TimeoutProvider that\n * coalesces timeouts.\n */\nexport class TimeoutManager implements Omit<TimeoutProvider, 'name'> {\n  // We cannot have TimeoutManager<T> as we must instantiate it with a concrete\n  // type at app boot; and if we leave that type, then any new timer provider\n  // would need to support the default provider's concrete timer ID, which is\n  // infeasible across environments.\n  //\n  // We settle for type safety for the TimeoutProvider type, and accept that\n  // this class is unsafe internally to allow for extension.\n  #provider: TimeoutProvider<any> = defaultTimeoutProvider\n  #providerCalled = false\n\n  setTimeoutProvider<TTimerId extends ManagedTimerId>(\n    provider: TimeoutProvider<TTimerId>,\n  ): void {\n    if (process.env.NODE_ENV !== 'production') {\n      if (this.#providerCalled && provider !== this.#provider) {\n        // After changing providers, `clearTimeout` will not work as expected for\n        // timeouts from the previous provider.\n        //\n        // Since they may allocate the same timeout ID, clearTimeout may cancel an\n        // arbitrary different timeout, or unexpected no-op.\n        //\n        // We could protect against this by mixing the timeout ID bits\n        // deterministically with some per-provider bits.\n        //\n        // We could internally queue `setTimeout` calls to `TimeoutManager` until\n        // some API call to set the initial provider.\n        console.error(\n          `[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.`,\n          { previous: this.#provider, provider },\n        )\n      }\n    }\n\n    this.#provider = provider\n    if (process.env.NODE_ENV !== 'production') {\n      this.#providerCalled = false\n    }\n  }\n\n  setTimeout(callback: TimeoutCallback, delay: number): ManagedTimerId {\n    if (process.env.NODE_ENV !== 'production') {\n      this.#providerCalled = true\n    }\n    return this.#provider.setTimeout(callback, delay)\n  }\n\n  clearTimeout(timeoutId: ManagedTimerId | undefined): void {\n    this.#provider.clearTimeout(timeoutId)\n  }\n\n  setInterval(callback: TimeoutCallback, delay: number): ManagedTimerId {\n    if (process.env.NODE_ENV !== 'production') {\n      this.#providerCalled = true\n    }\n    return this.#provider.setInterval(callback, delay)\n  }\n\n  clearInterval(intervalId: ManagedTimerId | undefined): void {\n    this.#provider.clearInterval(intervalId)\n  }\n}\n\nexport const timeoutManager = new TimeoutManager()\n\n/**\n * In many cases code wants to delay to the next event loop tick; this is not\n * mediated by {@link timeoutManager}.\n *\n * This function is provided to make auditing the `tanstack/query-core` for\n * incorrect use of system `setTimeout` easier.\n */\nexport function systemSetTimeoutZero(callback: TimeoutCallback): void {\n  setTimeout(callback, 0)\n}\n"],"mappings":";;;;;;;AAgCO,IAAM,yBAA0C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWrD,YAAY,CAAC,UAAU,UAAU,WAAW,UAAU,KAAK;AAAA,EAC3D,cAAc,CAAC,cACb,aAAa,SAAsC;AAAA,EAErD,aAAa,CAAC,UAAU,UAAU,YAAY,UAAU,KAAK;AAAA,EAC7D,eAAe,CAAC,eACd,cAAc,UAAuC;AACzD;AAlDA;AA+DO,IAAM,iBAAN,MAA8D;AAAA,EAA9D;AAQL;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kCAAkC;AAClC,wCAAkB;AAAA;AAAA,EAElB,mBACE,UACM;AACN,QAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,UAAI,mBAAK,oBAAmB,aAAa,mBAAK,YAAW;AAYvD,gBAAQ;AAAA,UACN;AAAA,UACA,EAAE,UAAU,mBAAK,YAAW,SAAS;AAAA,QACvC;AAAA,MACF;AAAA,IACF;AAEA,uBAAK,WAAY;AACjB,QAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,yBAAK,iBAAkB;AAAA,IACzB;AAAA,EACF;AAAA,EAEA,WAAW,UAA2B,OAA+B;AACnE,QAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,yBAAK,iBAAkB;AAAA,IACzB;AACA,WAAO,mBAAK,WAAU,WAAW,UAAU,KAAK;AAAA,EAClD;AAAA,EAEA,aAAa,WAA6C;AACxD,uBAAK,WAAU,aAAa,SAAS;AAAA,EACvC;AAAA,EAEA,YAAY,UAA2B,OAA+B;AACpE,QAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,yBAAK,iBAAkB;AAAA,IACzB;AACA,WAAO,mBAAK,WAAU,YAAY,UAAU,KAAK;AAAA,EACnD;AAAA,EAEA,cAAc,YAA8C;AAC1D,uBAAK,WAAU,cAAc,UAAU;AAAA,EACzC;AACF;AArDE;AACA;AAsDK,IAAM,iBAAiB,IAAI,eAAe;AAS1C,SAAS,qBAAqB,UAAiC;AACpE,aAAW,UAAU,CAAC;AACxB;","names":[]}
+{"version":3,"file":"timeoutManager.js","names":[],"sources":["../../src/timeoutManager.ts"],"sourcesContent":["/**\n * {@link TimeoutManager} does not support passing arguments to the callback.\n *\n * `(_: void)` is the argument type inferred by TypeScript's default typings for\n * `setTimeout(cb, number)`.\n * If we don't accept a single void argument, then\n * `new Promise(resolve => timeoutManager.setTimeout(resolve, N))` is a type error.\n */\nexport type TimeoutCallback = (_: void) => void\n\n/**\n * Wrapping `setTimeout` is awkward from a typing perspective because platform\n * typings may extend the return type of `setTimeout`. For example, NodeJS\n * typings add `NodeJS.Timeout`; but a non-default `timeoutManager` may not be\n * able to return such a type.\n */\nexport type ManagedTimerId = number | { [Symbol.toPrimitive]: () => number }\n\n/**\n * Backend for timer functions.\n */\nexport type TimeoutProvider<TTimerId extends ManagedTimerId = ManagedTimerId> =\n  {\n    readonly setTimeout: (callback: TimeoutCallback, delay: number) => TTimerId\n    readonly clearTimeout: (timeoutId: TTimerId | undefined) => void\n\n    readonly setInterval: (callback: TimeoutCallback, delay: number) => TTimerId\n    readonly clearInterval: (intervalId: TTimerId | undefined) => void\n  }\n\ntype SystemTimerId = ReturnType<typeof setTimeout>\n\nexport const defaultTimeoutProvider: TimeoutProvider = {\n  // We need the wrapper function syntax below instead of direct references to\n  // global setTimeout etc.\n  //\n  // BAD: `setTimeout: setTimeout`\n  // GOOD: `setTimeout: (cb, delay) => setTimeout(cb, delay)`\n  //\n  // If we use direct references here, then anything that wants to spy on or\n  // replace the global setTimeout (like tests) won't work since we'll already\n  // have a hard reference to the original implementation at the time when this\n  // file was imported.\n  setTimeout: (callback, delay) => setTimeout(callback, delay),\n  clearTimeout: (timeoutId) =>\n    clearTimeout(timeoutId as SystemTimerId | undefined),\n\n  setInterval: (callback, delay) => setInterval(callback, delay),\n  clearInterval: (intervalId) =>\n    clearInterval(intervalId as SystemTimerId | undefined),\n}\n\n/**\n * Allows customization of how timeouts are created.\n *\n * @tanstack/query-core makes liberal use of timeouts to implement `staleTime`\n * and `gcTime`. The default TimeoutManager provider uses the platform's global\n * `setTimeout` implementation, which is known to have scalability issues with\n * thousands of timeouts on the event loop.\n *\n * If you hit this limitation, consider providing a custom TimeoutProvider that\n * coalesces timeouts.\n */\nexport class TimeoutManager implements Omit<TimeoutProvider, 'name'> {\n  // We cannot have TimeoutManager<T> as we must instantiate it with a concrete\n  // type at app boot; and if we leave that type, then any new timer provider\n  // would need to support the default provider's concrete timer ID, which is\n  // infeasible across environments.\n  //\n  // We settle for type safety for the TimeoutProvider type, and accept that\n  // this class is unsafe internally to allow for extension.\n  #provider: TimeoutProvider<any> = defaultTimeoutProvider\n  #providerCalled = false\n\n  setTimeoutProvider<TTimerId extends ManagedTimerId>(\n    provider: TimeoutProvider<TTimerId>,\n  ): void {\n    if (process.env.NODE_ENV !== 'production') {\n      if (this.#providerCalled && provider !== this.#provider) {\n        // After changing providers, `clearTimeout` will not work as expected for\n        // timeouts from the previous provider.\n        //\n        // Since they may allocate the same timeout ID, clearTimeout may cancel an\n        // arbitrary different timeout, or unexpected no-op.\n        //\n        // We could protect against this by mixing the timeout ID bits\n        // deterministically with some per-provider bits.\n        //\n        // We could internally queue `setTimeout` calls to `TimeoutManager` until\n        // some API call to set the initial provider.\n        console.error(\n          `[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.`,\n          { previous: this.#provider, provider },\n        )\n      }\n    }\n\n    this.#provider = provider\n    if (process.env.NODE_ENV !== 'production') {\n      this.#providerCalled = false\n    }\n  }\n\n  setTimeout(callback: TimeoutCallback, delay: number): ManagedTimerId {\n    if (process.env.NODE_ENV !== 'production') {\n      this.#providerCalled = true\n    }\n    return this.#provider.setTimeout(callback, delay)\n  }\n\n  clearTimeout(timeoutId: ManagedTimerId | undefined): void {\n    this.#provider.clearTimeout(timeoutId)\n  }\n\n  setInterval(callback: TimeoutCallback, delay: number): ManagedTimerId {\n    if (process.env.NODE_ENV !== 'production') {\n      this.#providerCalled = true\n    }\n    return this.#provider.setInterval(callback, delay)\n  }\n\n  clearInterval(intervalId: ManagedTimerId | undefined): void {\n    this.#provider.clearInterval(intervalId)\n  }\n}\n\nexport const timeoutManager = new TimeoutManager()\n\n/**\n * In many cases code wants to delay to the next event loop tick; this is not\n * mediated by {@link timeoutManager}.\n *\n * This function is provided to make auditing the `tanstack/query-core` for\n * incorrect use of system `setTimeout` easier.\n */\nexport function systemSetTimeoutZero(callback: TimeoutCallback): void {\n  setTimeout(callback, 0)\n}\n"],"mappings":";;AAgCA,MAAa,yBAA0C;CAWrD,aAAa,UAAU,UAAU,WAAW,UAAU,KAAK;CAC3D,eAAe,cACb,aAAa,SAAsC;CAErD,cAAc,UAAU,UAAU,YAAY,UAAU,KAAK;CAC7D,gBAAgB,eACd,cAAc,UAAuC;AACzD;;;;;;;;;;;;;;AAaA,IAAa,iBAAb,MAAqE;;EAQjC,2BAAA,MAAA,WAAA,sBAAA;EAChB,2BAAA,MAAA,iBAAA,KAAA;;CAElB,mBACE,UACM;EACN,IAAI,QAAQ,IAAI,aAAa,cACvB;OAAA,uBAAA,iBAAA,IAAA,KAAwB,aAAA,uBAAA,WAAa,IAAA,GAYvC,QAAQ,MACN,8GACA;IAAE,UAAA,uBAAA,WAAU,IAAA;IAAgB;GAAS,CACvC;EAAA;EAIJ,uBAAA,WAAA,MAAiB,QAAA;EACjB,IAAI,QAAQ,IAAI,aAAa,cAC3B,uBAAA,iBAAA,MAAuB,KAAA;CAE3B;CAEA,WAAW,UAA2B,OAA+B;EACnE,IAAI,QAAQ,IAAI,aAAa,cAC3B,uBAAA,iBAAA,MAAuB,IAAA;EAEzB,OAAA,uBAAA,WAAO,IAAA,CAAA,CAAe,WAAW,UAAU,KAAK;CAClD;CAEA,aAAa,WAA6C;EACxD,uBAAA,WAAA,IAAA,CAAA,CAAe,aAAa,SAAS;CACvC;CAEA,YAAY,UAA2B,OAA+B;EACpE,IAAI,QAAQ,IAAI,aAAa,cAC3B,uBAAA,iBAAA,MAAuB,IAAA;EAEzB,OAAA,uBAAA,WAAO,IAAA,CAAA,CAAe,YAAY,UAAU,KAAK;CACnD;CAEA,cAAc,YAA8C;EAC1D,uBAAA,WAAA,IAAA,CAAA,CAAe,cAAc,UAAU;CACzC;AACF;AAEA,MAAa,iBAAiB,IAAI,eAAe;;;;;;;;AASjD,SAAgB,qBAAqB,UAAiC;CACpE,WAAW,UAAU,CAAC;AACxB"}