@tanstack/query-core 5.0.0-alpha.85 → 5.0.0-alpha.87

package/build/legacy/focusManager.cjs

@@ -0,0 +1,116 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw 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);
+  return value;
+};
+var focusManager_exports = {};
+__export(focusManager_exports, {
+  FocusManager: () => FocusManager,
+  focusManager: () => focusManager
+});
+module.exports = __toCommonJS(focusManager_exports);
+var import_subscribable = require("./subscribable");
+var import_utils = require("./utils");
+var _focused, _cleanup, _setup;
+class FocusManager extends import_subscribable.Subscribable {
+  constructor() {
+    super();
+    __privateAdd(this, _focused, void 0);
+    __privateAdd(this, _cleanup, void 0);
+    __privateAdd(this, _setup, void 0);
+    __privateSet(this, _setup, (onFocus) => {
+      if (!import_utils.isServer && window.addEventListener) {
+        const listener = () => onFocus();
+        window.addEventListener("visibilitychange", listener, false);
+        return () => {
+          window.removeEventListener("visibilitychange", listener);
+        };
+      }
+      return;
+    });
+  }
+  onSubscribe() {
+    if (!__privateGet(this, _cleanup)) {
+      this.setEventListener(__privateGet(this, _setup));
+    }
+  }
+  onUnsubscribe() {
+    var _a;
+    if (!this.hasListeners()) {
+      (_a = __privateGet(this, _cleanup)) == null ? void 0 : _a.call(this);
+      __privateSet(this, _cleanup, void 0);
+    }
+  }
+  setEventListener(setup) {
+    var _a;
+    __privateSet(this, _setup, setup);
+    (_a = __privateGet(this, _cleanup)) == null ? void 0 : _a.call(this);
+    __privateSet(this, _cleanup, setup((focused) => {
+      if (typeof focused === "boolean") {
+        this.setFocused(focused);
+      } else {
+        this.onFocus();
+      }
+    }));
+  }
+  setFocused(focused) {
+    const changed = __privateGet(this, _focused) !== focused;
+    if (changed) {
+      __privateSet(this, _focused, focused);
+      this.onFocus();
+    }
+  }
+  onFocus() {
+    this.listeners.forEach((listener) => {
+      listener();
+    });
+  }
+  isFocused() {
+    var _a;
+    if (typeof __privateGet(this, _focused) === "boolean") {
+      return __privateGet(this, _focused);
+    }
+    return ((_a = globalThis.document) == null ? void 0 : _a.visibilityState) !== "hidden";
+  }
+}
+_focused = new WeakMap();
+_cleanup = new WeakMap();
+_setup = new WeakMap();
+const focusManager = new FocusManager();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FocusManager,
+  focusManager
+});
+//# sourceMappingURL=focusManager.cjs.map

package/build/legacy/focusManager.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/focusManager.ts"],"sourcesContent":["import { Subscribable } from './subscribable'\nimport { isServer } from './utils'\n\ntype SetupFn = (\n  setFocused: (focused?: boolean) => void,\n) => (() => void) | undefined\n\nexport class FocusManager extends Subscribable {\n  #focused?: boolean\n  #cleanup?: () => void\n\n  #setup: SetupFn\n\n  constructor() {\n    super()\n    this.#setup = (onFocus) => {\n      // addEventListener does not exist in React Native, but window does\n      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n      if (!isServer && window.addEventListener) {\n        const listener = () => onFocus()\n        // Listen to visibilitychange\n        window.addEventListener('visibilitychange', listener, false)\n\n        return () => {\n          // Be sure to unsubscribe if a new handler is set\n          window.removeEventListener('visibilitychange', listener)\n        }\n      }\n      return\n    }\n  }\n\n  protected onSubscribe(): void {\n    if (!this.#cleanup) {\n      this.setEventListener(this.#setup)\n    }\n  }\n\n  protected onUnsubscribe() {\n    if (!this.hasListeners()) {\n      this.#cleanup?.()\n      this.#cleanup = undefined\n    }\n  }\n\n  setEventListener(setup: SetupFn): void {\n    this.#setup = setup\n    this.#cleanup?.()\n    this.#cleanup = setup((focused) => {\n      if (typeof focused === 'boolean') {\n        this.setFocused(focused)\n      } else {\n        this.onFocus()\n      }\n    })\n  }\n\n  setFocused(focused?: boolean): void {\n    const changed = this.#focused !== focused\n    if (changed) {\n      this.#focused = focused\n      this.onFocus()\n    }\n  }\n\n  onFocus(): void {\n    this.listeners.forEach((listener) => {\n      listener()\n    })\n  }\n\n  isFocused(): boolean {\n    if (typeof this.#focused === 'boolean') {\n      return this.#focused\n    }\n\n    // document global can be unavailable in react native\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n    return globalThis.document?.visibilityState !== 'hidden'\n  }\n}\n\nexport const focusManager = new FocusManager()\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,0BAA6B;AAC7B,mBAAyB;AADzB;AAOO,MAAM,qBAAqB,iCAAa;AAAA,EAM7C,cAAc;AACZ,UAAM;AANR;AACA;AAEA;AAIE,uBAAK,QAAS,CAAC,YAAY;AAGzB,UAAI,CAAC,yBAAY,OAAO,kBAAkB;AACxC,cAAM,WAAW,MAAM,QAAQ;AAE/B,eAAO,iBAAiB,oBAAoB,UAAU,KAAK;AAE3D,eAAO,MAAM;AAEX,iBAAO,oBAAoB,oBAAoB,QAAQ;AAAA,QACzD;AAAA,MACF;AACA;AAAA,IACF;AAAA,EACF;AAAA,EAEU,cAAoB;AAC5B,QAAI,CAAC,mBAAK,WAAU;AAClB,WAAK,iBAAiB,mBAAK,OAAM;AAAA,IACnC;AAAA,EACF;AAAA,EAEU,gBAAgB;AAtC5B;AAuCI,QAAI,CAAC,KAAK,aAAa,GAAG;AACxB,+BAAK,cAAL;AACA,yBAAK,UAAW;AAAA,IAClB;AAAA,EACF;AAAA,EAEA,iBAAiB,OAAsB;AA7CzC;AA8CI,uBAAK,QAAS;AACd,6BAAK,cAAL;AACA,uBAAK,UAAW,MAAM,CAAC,YAAY;AACjC,UAAI,OAAO,YAAY,WAAW;AAChC,aAAK,WAAW,OAAO;AAAA,MACzB,OAAO;AACL,aAAK,QAAQ;AAAA,MACf;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EAEA,WAAW,SAAyB;AAClC,UAAM,UAAU,mBAAK,cAAa;AAClC,QAAI,SAAS;AACX,yBAAK,UAAW;AAChB,WAAK,QAAQ;AAAA,IACf;AAAA,EACF;AAAA,EAEA,UAAgB;AACd,SAAK,UAAU,QAAQ,CAAC,aAAa;AACnC,eAAS;AAAA,IACX,CAAC;AAAA,EACH;AAAA,EAEA,YAAqB;AAvEvB;AAwEI,QAAI,OAAO,mBAAK,cAAa,WAAW;AACtC,aAAO,mBAAK;AAAA,IACd;AAIA,aAAO,gBAAW,aAAX,mBAAqB,qBAAoB;AAAA,EAClD;AACF;AAxEE;AACA;AAEA;AAuEK,MAAM,eAAe,IAAI,aAAa;","names":[]}

package/build/legacy/focusManager.d.cts

@@ -0,0 +1,16 @@
+import { Subscribable } from './subscribable.cjs';
+
+type SetupFn = (setFocused: (focused?: boolean) => void) => (() => void) | undefined;
+declare class FocusManager extends Subscribable {
+    #private;
+    constructor();
+    protected onSubscribe(): void;
+    protected onUnsubscribe(): void;
+    setEventListener(setup: SetupFn): void;
+    setFocused(focused?: boolean): void;
+    onFocus(): void;
+    isFocused(): boolean;
+}
+declare const focusManager: FocusManager;
+
+export { FocusManager, focusManager };

package/build/{lib → legacy}/focusManager.d.ts

@@ -1,6 +1,7 @@
-import { Subscribable } from './subscribable';
+import { Subscribable } from './subscribable.js';
+
 type SetupFn = (setFocused: (focused?: boolean) => void) => (() => void) | undefined;
-export declare class FocusManager extends Subscribable {
+declare class FocusManager extends Subscribable {
     #private;
     constructor();
     protected onSubscribe(): void;
@@ -10,6 +11,6 @@ export declare class FocusManager extends Subscribable {
     onFocus(): void;
     isFocused(): boolean;
 }
-export declare const focusManager: FocusManager;
-export {};
-//# sourceMappingURL=focusManager.d.ts.map
+declare const focusManager: FocusManager;
+
+export { FocusManager, focusManager };

package/build/legacy/focusManager.js

@@ -0,0 +1,91 @@
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw 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);
+  return value;
+};
+var _focused, _cleanup, _setup;
+import { Subscribable } from "./subscribable";
+import { isServer } from "./utils";
+class FocusManager extends Subscribable {
+  constructor() {
+    super();
+    __privateAdd(this, _focused, void 0);
+    __privateAdd(this, _cleanup, void 0);
+    __privateAdd(this, _setup, void 0);
+    __privateSet(this, _setup, (onFocus) => {
+      if (!isServer && window.addEventListener) {
+        const listener = () => onFocus();
+        window.addEventListener("visibilitychange", listener, false);
+        return () => {
+          window.removeEventListener("visibilitychange", listener);
+        };
+      }
+      return;
+    });
+  }
+  onSubscribe() {
+    if (!__privateGet(this, _cleanup)) {
+      this.setEventListener(__privateGet(this, _setup));
+    }
+  }
+  onUnsubscribe() {
+    var _a;
+    if (!this.hasListeners()) {
+      (_a = __privateGet(this, _cleanup)) == null ? void 0 : _a.call(this);
+      __privateSet(this, _cleanup, void 0);
+    }
+  }
+  setEventListener(setup) {
+    var _a;
+    __privateSet(this, _setup, setup);
+    (_a = __privateGet(this, _cleanup)) == null ? void 0 : _a.call(this);
+    __privateSet(this, _cleanup, setup((focused) => {
+      if (typeof focused === "boolean") {
+        this.setFocused(focused);
+      } else {
+        this.onFocus();
+      }
+    }));
+  }
+  setFocused(focused) {
+    const changed = __privateGet(this, _focused) !== focused;
+    if (changed) {
+      __privateSet(this, _focused, focused);
+      this.onFocus();
+    }
+  }
+  onFocus() {
+    this.listeners.forEach((listener) => {
+      listener();
+    });
+  }
+  isFocused() {
+    var _a;
+    if (typeof __privateGet(this, _focused) === "boolean") {
+      return __privateGet(this, _focused);
+    }
+    return ((_a = globalThis.document) == null ? void 0 : _a.visibilityState) !== "hidden";
+  }
+}
+_focused = new WeakMap();
+_cleanup = new WeakMap();
+_setup = new WeakMap();
+const focusManager = new FocusManager();
+export {
+  FocusManager,
+  focusManager
+};
+//# sourceMappingURL=focusManager.js.map

package/build/legacy/focusManager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/focusManager.ts"],"sourcesContent":["import { Subscribable } from './subscribable'\nimport { isServer } from './utils'\n\ntype SetupFn = (\n  setFocused: (focused?: boolean) => void,\n) => (() => void) | undefined\n\nexport class FocusManager extends Subscribable {\n  #focused?: boolean\n  #cleanup?: () => void\n\n  #setup: SetupFn\n\n  constructor() {\n    super()\n    this.#setup = (onFocus) => {\n      // addEventListener does not exist in React Native, but window does\n      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n      if (!isServer && window.addEventListener) {\n        const listener = () => onFocus()\n        // Listen to visibilitychange\n        window.addEventListener('visibilitychange', listener, false)\n\n        return () => {\n          // Be sure to unsubscribe if a new handler is set\n          window.removeEventListener('visibilitychange', listener)\n        }\n      }\n      return\n    }\n  }\n\n  protected onSubscribe(): void {\n    if (!this.#cleanup) {\n      this.setEventListener(this.#setup)\n    }\n  }\n\n  protected onUnsubscribe() {\n    if (!this.hasListeners()) {\n      this.#cleanup?.()\n      this.#cleanup = undefined\n    }\n  }\n\n  setEventListener(setup: SetupFn): void {\n    this.#setup = setup\n    this.#cleanup?.()\n    this.#cleanup = setup((focused) => {\n      if (typeof focused === 'boolean') {\n        this.setFocused(focused)\n      } else {\n        this.onFocus()\n      }\n    })\n  }\n\n  setFocused(focused?: boolean): void {\n    const changed = this.#focused !== focused\n    if (changed) {\n      this.#focused = focused\n      this.onFocus()\n    }\n  }\n\n  onFocus(): void {\n    this.listeners.forEach((listener) => {\n      listener()\n    })\n  }\n\n  isFocused(): boolean {\n    if (typeof this.#focused === 'boolean') {\n      return this.#focused\n    }\n\n    // document global can be unavailable in react native\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n    return globalThis.document?.visibilityState !== 'hidden'\n  }\n}\n\nexport const focusManager = new FocusManager()\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA,SAAS,oBAAoB;AAC7B,SAAS,gBAAgB;AAMlB,MAAM,qBAAqB,aAAa;AAAA,EAM7C,cAAc;AACZ,UAAM;AANR;AACA;AAEA;AAIE,uBAAK,QAAS,CAAC,YAAY;AAGzB,UAAI,CAAC,YAAY,OAAO,kBAAkB;AACxC,cAAM,WAAW,MAAM,QAAQ;AAE/B,eAAO,iBAAiB,oBAAoB,UAAU,KAAK;AAE3D,eAAO,MAAM;AAEX,iBAAO,oBAAoB,oBAAoB,QAAQ;AAAA,QACzD;AAAA,MACF;AACA;AAAA,IACF;AAAA,EACF;AAAA,EAEU,cAAoB;AAC5B,QAAI,CAAC,mBAAK,WAAU;AAClB,WAAK,iBAAiB,mBAAK,OAAM;AAAA,IACnC;AAAA,EACF;AAAA,EAEU,gBAAgB;AAtC5B;AAuCI,QAAI,CAAC,KAAK,aAAa,GAAG;AACxB,+BAAK,cAAL;AACA,yBAAK,UAAW;AAAA,IAClB;AAAA,EACF;AAAA,EAEA,iBAAiB,OAAsB;AA7CzC;AA8CI,uBAAK,QAAS;AACd,6BAAK,cAAL;AACA,uBAAK,UAAW,MAAM,CAAC,YAAY;AACjC,UAAI,OAAO,YAAY,WAAW;AAChC,aAAK,WAAW,OAAO;AAAA,MACzB,OAAO;AACL,aAAK,QAAQ;AAAA,MACf;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EAEA,WAAW,SAAyB;AAClC,UAAM,UAAU,mBAAK,cAAa;AAClC,QAAI,SAAS;AACX,yBAAK,UAAW;AAChB,WAAK,QAAQ;AAAA,IACf;AAAA,EACF;AAAA,EAEA,UAAgB;AACd,SAAK,UAAU,QAAQ,CAAC,aAAa;AACnC,eAAS;AAAA,IACX,CAAC;AAAA,EACH;AAAA,EAEA,YAAqB;AAvEvB;AAwEI,QAAI,OAAO,mBAAK,cAAa,WAAW;AACtC,aAAO,mBAAK;AAAA,IACd;AAIA,aAAO,gBAAW,aAAX,mBAAqB,qBAAoB;AAAA,EAClD;AACF;AAxEE;AACA;AAEA;AAuEK,MAAM,eAAe,IAAI,aAAa;","names":[]}

package/build/legacy/hydration.cjs

@@ -0,0 +1,109 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 hydration_exports = {};
+__export(hydration_exports, {
+  defaultShouldDehydrateMutation: () => defaultShouldDehydrateMutation,
+  defaultShouldDehydrateQuery: () => defaultShouldDehydrateQuery,
+  dehydrate: () => dehydrate,
+  hydrate: () => hydrate
+});
+module.exports = __toCommonJS(hydration_exports);
+function dehydrateMutation(mutation) {
+  return {
+    mutationKey: mutation.options.mutationKey,
+    state: mutation.state,
+    ...mutation.meta && { meta: mutation.meta }
+  };
+}
+function dehydrateQuery(query) {
+  return {
+    state: query.state,
+    queryKey: query.queryKey,
+    queryHash: query.queryHash,
+    ...query.meta && { meta: query.meta }
+  };
+}
+function defaultShouldDehydrateMutation(mutation) {
+  return mutation.state.isPaused;
+}
+function defaultShouldDehydrateQuery(query) {
+  return query.state.status === "success";
+}
+function dehydrate(client, options = {}) {
+  const filterMutation = options.shouldDehydrateMutation ?? defaultShouldDehydrateMutation;
+  const mutations = client.getMutationCache().getAll().flatMap(
+    (mutation) => filterMutation(mutation) ? [dehydrateMutation(mutation)] : []
+  );
+  const filterQuery = options.shouldDehydrateQuery ?? defaultShouldDehydrateQuery;
+  const queries = client.getQueryCache().getAll().flatMap((query) => filterQuery(query) ? [dehydrateQuery(query)] : []);
+  return { mutations, queries };
+}
+function hydrate(client, dehydratedState, options) {
+  if (typeof dehydratedState !== "object" || dehydratedState === null) {
+    return;
+  }
+  const mutationCache = client.getMutationCache();
+  const queryCache = client.getQueryCache();
+  const mutations = dehydratedState.mutations || [];
+  const queries = dehydratedState.queries || [];
+  mutations.forEach((dehydratedMutation) => {
+    var _a;
+    mutationCache.build(
+      client,
+      {
+        ...(_a = options == null ? void 0 : options.defaultOptions) == null ? void 0 : _a.mutations,
+        mutationKey: dehydratedMutation.mutationKey,
+        meta: dehydratedMutation.meta
+      },
+      dehydratedMutation.state
+    );
+  });
+  queries.forEach((dehydratedQuery) => {
+    var _a;
+    const query = queryCache.get(dehydratedQuery.queryHash);
+    const dehydratedQueryState = {
+      ...dehydratedQuery.state,
+      fetchStatus: "idle"
+    };
+    if (query) {
+      if (query.state.dataUpdatedAt < dehydratedQueryState.dataUpdatedAt) {
+        query.setState(dehydratedQueryState);
+      }
+      return;
+    }
+    queryCache.build(
+      client,
+      {
+        ...(_a = options == null ? void 0 : options.defaultOptions) == null ? void 0 : _a.queries,
+        queryKey: dehydratedQuery.queryKey,
+        queryHash: dehydratedQuery.queryHash,
+        meta: dehydratedQuery.meta
+      },
+      dehydratedQueryState
+    );
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaultShouldDehydrateMutation,
+  defaultShouldDehydrateQuery,
+  dehydrate,
+  hydrate
+});
+//# sourceMappingURL=hydration.cjs.map

package/build/legacy/hydration.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hydration.ts"],"sourcesContent":["import type { QueryClient } from './queryClient'\nimport type { Query, QueryState } from './query'\nimport type {\n  MutationKey,\n  MutationMeta,\n  MutationOptions,\n  QueryKey,\n  QueryMeta,\n  QueryOptions,\n} from './types'\nimport type { Mutation, MutationState } from './mutation'\n\n// TYPES\n\nexport interface DehydrateOptions {\n  shouldDehydrateMutation?: (mutation: Mutation) => boolean\n  shouldDehydrateQuery?: (query: Query) => boolean\n}\n\nexport interface HydrateOptions {\n  defaultOptions?: {\n    queries?: QueryOptions\n    mutations?: MutationOptions\n  }\n}\n\ninterface DehydratedMutation {\n  mutationKey?: MutationKey\n  state: MutationState\n  meta?: MutationMeta\n}\n\ninterface DehydratedQuery {\n  queryHash: string\n  queryKey: QueryKey\n  state: QueryState\n  meta?: QueryMeta\n}\n\nexport interface DehydratedState {\n  mutations: DehydratedMutation[]\n  queries: DehydratedQuery[]\n}\n\n// FUNCTIONS\n\nfunction dehydrateMutation(mutation: Mutation): DehydratedMutation {\n  return {\n    mutationKey: mutation.options.mutationKey,\n    state: mutation.state,\n    ...(mutation.meta && { meta: mutation.meta }),\n  }\n}\n\n// Most config is not dehydrated but instead meant to configure again when\n// consuming the de/rehydrated data, typically with useQuery on the client.\n// Sometimes it might make sense to prefetch data on the server and include\n// in the html-payload, but not consume it on the initial render.\nfunction dehydrateQuery(query: Query): DehydratedQuery {\n  return {\n    state: query.state,\n    queryKey: query.queryKey,\n    queryHash: query.queryHash,\n    ...(query.meta && { meta: query.meta }),\n  }\n}\n\nexport function defaultShouldDehydrateMutation(mutation: Mutation) {\n  return mutation.state.isPaused\n}\n\nexport function defaultShouldDehydrateQuery(query: Query) {\n  return query.state.status === 'success'\n}\n\nexport function dehydrate(\n  client: QueryClient,\n  options: DehydrateOptions = {},\n): DehydratedState {\n  const filterMutation =\n    options.shouldDehydrateMutation ?? defaultShouldDehydrateMutation\n\n  const mutations = client\n    .getMutationCache()\n    .getAll()\n    .flatMap((mutation) =>\n      filterMutation(mutation) ? [dehydrateMutation(mutation)] : [],\n    )\n\n  const filterQuery =\n    options.shouldDehydrateQuery ?? defaultShouldDehydrateQuery\n\n  const queries = client\n    .getQueryCache()\n    .getAll()\n    .flatMap((query) => (filterQuery(query) ? [dehydrateQuery(query)] : []))\n\n  return { mutations, queries }\n}\n\nexport function hydrate(\n  client: QueryClient,\n  dehydratedState: unknown,\n  options?: HydrateOptions,\n): void {\n  if (typeof dehydratedState !== 'object' || dehydratedState === null) {\n    return\n  }\n\n  const mutationCache = client.getMutationCache()\n  const queryCache = client.getQueryCache()\n\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  const mutations = (dehydratedState as DehydratedState).mutations || []\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  const queries = (dehydratedState as DehydratedState).queries || []\n\n  mutations.forEach((dehydratedMutation) => {\n    mutationCache.build(\n      client,\n      {\n        ...options?.defaultOptions?.mutations,\n        mutationKey: dehydratedMutation.mutationKey,\n        meta: dehydratedMutation.meta,\n      },\n      dehydratedMutation.state,\n    )\n  })\n\n  queries.forEach((dehydratedQuery) => {\n    const query = queryCache.get(dehydratedQuery.queryHash)\n\n    // Reset fetch status to idle in the dehydrated state to avoid\n    // query being stuck in fetching state upon hydration\n    const dehydratedQueryState = {\n      ...dehydratedQuery.state,\n      fetchStatus: 'idle' as const,\n    }\n\n    // Do not hydrate if an existing query exists with newer data\n    if (query) {\n      if (query.state.dataUpdatedAt < dehydratedQueryState.dataUpdatedAt) {\n        query.setState(dehydratedQueryState)\n      }\n      return\n    }\n\n    // Restore query\n    queryCache.build(\n      client,\n      {\n        ...options?.defaultOptions?.queries,\n        queryKey: dehydratedQuery.queryKey,\n        queryHash: dehydratedQuery.queryHash,\n        meta: dehydratedQuery.meta,\n      },\n      dehydratedQueryState,\n    )\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA8CA,SAAS,kBAAkB,UAAwC;AACjE,SAAO;AAAA,IACL,aAAa,SAAS,QAAQ;AAAA,IAC9B,OAAO,SAAS;AAAA,IAChB,GAAI,SAAS,QAAQ,EAAE,MAAM,SAAS,KAAK;AAAA,EAC7C;AACF;AAMA,SAAS,eAAe,OAA+B;AACrD,SAAO;AAAA,IACL,OAAO,MAAM;AAAA,IACb,UAAU,MAAM;AAAA,IAChB,WAAW,MAAM;AAAA,IACjB,GAAI,MAAM,QAAQ,EAAE,MAAM,MAAM,KAAK;AAAA,EACvC;AACF;AAEO,SAAS,+BAA+B,UAAoB;AACjE,SAAO,SAAS,MAAM;AACxB;AAEO,SAAS,4BAA4B,OAAc;AACxD,SAAO,MAAM,MAAM,WAAW;AAChC;AAEO,SAAS,UACd,QACA,UAA4B,CAAC,GACZ;AACjB,QAAM,iBACJ,QAAQ,2BAA2B;AAErC,QAAM,YAAY,OACf,iBAAiB,EACjB,OAAO,EACP;AAAA,IAAQ,CAAC,aACR,eAAe,QAAQ,IAAI,CAAC,kBAAkB,QAAQ,CAAC,IAAI,CAAC;AAAA,EAC9D;AAEF,QAAM,cACJ,QAAQ,wBAAwB;AAElC,QAAM,UAAU,OACb,cAAc,EACd,OAAO,EACP,QAAQ,CAAC,UAAW,YAAY,KAAK,IAAI,CAAC,eAAe,KAAK,CAAC,IAAI,CAAC,CAAE;AAEzE,SAAO,EAAE,WAAW,QAAQ;AAC9B;AAEO,SAAS,QACd,QACA,iBACA,SACM;AACN,MAAI,OAAO,oBAAoB,YAAY,oBAAoB,MAAM;AACnE;AAAA,EACF;AAEA,QAAM,gBAAgB,OAAO,iBAAiB;AAC9C,QAAM,aAAa,OAAO,cAAc;AAGxC,QAAM,YAAa,gBAAoC,aAAa,CAAC;AAErE,QAAM,UAAW,gBAAoC,WAAW,CAAC;AAEjE,YAAU,QAAQ,CAAC,uBAAuB;AArH5C;AAsHI,kBAAc;AAAA,MACZ;AAAA,MACA;AAAA,QACE,IAAG,wCAAS,mBAAT,mBAAyB;AAAA,QAC5B,aAAa,mBAAmB;AAAA,QAChC,MAAM,mBAAmB;AAAA,MAC3B;AAAA,MACA,mBAAmB;AAAA,IACrB;AAAA,EACF,CAAC;AAED,UAAQ,QAAQ,CAAC,oBAAoB;AAjIvC;AAkII,UAAM,QAAQ,WAAW,IAAI,gBAAgB,SAAS;AAItD,UAAM,uBAAuB;AAAA,MAC3B,GAAG,gBAAgB;AAAA,MACnB,aAAa;AAAA,IACf;AAGA,QAAI,OAAO;AACT,UAAI,MAAM,MAAM,gBAAgB,qBAAqB,eAAe;AAClE,cAAM,SAAS,oBAAoB;AAAA,MACrC;AACA;AAAA,IACF;AAGA,eAAW;AAAA,MACT;AAAA,MACA;AAAA,QACE,IAAG,wCAAS,mBAAT,mBAAyB;AAAA,QAC5B,UAAU,gBAAgB;AAAA,QAC1B,WAAW,gBAAgB;AAAA,QAC3B,MAAM,gBAAgB;AAAA,MACxB;AAAA,MACA;AAAA,IACF;AAAA,EACF,CAAC;AACH;","names":[]}

package/build/legacy/hydration.d.cts

@@ -0,0 +1,35 @@
+import { n as Mutation, j as Query, y as QueryOptions, ai as MutationOptions, b as QueryClient, ae as MutationKey, o as MutationState, ag as MutationMeta, p as QueryKey, l as QueryState, x as QueryMeta } from './queryClient-4ba6364e.js';
+import './removable.cjs';
+import './subscribable.cjs';
+
+interface DehydrateOptions {
+    shouldDehydrateMutation?: (mutation: Mutation) => boolean;
+    shouldDehydrateQuery?: (query: Query) => boolean;
+}
+interface HydrateOptions {
+    defaultOptions?: {
+        queries?: QueryOptions;
+        mutations?: MutationOptions;
+    };
+}
+interface DehydratedMutation {
+    mutationKey?: MutationKey;
+    state: MutationState;
+    meta?: MutationMeta;
+}
+interface DehydratedQuery {
+    queryHash: string;
+    queryKey: QueryKey;
+    state: QueryState;
+    meta?: QueryMeta;
+}
+interface DehydratedState {
+    mutations: DehydratedMutation[];
+    queries: DehydratedQuery[];
+}
+declare function defaultShouldDehydrateMutation(mutation: Mutation): boolean;
+declare function defaultShouldDehydrateQuery(query: Query): boolean;
+declare function dehydrate(client: QueryClient, options?: DehydrateOptions): DehydratedState;
+declare function hydrate(client: QueryClient, dehydratedState: unknown, options?: HydrateOptions): void;
+
+export { DehydrateOptions, DehydratedState, HydrateOptions, defaultShouldDehydrateMutation, defaultShouldDehydrateQuery, dehydrate, hydrate };

package/build/legacy/hydration.d.ts

@@ -0,0 +1,35 @@
+import { n as Mutation, j as Query, y as QueryOptions, ai as MutationOptions, b as QueryClient, ae as MutationKey, o as MutationState, ag as MutationMeta, p as QueryKey, l as QueryState, x as QueryMeta } from './queryClient-d615ed9f.js';
+import './removable.js';
+import './subscribable.js';
+
+interface DehydrateOptions {
+    shouldDehydrateMutation?: (mutation: Mutation) => boolean;
+    shouldDehydrateQuery?: (query: Query) => boolean;
+}
+interface HydrateOptions {
+    defaultOptions?: {
+        queries?: QueryOptions;
+        mutations?: MutationOptions;
+    };
+}
+interface DehydratedMutation {
+    mutationKey?: MutationKey;
+    state: MutationState;
+    meta?: MutationMeta;
+}
+interface DehydratedQuery {
+    queryHash: string;
+    queryKey: QueryKey;
+    state: QueryState;
+    meta?: QueryMeta;
+}
+interface DehydratedState {
+    mutations: DehydratedMutation[];
+    queries: DehydratedQuery[];
+}
+declare function defaultShouldDehydrateMutation(mutation: Mutation): boolean;
+declare function defaultShouldDehydrateQuery(query: Query): boolean;
+declare function dehydrate(client: QueryClient, options?: DehydrateOptions): DehydratedState;
+declare function hydrate(client: QueryClient, dehydratedState: unknown, options?: HydrateOptions): void;
+
+export { DehydrateOptions, DehydratedState, HydrateOptions, defaultShouldDehydrateMutation, defaultShouldDehydrateQuery, dehydrate, hydrate };

package/build/legacy/hydration.js

@@ -0,0 +1,82 @@
+function dehydrateMutation(mutation) {
+  return {
+    mutationKey: mutation.options.mutationKey,
+    state: mutation.state,
+    ...mutation.meta && { meta: mutation.meta }
+  };
+}
+function dehydrateQuery(query) {
+  return {
+    state: query.state,
+    queryKey: query.queryKey,
+    queryHash: query.queryHash,
+    ...query.meta && { meta: query.meta }
+  };
+}
+function defaultShouldDehydrateMutation(mutation) {
+  return mutation.state.isPaused;
+}
+function defaultShouldDehydrateQuery(query) {
+  return query.state.status === "success";
+}
+function dehydrate(client, options = {}) {
+  const filterMutation = options.shouldDehydrateMutation ?? defaultShouldDehydrateMutation;
+  const mutations = client.getMutationCache().getAll().flatMap(
+    (mutation) => filterMutation(mutation) ? [dehydrateMutation(mutation)] : []
+  );
+  const filterQuery = options.shouldDehydrateQuery ?? defaultShouldDehydrateQuery;
+  const queries = client.getQueryCache().getAll().flatMap((query) => filterQuery(query) ? [dehydrateQuery(query)] : []);
+  return { mutations, queries };
+}
+function hydrate(client, dehydratedState, options) {
+  if (typeof dehydratedState !== "object" || dehydratedState === null) {
+    return;
+  }
+  const mutationCache = client.getMutationCache();
+  const queryCache = client.getQueryCache();
+  const mutations = dehydratedState.mutations || [];
+  const queries = dehydratedState.queries || [];
+  mutations.forEach((dehydratedMutation) => {
+    var _a;
+    mutationCache.build(
+      client,
+      {
+        ...(_a = options == null ? void 0 : options.defaultOptions) == null ? void 0 : _a.mutations,
+        mutationKey: dehydratedMutation.mutationKey,
+        meta: dehydratedMutation.meta
+      },
+      dehydratedMutation.state
+    );
+  });
+  queries.forEach((dehydratedQuery) => {
+    var _a;
+    const query = queryCache.get(dehydratedQuery.queryHash);
+    const dehydratedQueryState = {
+      ...dehydratedQuery.state,
+      fetchStatus: "idle"
+    };
+    if (query) {
+      if (query.state.dataUpdatedAt < dehydratedQueryState.dataUpdatedAt) {
+        query.setState(dehydratedQueryState);
+      }
+      return;
+    }
+    queryCache.build(
+      client,
+      {
+        ...(_a = options == null ? void 0 : options.defaultOptions) == null ? void 0 : _a.queries,
+        queryKey: dehydratedQuery.queryKey,
+        queryHash: dehydratedQuery.queryHash,
+        meta: dehydratedQuery.meta
+      },
+      dehydratedQueryState
+    );
+  });
+}
+export {
+  defaultShouldDehydrateMutation,
+  defaultShouldDehydrateQuery,
+  dehydrate,
+  hydrate
+};
+//# sourceMappingURL=hydration.js.map

package/build/legacy/hydration.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hydration.ts"],"sourcesContent":["import type { QueryClient } from './queryClient'\nimport type { Query, QueryState } from './query'\nimport type {\n  MutationKey,\n  MutationMeta,\n  MutationOptions,\n  QueryKey,\n  QueryMeta,\n  QueryOptions,\n} from './types'\nimport type { Mutation, MutationState } from './mutation'\n\n// TYPES\n\nexport interface DehydrateOptions {\n  shouldDehydrateMutation?: (mutation: Mutation) => boolean\n  shouldDehydrateQuery?: (query: Query) => boolean\n}\n\nexport interface HydrateOptions {\n  defaultOptions?: {\n    queries?: QueryOptions\n    mutations?: MutationOptions\n  }\n}\n\ninterface DehydratedMutation {\n  mutationKey?: MutationKey\n  state: MutationState\n  meta?: MutationMeta\n}\n\ninterface DehydratedQuery {\n  queryHash: string\n  queryKey: QueryKey\n  state: QueryState\n  meta?: QueryMeta\n}\n\nexport interface DehydratedState {\n  mutations: DehydratedMutation[]\n  queries: DehydratedQuery[]\n}\n\n// FUNCTIONS\n\nfunction dehydrateMutation(mutation: Mutation): DehydratedMutation {\n  return {\n    mutationKey: mutation.options.mutationKey,\n    state: mutation.state,\n    ...(mutation.meta && { meta: mutation.meta }),\n  }\n}\n\n// Most config is not dehydrated but instead meant to configure again when\n// consuming the de/rehydrated data, typically with useQuery on the client.\n// Sometimes it might make sense to prefetch data on the server and include\n// in the html-payload, but not consume it on the initial render.\nfunction dehydrateQuery(query: Query): DehydratedQuery {\n  return {\n    state: query.state,\n    queryKey: query.queryKey,\n    queryHash: query.queryHash,\n    ...(query.meta && { meta: query.meta }),\n  }\n}\n\nexport function defaultShouldDehydrateMutation(mutation: Mutation) {\n  return mutation.state.isPaused\n}\n\nexport function defaultShouldDehydrateQuery(query: Query) {\n  return query.state.status === 'success'\n}\n\nexport function dehydrate(\n  client: QueryClient,\n  options: DehydrateOptions = {},\n): DehydratedState {\n  const filterMutation =\n    options.shouldDehydrateMutation ?? defaultShouldDehydrateMutation\n\n  const mutations = client\n    .getMutationCache()\n    .getAll()\n    .flatMap((mutation) =>\n      filterMutation(mutation) ? [dehydrateMutation(mutation)] : [],\n    )\n\n  const filterQuery =\n    options.shouldDehydrateQuery ?? defaultShouldDehydrateQuery\n\n  const queries = client\n    .getQueryCache()\n    .getAll()\n    .flatMap((query) => (filterQuery(query) ? [dehydrateQuery(query)] : []))\n\n  return { mutations, queries }\n}\n\nexport function hydrate(\n  client: QueryClient,\n  dehydratedState: unknown,\n  options?: HydrateOptions,\n): void {\n  if (typeof dehydratedState !== 'object' || dehydratedState === null) {\n    return\n  }\n\n  const mutationCache = client.getMutationCache()\n  const queryCache = client.getQueryCache()\n\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  const mutations = (dehydratedState as DehydratedState).mutations || []\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  const queries = (dehydratedState as DehydratedState).queries || []\n\n  mutations.forEach((dehydratedMutation) => {\n    mutationCache.build(\n      client,\n      {\n        ...options?.defaultOptions?.mutations,\n        mutationKey: dehydratedMutation.mutationKey,\n        meta: dehydratedMutation.meta,\n      },\n      dehydratedMutation.state,\n    )\n  })\n\n  queries.forEach((dehydratedQuery) => {\n    const query = queryCache.get(dehydratedQuery.queryHash)\n\n    // Reset fetch status to idle in the dehydrated state to avoid\n    // query being stuck in fetching state upon hydration\n    const dehydratedQueryState = {\n      ...dehydratedQuery.state,\n      fetchStatus: 'idle' as const,\n    }\n\n    // Do not hydrate if an existing query exists with newer data\n    if (query) {\n      if (query.state.dataUpdatedAt < dehydratedQueryState.dataUpdatedAt) {\n        query.setState(dehydratedQueryState)\n      }\n      return\n    }\n\n    // Restore query\n    queryCache.build(\n      client,\n      {\n        ...options?.defaultOptions?.queries,\n        queryKey: dehydratedQuery.queryKey,\n        queryHash: dehydratedQuery.queryHash,\n        meta: dehydratedQuery.meta,\n      },\n      dehydratedQueryState,\n    )\n  })\n}\n"],"mappings":"AA8CA,SAAS,kBAAkB,UAAwC;AACjE,SAAO;AAAA,IACL,aAAa,SAAS,QAAQ;AAAA,IAC9B,OAAO,SAAS;AAAA,IAChB,GAAI,SAAS,QAAQ,EAAE,MAAM,SAAS,KAAK;AAAA,EAC7C;AACF;AAMA,SAAS,eAAe,OAA+B;AACrD,SAAO;AAAA,IACL,OAAO,MAAM;AAAA,IACb,UAAU,MAAM;AAAA,IAChB,WAAW,MAAM;AAAA,IACjB,GAAI,MAAM,QAAQ,EAAE,MAAM,MAAM,KAAK;AAAA,EACvC;AACF;AAEO,SAAS,+BAA+B,UAAoB;AACjE,SAAO,SAAS,MAAM;AACxB;AAEO,SAAS,4BAA4B,OAAc;AACxD,SAAO,MAAM,MAAM,WAAW;AAChC;AAEO,SAAS,UACd,QACA,UAA4B,CAAC,GACZ;AACjB,QAAM,iBACJ,QAAQ,2BAA2B;AAErC,QAAM,YAAY,OACf,iBAAiB,EACjB,OAAO,EACP;AAAA,IAAQ,CAAC,aACR,eAAe,QAAQ,IAAI,CAAC,kBAAkB,QAAQ,CAAC,IAAI,CAAC;AAAA,EAC9D;AAEF,QAAM,cACJ,QAAQ,wBAAwB;AAElC,QAAM,UAAU,OACb,cAAc,EACd,OAAO,EACP,QAAQ,CAAC,UAAW,YAAY,KAAK,IAAI,CAAC,eAAe,KAAK,CAAC,IAAI,CAAC,CAAE;AAEzE,SAAO,EAAE,WAAW,QAAQ;AAC9B;AAEO,SAAS,QACd,QACA,iBACA,SACM;AACN,MAAI,OAAO,oBAAoB,YAAY,oBAAoB,MAAM;AACnE;AAAA,EACF;AAEA,QAAM,gBAAgB,OAAO,iBAAiB;AAC9C,QAAM,aAAa,OAAO,cAAc;AAGxC,QAAM,YAAa,gBAAoC,aAAa,CAAC;AAErE,QAAM,UAAW,gBAAoC,WAAW,CAAC;AAEjE,YAAU,QAAQ,CAAC,uBAAuB;AArH5C;AAsHI,kBAAc;AAAA,MACZ;AAAA,MACA;AAAA,QACE,IAAG,wCAAS,mBAAT,mBAAyB;AAAA,QAC5B,aAAa,mBAAmB;AAAA,QAChC,MAAM,mBAAmB;AAAA,MAC3B;AAAA,MACA,mBAAmB;AAAA,IACrB;AAAA,EACF,CAAC;AAED,UAAQ,QAAQ,CAAC,oBAAoB;AAjIvC;AAkII,UAAM,QAAQ,WAAW,IAAI,gBAAgB,SAAS;AAItD,UAAM,uBAAuB;AAAA,MAC3B,GAAG,gBAAgB;AAAA,MACnB,aAAa;AAAA,IACf;AAGA,QAAI,OAAO;AACT,UAAI,MAAM,MAAM,gBAAgB,qBAAqB,eAAe;AAClE,cAAM,SAAS,oBAAoB;AAAA,MACrC;AACA;AAAA,IACF;AAGA,eAAW;AAAA,MACT;AAAA,MACA;AAAA,QACE,IAAG,wCAAS,mBAAT,mBAAyB;AAAA,QAC5B,UAAU,gBAAgB;AAAA,QAC1B,WAAW,gBAAgB;AAAA,QAC3B,MAAM,gBAAgB;AAAA,MACxB;AAAA,MACA;AAAA,IACF;AAAA,EACF,CAAC;AACH;","names":[]}

package/build/legacy/index.cjs

@@ -0,0 +1,85 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  CancelledError: () => import_retryer.CancelledError,
+  InfiniteQueryObserver: () => import_infiniteQueryObserver.InfiniteQueryObserver,
+  MutationCache: () => import_mutationCache.MutationCache,
+  MutationObserver: () => import_mutationObserver.MutationObserver,
+  QueriesObserver: () => import_queriesObserver.QueriesObserver,
+  QueryCache: () => import_queryCache.QueryCache,
+  QueryClient: () => import_queryClient.QueryClient,
+  QueryObserver: () => import_queryObserver.QueryObserver,
+  defaultShouldDehydrateMutation: () => import_hydration.defaultShouldDehydrateMutation,
+  defaultShouldDehydrateQuery: () => import_hydration.defaultShouldDehydrateQuery,
+  dehydrate: () => import_hydration.dehydrate,
+  focusManager: () => import_focusManager.focusManager,
+  hashKey: () => import_utils.hashKey,
+  hydrate: () => import_hydration.hydrate,
+  isCancelledError: () => import_retryer2.isCancelledError,
+  isServer: () => import_utils.isServer,
+  keepPreviousData: () => import_utils.keepPreviousData,
+  matchQuery: () => import_utils.matchQuery,
+  notifyManager: () => import_notifyManager.notifyManager,
+  onlineManager: () => import_onlineManager.onlineManager,
+  replaceEqualDeep: () => import_utils.replaceEqualDeep
+});
+module.exports = __toCommonJS(src_exports);
+var import_retryer = require("./retryer");
+var import_queryCache = require("./queryCache");
+var import_queryClient = require("./queryClient");
+var import_queryObserver = require("./queryObserver");
+var import_queriesObserver = require("./queriesObserver");
+var import_infiniteQueryObserver = require("./infiniteQueryObserver");
+var import_mutationCache = require("./mutationCache");
+var import_mutationObserver = require("./mutationObserver");
+var import_notifyManager = require("./notifyManager");
+var import_focusManager = require("./focusManager");
+var import_onlineManager = require("./onlineManager");
+var import_utils = require("./utils");
+var import_retryer2 = require("./retryer");
+var import_hydration = require("./hydration");
+__reExport(src_exports, require("./types"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CancelledError,
+  InfiniteQueryObserver,
+  MutationCache,
+  MutationObserver,
+  QueriesObserver,
+  QueryCache,
+  QueryClient,
+  QueryObserver,
+  defaultShouldDehydrateMutation,
+  defaultShouldDehydrateQuery,
+  dehydrate,
+  focusManager,
+  hashKey,
+  hydrate,
+  isCancelledError,
+  isServer,
+  keepPreviousData,
+  matchQuery,
+  notifyManager,
+  onlineManager,
+  replaceEqualDeep,
+  ...require("./types")
+});
+//# sourceMappingURL=index.cjs.map

package/build/legacy/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["/* istanbul ignore file */\n\nexport { CancelledError } from './retryer'\nexport { QueryCache } from './queryCache'\nexport type { QueryCacheNotifyEvent } from './queryCache'\nexport { QueryClient } from './queryClient'\nexport { QueryObserver } from './queryObserver'\nexport { QueriesObserver } from './queriesObserver'\nexport { InfiniteQueryObserver } from './infiniteQueryObserver'\nexport { MutationCache } from './mutationCache'\nexport { MutationObserver } from './mutationObserver'\nexport { notifyManager } from './notifyManager'\nexport { focusManager } from './focusManager'\nexport { onlineManager } from './onlineManager'\nexport {\n  hashKey,\n  replaceEqualDeep,\n  isServer,\n  matchQuery,\n  keepPreviousData,\n} from './utils'\nexport type { MutationFilters, QueryFilters, Updater } from './utils'\nexport { isCancelledError } from './retryer'\nexport {\n  dehydrate,\n  hydrate,\n  defaultShouldDehydrateQuery,\n  defaultShouldDehydrateMutation,\n} from './hydration'\n\n// Types\nexport * from './types'\nexport type { Query, QueryState } from './query'\nexport type { Mutation, MutationState } from './mutation'\nexport type {\n  DehydrateOptions,\n  DehydratedState,\n  HydrateOptions,\n} from './hydration'\nexport type { QueriesObserverOptions } from './queriesObserver'\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,qBAA+B;AAC/B,wBAA2B;AAE3B,yBAA4B;AAC5B,2BAA8B;AAC9B,6BAAgC;AAChC,mCAAsC;AACtC,2BAA8B;AAC9B,8BAAiC;AACjC,2BAA8B;AAC9B,0BAA6B;AAC7B,2BAA8B;AAC9B,mBAMO;AAEP,IAAAA,kBAAiC;AACjC,uBAKO;AAGP,wBAAc,oBA/Bd;","names":["import_retryer"]}

package/build/legacy/index.d.cts

@@ -0,0 +1,9 @@
+export { au as CancelOptions, C as CancelledError, D as DefaultError, at as DefaultOptions, z as DefaultPageParam, H as DefaultedInfiniteQueryObserverOptions, E as DefaultedQueryObserverOptions, a6 as DefinedQueryObserverResult, K as FetchInfiniteQueryOptions, Z as FetchNextPageOptions, _ as FetchPreviousPageOptions, J as FetchQueryOptions, a0 as FetchStatus, v as GetNextPageParamFunction, G as GetPreviousPageParamFunction, w as InfiniteData, a8 as InfiniteQueryObserverBaseResult, aa as InfiniteQueryObserverLoadingErrorResult, a9 as InfiniteQueryObserverLoadingResult, F as InfiniteQueryObserverOptions, ab as InfiniteQueryObserverRefetchErrorResult, ad as InfiniteQueryObserverResult, ac as InfiniteQueryObserverSuccessResult, A as InfiniteQueryPageParamsOptions, I as InitialDataFunction, X as InvalidateOptions, S as InvalidateQueryFilters, al as MutateFunction, ak as MutateOptions, n as Mutation, M as MutationCache, e as MutationFilters, ah as MutationFunction, ae as MutationKey, ag as MutationMeta, d as MutationObserver, am as MutationObserverBaseResult, ap as MutationObserverErrorResult, an as MutationObserverIdleResult, ao as MutationObserverLoadingResult, aj as MutationObserverOptions, ar as MutationObserverResult, aq as MutationObserverSuccessResult, ai as MutationOptions, o as MutationState, af as MutationStatus, N as NetworkMode, ax as NotifyEvent, aw as NotifyEventType, P as PlaceholderDataFunction, t as QueriesPlaceholderDataFunction, j as Query, Q as QueryCache, a as QueryCacheNotifyEvent, b as QueryClient, as as QueryClientConfig, f as QueryFilters, q as QueryFunction, s as QueryFunctionContext, p as QueryKey, u as QueryKeyHashFunction, x as QueryMeta, c as QueryObserver, a1 as QueryObserverBaseResult, a3 as QueryObserverLoadingErrorResult, a2 as QueryObserverLoadingResult, B as QueryObserverOptions, a4 as QueryObserverRefetchErrorResult, a7 as QueryObserverResult, a5 as QueryObserverSuccessResult, y as QueryOptions, l as QueryState, $ as QueryStatus, O as RefetchOptions, V as RefetchQueryFilters, R as Register, Y as ResetOptions, L as ResultOptions, av as SetDataOptions, T as ThrowOnError, U as Updater, W as WithRequired, h as hashKey, g as isCancelledError, i as isServer, k as keepPreviousData, m as matchQuery, r as replaceEqualDeep } from './queryClient-4ba6364e.js';
+export { QueriesObserver, QueriesObserverOptions } from './queriesObserver.cjs';
+export { InfiniteQueryObserver } from './infiniteQueryObserver.cjs';
+export { notifyManager } from './notifyManager.cjs';
+export { focusManager } from './focusManager.cjs';
+export { onlineManager } from './onlineManager.cjs';
+export { DehydrateOptions, DehydratedState, HydrateOptions, defaultShouldDehydrateMutation, defaultShouldDehydrateQuery, dehydrate, hydrate } from './hydration.cjs';
+import './removable.cjs';
+import './subscribable.cjs';