@tanstack/react-query 5.0.0-alpha.62 → 5.0.0-alpha.66

package/build/lib/HydrationBoundary.legacy.cjs

@@ -0,0 +1,50 @@
+'use client';
+'use strict';
+
+var React = require('react');
+var queryCore = require('@tanstack/query-core');
+var QueryClientProvider = require('./QueryClientProvider.legacy.cjs');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+
+const HydrationBoundary = ({
+  children,
+  options = {},
+  state,
+  queryClient
+}) => {
+  const client = QueryClientProvider.useQueryClient(queryClient);
+  const optionsRef = React__namespace.useRef(options);
+  optionsRef.current = options;
+
+  // Running hydrate again with the same queries is safe,
+  // it wont overwrite or initialize existing queries,
+  // relying on useMemo here is only a performance optimization.
+  // hydrate can and should be run *during* render here for SSR to work properly
+  React__namespace.useMemo(() => {
+    if (state) {
+      queryCore.hydrate(client, state, optionsRef.current);
+    }
+  }, [client, state]);
+  return children;
+};
+
+exports.HydrationBoundary = HydrationBoundary;
+//# sourceMappingURL=HydrationBoundary.legacy.cjs.map

package/build/lib/HydrationBoundary.legacy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"HydrationBoundary.legacy.cjs","sources":["../../src/HydrationBoundary.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport type { HydrateOptions, QueryClient } from '@tanstack/query-core'\nimport { hydrate } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\n\nexport interface HydrationBoundaryProps {\n  state?: unknown\n  options?: HydrateOptions\n  children?: React.ReactNode\n  queryClient?: QueryClient\n}\n\nexport const HydrationBoundary = ({\n  children,\n  options = {},\n  state,\n  queryClient,\n}: HydrationBoundaryProps) => {\n  const client = useQueryClient(queryClient)\n\n  const optionsRef = React.useRef(options)\n  optionsRef.current = options\n\n  // Running hydrate again with the same queries is safe,\n  // it wont overwrite or initialize existing queries,\n  // relying on useMemo here is only a performance optimization.\n  // hydrate can and should be run *during* render here for SSR to work properly\n  React.useMemo(() => {\n    if (state) {\n      hydrate(client, state, optionsRef.current)\n    }\n  }, [client, state])\n\n  return children as React.ReactElement\n}\n"],"names":["queryClient"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAcO;;;;AAILA;AACsB;AACtB;AAEA;;;AAGA;AACA;AACA;AACA;;AAEE;;AAEA;AACF;AAEA;AACF;;"}

package/build/lib/HydrationBoundary.legacy.js

@@ -0,0 +1,29 @@
+'use client';
+import * as React from 'react';
+import { hydrate } from '@tanstack/query-core';
+import { useQueryClient } from './QueryClientProvider.legacy.js';
+
+const HydrationBoundary = ({
+  children,
+  options = {},
+  state,
+  queryClient
+}) => {
+  const client = useQueryClient(queryClient);
+  const optionsRef = React.useRef(options);
+  optionsRef.current = options;
+
+  // Running hydrate again with the same queries is safe,
+  // it wont overwrite or initialize existing queries,
+  // relying on useMemo here is only a performance optimization.
+  // hydrate can and should be run *during* render here for SSR to work properly
+  React.useMemo(() => {
+    if (state) {
+      hydrate(client, state, optionsRef.current);
+    }
+  }, [client, state]);
+  return children;
+};
+
+export { HydrationBoundary };
+//# sourceMappingURL=HydrationBoundary.legacy.js.map

package/build/lib/HydrationBoundary.legacy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HydrationBoundary.legacy.js","sources":["../../src/HydrationBoundary.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport type { HydrateOptions, QueryClient } from '@tanstack/query-core'\nimport { hydrate } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\n\nexport interface HydrationBoundaryProps {\n  state?: unknown\n  options?: HydrateOptions\n  children?: React.ReactNode\n  queryClient?: QueryClient\n}\n\nexport const HydrationBoundary = ({\n  children,\n  options = {},\n  state,\n  queryClient,\n}: HydrationBoundaryProps) => {\n  const client = useQueryClient(queryClient)\n\n  const optionsRef = React.useRef(options)\n  optionsRef.current = options\n\n  // Running hydrate again with the same queries is safe,\n  // it wont overwrite or initialize existing queries,\n  // relying on useMemo here is only a performance optimization.\n  // hydrate can and should be run *during* render here for SSR to work properly\n  React.useMemo(() => {\n    if (state) {\n      hydrate(client, state, optionsRef.current)\n    }\n  }, [client, state])\n\n  return children as React.ReactElement\n}\n"],"names":["queryClient"],"mappings":";;;;;AAcO;;;;AAILA;AACsB;AACtB;AAEA;;;AAGA;AACA;AACA;AACA;;AAEE;;AAEA;AACF;AAEA;AACF;;"}

package/build/lib/QueryClientProvider.legacy.cjs

@@ -0,0 +1,54 @@
+'use client';
+'use strict';
+
+var React = require('react');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+
+const QueryClientContext = /*#__PURE__*/React__namespace.createContext(undefined);
+const useQueryClient = queryClient => {
+  const client = React__namespace.useContext(QueryClientContext);
+  if (queryClient) {
+    return queryClient;
+  }
+  if (!client) {
+    throw new Error('No QueryClient set, use QueryClientProvider to set one');
+  }
+  return client;
+};
+const QueryClientProvider = ({
+  client,
+  children
+}) => {
+  React__namespace.useEffect(() => {
+    client.mount();
+    return () => {
+      client.unmount();
+    };
+  }, [client]);
+  return /*#__PURE__*/React__namespace.createElement(QueryClientContext.Provider, {
+    value: client
+  }, children);
+};
+
+exports.QueryClientContext = QueryClientContext;
+exports.QueryClientProvider = QueryClientProvider;
+exports.useQueryClient = useQueryClient;
+//# sourceMappingURL=QueryClientProvider.legacy.cjs.map

package/build/lib/QueryClientProvider.legacy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryClientProvider.legacy.cjs","sources":["../../src/QueryClientProvider.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport type { QueryClient } from '@tanstack/query-core'\n\nexport const QueryClientContext = React.createContext<QueryClient | undefined>(\n  undefined,\n)\n\nexport const useQueryClient = (queryClient?: QueryClient) => {\n  const client = React.useContext(QueryClientContext)\n\n  if (queryClient) {\n    return queryClient\n  }\n\n  if (!client) {\n    throw new Error('No QueryClient set, use QueryClientProvider to set one')\n  }\n\n  return client\n}\n\nexport type QueryClientProviderProps = {\n  client: QueryClient\n  children?: React.ReactNode\n}\n\nexport const QueryClientProvider = ({\n  client,\n  children,\n}: QueryClientProviderProps): JSX.Element => {\n  React.useEffect(() => {\n    client.mount()\n    return () => {\n      client.unmount()\n    }\n  }, [client])\n\n  return (\n    <QueryClientContext.Provider value={client}>\n      {children}\n    </QueryClientContext.Provider>\n  )\n}\n"],"names":["useQueryClient","children","value"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAKO;AAIMA;AACX;AAEA;AACE;AACF;;AAGE;AACF;AAEA;AACF;AAOO;;AAELC;AACwB;;;AAGtB;;;AAGF;AAEA;AAC+BC;AAAc;AAI/C;;;;"}

package/build/lib/QueryClientProvider.legacy.js

@@ -0,0 +1,31 @@
+'use client';
+import * as React from 'react';
+
+const QueryClientContext = /*#__PURE__*/React.createContext(undefined);
+const useQueryClient = queryClient => {
+  const client = React.useContext(QueryClientContext);
+  if (queryClient) {
+    return queryClient;
+  }
+  if (!client) {
+    throw new Error('No QueryClient set, use QueryClientProvider to set one');
+  }
+  return client;
+};
+const QueryClientProvider = ({
+  client,
+  children
+}) => {
+  React.useEffect(() => {
+    client.mount();
+    return () => {
+      client.unmount();
+    };
+  }, [client]);
+  return /*#__PURE__*/React.createElement(QueryClientContext.Provider, {
+    value: client
+  }, children);
+};
+
+export { QueryClientContext, QueryClientProvider, useQueryClient };
+//# sourceMappingURL=QueryClientProvider.legacy.js.map

package/build/lib/QueryClientProvider.legacy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryClientProvider.legacy.js","sources":["../../src/QueryClientProvider.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport type { QueryClient } from '@tanstack/query-core'\n\nexport const QueryClientContext = React.createContext<QueryClient | undefined>(\n  undefined,\n)\n\nexport const useQueryClient = (queryClient?: QueryClient) => {\n  const client = React.useContext(QueryClientContext)\n\n  if (queryClient) {\n    return queryClient\n  }\n\n  if (!client) {\n    throw new Error('No QueryClient set, use QueryClientProvider to set one')\n  }\n\n  return client\n}\n\nexport type QueryClientProviderProps = {\n  client: QueryClient\n  children?: React.ReactNode\n}\n\nexport const QueryClientProvider = ({\n  client,\n  children,\n}: QueryClientProviderProps): JSX.Element => {\n  React.useEffect(() => {\n    client.mount()\n    return () => {\n      client.unmount()\n    }\n  }, [client])\n\n  return (\n    <QueryClientContext.Provider value={client}>\n      {children}\n    </QueryClientContext.Provider>\n  )\n}\n"],"names":["useQueryClient","children","value"],"mappings":";;;AAKO;AAIMA;AACX;AAEA;AACE;AACF;;AAGE;AACF;AAEA;AACF;AAOO;;AAELC;AACwB;;;AAGtB;;;AAGF;AAEA;AAC+BC;AAAc;AAI/C;;"}

package/build/lib/QueryErrorResetBoundary.legacy.cjs

@@ -0,0 +1,60 @@
+'use client';
+'use strict';
+
+var React = require('react');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+
+// CONTEXT
+
+function createValue() {
+  let isReset = false;
+  return {
+    clearReset: () => {
+      isReset = false;
+    },
+    reset: () => {
+      isReset = true;
+    },
+    isReset: () => {
+      return isReset;
+    }
+  };
+}
+const QueryErrorResetBoundaryContext = /*#__PURE__*/React__namespace.createContext(createValue());
+
+// HOOK
+
+const useQueryErrorResetBoundary = () => React__namespace.useContext(QueryErrorResetBoundaryContext);
+
+// COMPONENT
+
+const QueryErrorResetBoundary = ({
+  children
+}) => {
+  const [value] = React__namespace.useState(() => createValue());
+  return /*#__PURE__*/React__namespace.createElement(QueryErrorResetBoundaryContext.Provider, {
+    value: value
+  }, typeof children === 'function' ? children(value) : children);
+};
+
+exports.QueryErrorResetBoundary = QueryErrorResetBoundary;
+exports.useQueryErrorResetBoundary = useQueryErrorResetBoundary;
+//# sourceMappingURL=QueryErrorResetBoundary.legacy.cjs.map

package/build/lib/QueryErrorResetBoundary.legacy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryErrorResetBoundary.legacy.cjs","sources":["../../src/QueryErrorResetBoundary.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\n// CONTEXT\n\nexport interface QueryErrorResetBoundaryValue {\n  clearReset: () => void\n  isReset: () => boolean\n  reset: () => void\n}\n\nfunction createValue(): QueryErrorResetBoundaryValue {\n  let isReset = false\n  return {\n    clearReset: () => {\n      isReset = false\n    },\n    reset: () => {\n      isReset = true\n    },\n    isReset: () => {\n      return isReset\n    },\n  }\n}\n\nconst QueryErrorResetBoundaryContext = React.createContext(createValue())\n\n// HOOK\n\nexport const useQueryErrorResetBoundary = () =>\n  React.useContext(QueryErrorResetBoundaryContext)\n\n// COMPONENT\n\nexport interface QueryErrorResetBoundaryProps {\n  children:\n    | ((value: QueryErrorResetBoundaryValue) => React.ReactNode)\n    | React.ReactNode\n}\n\nexport const QueryErrorResetBoundary = ({\n  children,\n}: QueryErrorResetBoundaryProps) => {\n  const [value] = React.useState(() => createValue())\n  return (\n    <QueryErrorResetBoundaryContext.Provider value={value}>\n      {typeof children === 'function'\n        ? (children as Function)(value)\n        : children}\n    </QueryErrorResetBoundaryContext.Provider>\n  )\n}\n"],"names":["isReset","children","value"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAGA;;AAQA;;;;AAIMA;;;AAGAA;;;AAGA;AACF;;AAEJ;AAEA;;AAEA;;AAEO;;AAGP;;AAQO;AACLC;AAC4B;AAC5B;AACA;AAC2CC;;AAM7C;;;"}

package/build/lib/QueryErrorResetBoundary.legacy.js

@@ -0,0 +1,38 @@
+'use client';
+import * as React from 'react';
+
+// CONTEXT
+
+function createValue() {
+  let isReset = false;
+  return {
+    clearReset: () => {
+      isReset = false;
+    },
+    reset: () => {
+      isReset = true;
+    },
+    isReset: () => {
+      return isReset;
+    }
+  };
+}
+const QueryErrorResetBoundaryContext = /*#__PURE__*/React.createContext(createValue());
+
+// HOOK
+
+const useQueryErrorResetBoundary = () => React.useContext(QueryErrorResetBoundaryContext);
+
+// COMPONENT
+
+const QueryErrorResetBoundary = ({
+  children
+}) => {
+  const [value] = React.useState(() => createValue());
+  return /*#__PURE__*/React.createElement(QueryErrorResetBoundaryContext.Provider, {
+    value: value
+  }, typeof children === 'function' ? children(value) : children);
+};
+
+export { QueryErrorResetBoundary, useQueryErrorResetBoundary };
+//# sourceMappingURL=QueryErrorResetBoundary.legacy.js.map

package/build/lib/QueryErrorResetBoundary.legacy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryErrorResetBoundary.legacy.js","sources":["../../src/QueryErrorResetBoundary.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\n// CONTEXT\n\nexport interface QueryErrorResetBoundaryValue {\n  clearReset: () => void\n  isReset: () => boolean\n  reset: () => void\n}\n\nfunction createValue(): QueryErrorResetBoundaryValue {\n  let isReset = false\n  return {\n    clearReset: () => {\n      isReset = false\n    },\n    reset: () => {\n      isReset = true\n    },\n    isReset: () => {\n      return isReset\n    },\n  }\n}\n\nconst QueryErrorResetBoundaryContext = React.createContext(createValue())\n\n// HOOK\n\nexport const useQueryErrorResetBoundary = () =>\n  React.useContext(QueryErrorResetBoundaryContext)\n\n// COMPONENT\n\nexport interface QueryErrorResetBoundaryProps {\n  children:\n    | ((value: QueryErrorResetBoundaryValue) => React.ReactNode)\n    | React.ReactNode\n}\n\nexport const QueryErrorResetBoundary = ({\n  children,\n}: QueryErrorResetBoundaryProps) => {\n  const [value] = React.useState(() => createValue())\n  return (\n    <QueryErrorResetBoundaryContext.Provider value={value}>\n      {typeof children === 'function'\n        ? (children as Function)(value)\n        : children}\n    </QueryErrorResetBoundaryContext.Provider>\n  )\n}\n"],"names":["isReset","children","value"],"mappings":";;;AAGA;;AAQA;;;;AAIMA;;;AAGAA;;;AAGA;AACF;;AAEJ;AAEA;;AAEA;;AAEO;;AAGP;;AAQO;AACLC;AAC4B;AAC5B;AACA;AAC2CC;;AAM7C;;"}

package/build/lib/errorBoundaryUtils.legacy.cjs

@@ -0,0 +1,51 @@
+'use client';
+'use strict';
+
+var React = require('react');
+var utils = require('./utils.legacy.cjs');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+
+const ensurePreventErrorBoundaryRetry = (options, errorResetBoundary) => {
+  if (options.suspense || options.throwOnError) {
+    // Prevent retrying failed query if the error boundary has not been reset yet
+    if (!errorResetBoundary.isReset()) {
+      options.retryOnMount = false;
+    }
+  }
+};
+const useClearResetErrorBoundary = errorResetBoundary => {
+  React__namespace.useEffect(() => {
+    errorResetBoundary.clearReset();
+  }, [errorResetBoundary]);
+};
+const getHasError = ({
+  result,
+  errorResetBoundary,
+  throwOnError,
+  query
+}) => {
+  return result.isError && !errorResetBoundary.isReset() && !result.isFetching && utils.shouldThrowError(throwOnError, [result.error, query]);
+};
+
+exports.ensurePreventErrorBoundaryRetry = ensurePreventErrorBoundaryRetry;
+exports.getHasError = getHasError;
+exports.useClearResetErrorBoundary = useClearResetErrorBoundary;
+//# sourceMappingURL=errorBoundaryUtils.legacy.cjs.map

package/build/lib/errorBoundaryUtils.legacy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorBoundaryUtils.legacy.cjs","sources":["../../src/errorBoundaryUtils.ts"],"sourcesContent":["'use client'\nimport type {\n  DefaultedQueryObserverOptions,\n  Query,\n  QueryKey,\n  QueryObserverResult,\n  ThrowOnError,\n} from '@tanstack/query-core'\nimport type { QueryErrorResetBoundaryValue } from './QueryErrorResetBoundary'\nimport * as React from 'react'\nimport { shouldThrowError } from './utils'\n\nexport const ensurePreventErrorBoundaryRetry = <\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryData,\n  TQueryKey extends QueryKey,\n>(\n  options: DefaultedQueryObserverOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryData,\n    TQueryKey\n  >,\n  errorResetBoundary: QueryErrorResetBoundaryValue,\n) => {\n  if (options.suspense || options.throwOnError) {\n    // Prevent retrying failed query if the error boundary has not been reset yet\n    if (!errorResetBoundary.isReset()) {\n      options.retryOnMount = false\n    }\n  }\n}\n\nexport const useClearResetErrorBoundary = (\n  errorResetBoundary: QueryErrorResetBoundaryValue,\n) => {\n  React.useEffect(() => {\n    errorResetBoundary.clearReset()\n  }, [errorResetBoundary])\n}\n\nexport const getHasError = <\n  TData,\n  TError,\n  TQueryFnData,\n  TQueryData,\n  TQueryKey extends QueryKey,\n>({\n  result,\n  errorResetBoundary,\n  throwOnError,\n  query,\n}: {\n  result: QueryObserverResult<TData, TError>\n  errorResetBoundary: QueryErrorResetBoundaryValue\n  throwOnError: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>\n  query: Query<TQueryFnData, TError, TQueryData, TQueryKey>\n}) => {\n  return (\n    result.isError &&\n    !errorResetBoundary.isReset() &&\n    !result.isFetching &&\n    shouldThrowError(throwOnError, [result.error, query])\n  )\n}\n"],"names":["useClearResetErrorBoundary","query"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA4BE;AACE;AACA;;AAEA;AACF;AACF;AAEaA;;;AAKX;AACF;AAEO;;;;AAULC;AAMF;;AAOA;;;;"}

package/build/lib/errorBoundaryUtils.legacy.js

@@ -0,0 +1,28 @@
+'use client';
+import * as React from 'react';
+import { shouldThrowError } from './utils.legacy.js';
+
+const ensurePreventErrorBoundaryRetry = (options, errorResetBoundary) => {
+  if (options.suspense || options.throwOnError) {
+    // Prevent retrying failed query if the error boundary has not been reset yet
+    if (!errorResetBoundary.isReset()) {
+      options.retryOnMount = false;
+    }
+  }
+};
+const useClearResetErrorBoundary = errorResetBoundary => {
+  React.useEffect(() => {
+    errorResetBoundary.clearReset();
+  }, [errorResetBoundary]);
+};
+const getHasError = ({
+  result,
+  errorResetBoundary,
+  throwOnError,
+  query
+}) => {
+  return result.isError && !errorResetBoundary.isReset() && !result.isFetching && shouldThrowError(throwOnError, [result.error, query]);
+};
+
+export { ensurePreventErrorBoundaryRetry, getHasError, useClearResetErrorBoundary };
+//# sourceMappingURL=errorBoundaryUtils.legacy.js.map

package/build/lib/errorBoundaryUtils.legacy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorBoundaryUtils.legacy.js","sources":["../../src/errorBoundaryUtils.ts"],"sourcesContent":["'use client'\nimport type {\n  DefaultedQueryObserverOptions,\n  Query,\n  QueryKey,\n  QueryObserverResult,\n  ThrowOnError,\n} from '@tanstack/query-core'\nimport type { QueryErrorResetBoundaryValue } from './QueryErrorResetBoundary'\nimport * as React from 'react'\nimport { shouldThrowError } from './utils'\n\nexport const ensurePreventErrorBoundaryRetry = <\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryData,\n  TQueryKey extends QueryKey,\n>(\n  options: DefaultedQueryObserverOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryData,\n    TQueryKey\n  >,\n  errorResetBoundary: QueryErrorResetBoundaryValue,\n) => {\n  if (options.suspense || options.throwOnError) {\n    // Prevent retrying failed query if the error boundary has not been reset yet\n    if (!errorResetBoundary.isReset()) {\n      options.retryOnMount = false\n    }\n  }\n}\n\nexport const useClearResetErrorBoundary = (\n  errorResetBoundary: QueryErrorResetBoundaryValue,\n) => {\n  React.useEffect(() => {\n    errorResetBoundary.clearReset()\n  }, [errorResetBoundary])\n}\n\nexport const getHasError = <\n  TData,\n  TError,\n  TQueryFnData,\n  TQueryData,\n  TQueryKey extends QueryKey,\n>({\n  result,\n  errorResetBoundary,\n  throwOnError,\n  query,\n}: {\n  result: QueryObserverResult<TData, TError>\n  errorResetBoundary: QueryErrorResetBoundaryValue\n  throwOnError: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>\n  query: Query<TQueryFnData, TError, TQueryData, TQueryKey>\n}) => {\n  return (\n    result.isError &&\n    !errorResetBoundary.isReset() &&\n    !result.isFetching &&\n    shouldThrowError(throwOnError, [result.error, query])\n  )\n}\n"],"names":["useClearResetErrorBoundary","query"],"mappings":";;;;;AA4BE;AACE;AACA;;AAEA;AACF;AACF;AAEaA;;;AAKX;AACF;AAEO;;;;AAULC;AAMF;;AAOA;;"}

package/build/lib/index.legacy.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+var queryCore = require('@tanstack/query-core');
+var useQueries = require('./useQueries.legacy.cjs');
+var useQuery = require('./useQuery.legacy.cjs');
+var QueryClientProvider = require('./QueryClientProvider.legacy.cjs');
+var HydrationBoundary = require('./HydrationBoundary.legacy.cjs');
+var QueryErrorResetBoundary = require('./QueryErrorResetBoundary.legacy.cjs');
+var useIsFetching = require('./useIsFetching.legacy.cjs');
+var useMutationState = require('./useMutationState.legacy.cjs');
+var useMutation = require('./useMutation.legacy.cjs');
+var useInfiniteQuery = require('./useInfiniteQuery.legacy.cjs');
+var isRestoring = require('./isRestoring.legacy.cjs');
+
+
+
+exports.useQueries = useQueries.useQueries;
+exports.queryOptions = useQuery.queryOptions;
+exports.useQuery = useQuery.useQuery;
+exports.QueryClientContext = QueryClientProvider.QueryClientContext;
+exports.QueryClientProvider = QueryClientProvider.QueryClientProvider;
+exports.useQueryClient = QueryClientProvider.useQueryClient;
+exports.HydrationBoundary = HydrationBoundary.HydrationBoundary;
+exports.QueryErrorResetBoundary = QueryErrorResetBoundary.QueryErrorResetBoundary;
+exports.useQueryErrorResetBoundary = QueryErrorResetBoundary.useQueryErrorResetBoundary;
+exports.useIsFetching = useIsFetching.useIsFetching;
+exports.useIsMutating = useMutationState.useIsMutating;
+exports.useMutationState = useMutationState.useMutationState;
+exports.useMutation = useMutation.useMutation;
+exports.useInfiniteQuery = useInfiniteQuery.useInfiniteQuery;
+exports.IsRestoringProvider = isRestoring.IsRestoringProvider;
+exports.useIsRestoring = isRestoring.useIsRestoring;
+Object.keys(queryCore).forEach(function (k) {
+  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return queryCore[k]; }
+  });
+});
+//# sourceMappingURL=index.legacy.cjs.map

package/build/lib/index.legacy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.legacy.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/lib/index.legacy.js

@@ -0,0 +1,12 @@
+export * from '@tanstack/query-core';
+export { useQueries } from './useQueries.legacy.js';
+export { queryOptions, useQuery } from './useQuery.legacy.js';
+export { QueryClientContext, QueryClientProvider, useQueryClient } from './QueryClientProvider.legacy.js';
+export { HydrationBoundary } from './HydrationBoundary.legacy.js';
+export { QueryErrorResetBoundary, useQueryErrorResetBoundary } from './QueryErrorResetBoundary.legacy.js';
+export { useIsFetching } from './useIsFetching.legacy.js';
+export { useIsMutating, useMutationState } from './useMutationState.legacy.js';
+export { useMutation } from './useMutation.legacy.js';
+export { useInfiniteQuery } from './useInfiniteQuery.legacy.js';
+export { IsRestoringProvider, useIsRestoring } from './isRestoring.legacy.js';
+//# sourceMappingURL=index.legacy.js.map

package/build/lib/index.legacy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.legacy.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;"}

package/build/lib/isRestoring.legacy.cjs

@@ -0,0 +1,31 @@
+'use client';
+'use strict';
+
+var React = require('react');
+
+function _interopNamespaceDefault(e) {
+	var n = Object.create(null);
+	if (e) {
+		Object.keys(e).forEach(function (k) {
+			if (k !== 'default') {
+				var d = Object.getOwnPropertyDescriptor(e, k);
+				Object.defineProperty(n, k, d.get ? d : {
+					enumerable: true,
+					get: function () { return e[k]; }
+				});
+			}
+		});
+	}
+	n.default = e;
+	return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+
+const IsRestoringContext = /*#__PURE__*/React__namespace.createContext(false);
+const useIsRestoring = () => React__namespace.useContext(IsRestoringContext);
+const IsRestoringProvider = IsRestoringContext.Provider;
+
+exports.IsRestoringProvider = IsRestoringProvider;
+exports.useIsRestoring = useIsRestoring;
+//# sourceMappingURL=isRestoring.legacy.cjs.map

package/build/lib/isRestoring.legacy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"isRestoring.legacy.cjs","sources":["../../src/isRestoring.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nconst IsRestoringContext = React.createContext(false)\n\nexport const useIsRestoring = () => React.useContext(IsRestoringContext)\nexport const IsRestoringProvider = IsRestoringContext.Provider\n"],"names":["IsRestoringProvider"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAGA;AAEO;AACMA;;;"}

package/build/lib/isRestoring.legacy.js

@@ -0,0 +1,9 @@
+'use client';
+import * as React from 'react';
+
+const IsRestoringContext = /*#__PURE__*/React.createContext(false);
+const useIsRestoring = () => React.useContext(IsRestoringContext);
+const IsRestoringProvider = IsRestoringContext.Provider;
+
+export { IsRestoringProvider, useIsRestoring };
+//# sourceMappingURL=isRestoring.legacy.js.map

package/build/lib/isRestoring.legacy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isRestoring.legacy.js","sources":["../../src/isRestoring.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nconst IsRestoringContext = React.createContext(false)\n\nexport const useIsRestoring = () => React.useContext(IsRestoringContext)\nexport const IsRestoringProvider = IsRestoringContext.Provider\n"],"names":["IsRestoringProvider"],"mappings":";;;AAGA;AAEO;AACMA;;"}

package/build/lib/suspense.legacy.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+const ensureStaleTime = defaultedOptions => {
+  if (defaultedOptions.suspense) {
+    // Always set stale time when using suspense to prevent
+    // fetching again when directly mounting after suspending
+    if (typeof defaultedOptions.staleTime !== 'number') {
+      defaultedOptions.staleTime = 1000;
+    }
+  }
+};
+const willFetch = (result, isRestoring) => result.isLoading && result.isFetching && !isRestoring;
+const shouldSuspend = (defaultedOptions, result, isRestoring) => (defaultedOptions == null ? void 0 : defaultedOptions.suspense) && willFetch(result, isRestoring);
+const fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).catch(() => {
+  errorResetBoundary.clearReset();
+});
+
+exports.ensureStaleTime = ensureStaleTime;
+exports.fetchOptimistic = fetchOptimistic;
+exports.shouldSuspend = shouldSuspend;
+exports.willFetch = willFetch;
+//# sourceMappingURL=suspense.legacy.cjs.map

package/build/lib/suspense.legacy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"suspense.legacy.cjs","sources":["../../src/suspense.ts"],"sourcesContent":["import type {\n  DefaultedQueryObserverOptions,\n  QueryObserverResult,\n  QueryKey,\n  QueryObserver,\n} from '@tanstack/query-core'\nimport type { QueryErrorResetBoundaryValue } from './QueryErrorResetBoundary'\n\nexport const ensureStaleTime = (\n  defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any>,\n) => {\n  if (defaultedOptions.suspense) {\n    // Always set stale time when using suspense to prevent\n    // fetching again when directly mounting after suspending\n    if (typeof defaultedOptions.staleTime !== 'number') {\n      defaultedOptions.staleTime = 1000\n    }\n  }\n}\n\nexport const willFetch = (\n  result: QueryObserverResult<any, any>,\n  isRestoring: boolean,\n) => result.isLoading && result.isFetching && !isRestoring\n\nexport const shouldSuspend = (\n  defaultedOptions:\n    | DefaultedQueryObserverOptions<any, any, any, any, any>\n    | undefined,\n  result: QueryObserverResult<any, any>,\n  isRestoring: boolean,\n) => defaultedOptions?.suspense && willFetch(result, isRestoring)\n\nexport const fetchOptimistic = <\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryData,\n  TQueryKey extends QueryKey,\n>(\n  defaultedOptions: DefaultedQueryObserverOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryData,\n    TQueryKey\n  >,\n  observer: QueryObserver<TQueryFnData, TError, TData, TQueryData, TQueryKey>,\n  errorResetBoundary: QueryErrorResetBoundaryValue,\n) =>\n  observer.fetchOptimistic(defaultedOptions).catch(() => {\n    errorResetBoundary.clearReset()\n  })\n"],"names":["ensureStaleTime","defaultedOptions","suspense","staleTime","willFetch","result","isRestoring","isLoading","isFetching","shouldSuspend","fetchOptimistic","observer","errorResetBoundary","catch","clearReset"],"mappings":";;AAQaA,MAAAA,eAAe,GAC1BC,gBAAwE,IACrE;EACH,IAAIA,gBAAgB,CAACC,QAAQ,EAAE;AAC7B;AACA;AACA,IAAA,IAAI,OAAOD,gBAAgB,CAACE,SAAS,KAAK,QAAQ,EAAE;MAClDF,gBAAgB,CAACE,SAAS,GAAG,IAAI,CAAA;AACnC,KAAA;AACF,GAAA;AACF,EAAC;MAEYC,SAAS,GAAGA,CACvBC,MAAqC,EACrCC,WAAoB,KACjBD,MAAM,CAACE,SAAS,IAAIF,MAAM,CAACG,UAAU,IAAI,CAACF,YAAW;AAEnD,MAAMG,aAAa,GAAGA,CAC3BR,gBAEa,EACbI,MAAqC,EACrCC,WAAoB,KACjB,CAAAL,gBAAgB,IAAhBA,IAAAA,GAAAA,KAAAA,CAAAA,GAAAA,gBAAgB,CAAEC,QAAQ,KAAIE,SAAS,CAACC,MAAM,EAAEC,WAAW,EAAC;MAEpDI,eAAe,GAAGA,CAO7BT,gBAMC,EACDU,QAA2E,EAC3EC,kBAAgD,KAEhDD,QAAQ,CAACD,eAAe,CAACT,gBAAgB,CAAC,CAACY,KAAK,CAAC,MAAM;EACrDD,kBAAkB,CAACE,UAAU,EAAE,CAAA;AACjC,CAAC;;;;;;;"}

package/build/lib/suspense.legacy.js

@@ -0,0 +1,17 @@
+const ensureStaleTime = defaultedOptions => {
+  if (defaultedOptions.suspense) {
+    // Always set stale time when using suspense to prevent
+    // fetching again when directly mounting after suspending
+    if (typeof defaultedOptions.staleTime !== 'number') {
+      defaultedOptions.staleTime = 1000;
+    }
+  }
+};
+const willFetch = (result, isRestoring) => result.isLoading && result.isFetching && !isRestoring;
+const shouldSuspend = (defaultedOptions, result, isRestoring) => (defaultedOptions == null ? void 0 : defaultedOptions.suspense) && willFetch(result, isRestoring);
+const fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).catch(() => {
+  errorResetBoundary.clearReset();
+});
+
+export { ensureStaleTime, fetchOptimistic, shouldSuspend, willFetch };
+//# sourceMappingURL=suspense.legacy.js.map

package/build/lib/suspense.legacy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"suspense.legacy.js","sources":["../../src/suspense.ts"],"sourcesContent":["import type {\n  DefaultedQueryObserverOptions,\n  QueryObserverResult,\n  QueryKey,\n  QueryObserver,\n} from '@tanstack/query-core'\nimport type { QueryErrorResetBoundaryValue } from './QueryErrorResetBoundary'\n\nexport const ensureStaleTime = (\n  defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any>,\n) => {\n  if (defaultedOptions.suspense) {\n    // Always set stale time when using suspense to prevent\n    // fetching again when directly mounting after suspending\n    if (typeof defaultedOptions.staleTime !== 'number') {\n      defaultedOptions.staleTime = 1000\n    }\n  }\n}\n\nexport const willFetch = (\n  result: QueryObserverResult<any, any>,\n  isRestoring: boolean,\n) => result.isLoading && result.isFetching && !isRestoring\n\nexport const shouldSuspend = (\n  defaultedOptions:\n    | DefaultedQueryObserverOptions<any, any, any, any, any>\n    | undefined,\n  result: QueryObserverResult<any, any>,\n  isRestoring: boolean,\n) => defaultedOptions?.suspense && willFetch(result, isRestoring)\n\nexport const fetchOptimistic = <\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryData,\n  TQueryKey extends QueryKey,\n>(\n  defaultedOptions: DefaultedQueryObserverOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryData,\n    TQueryKey\n  >,\n  observer: QueryObserver<TQueryFnData, TError, TData, TQueryData, TQueryKey>,\n  errorResetBoundary: QueryErrorResetBoundaryValue,\n) =>\n  observer.fetchOptimistic(defaultedOptions).catch(() => {\n    errorResetBoundary.clearReset()\n  })\n"],"names":["ensureStaleTime","defaultedOptions","suspense","staleTime","willFetch","result","isRestoring","isLoading","isFetching","shouldSuspend","fetchOptimistic","observer","errorResetBoundary","catch","clearReset"],"mappings":"AAQaA,MAAAA,eAAe,GAC1BC,gBAAwE,IACrE;EACH,IAAIA,gBAAgB,CAACC,QAAQ,EAAE;AAC7B;AACA;AACA,IAAA,IAAI,OAAOD,gBAAgB,CAACE,SAAS,KAAK,QAAQ,EAAE;MAClDF,gBAAgB,CAACE,SAAS,GAAG,IAAI,CAAA;AACnC,KAAA;AACF,GAAA;AACF,EAAC;MAEYC,SAAS,GAAGA,CACvBC,MAAqC,EACrCC,WAAoB,KACjBD,MAAM,CAACE,SAAS,IAAIF,MAAM,CAACG,UAAU,IAAI,CAACF,YAAW;AAEnD,MAAMG,aAAa,GAAGA,CAC3BR,gBAEa,EACbI,MAAqC,EACrCC,WAAoB,KACjB,CAAAL,gBAAgB,IAAhBA,IAAAA,GAAAA,KAAAA,CAAAA,GAAAA,gBAAgB,CAAEC,QAAQ,KAAIE,SAAS,CAACC,MAAM,EAAEC,WAAW,EAAC;MAEpDI,eAAe,GAAGA,CAO7BT,gBAMC,EACDU,QAA2E,EAC3EC,kBAAgD,KAEhDD,QAAQ,CAACD,eAAe,CAACT,gBAAgB,CAAC,CAACY,KAAK,CAAC,MAAM;EACrDD,kBAAkB,CAACE,UAAU,EAAE,CAAA;AACjC,CAAC;;;;"}

package/build/lib/useBaseQuery.legacy.cjs

@@ -0,0 +1,80 @@
+'use client';
+'use strict';
+
+var React = require('react');
+var queryCore = require('@tanstack/query-core');
+var QueryErrorResetBoundary = require('./QueryErrorResetBoundary.legacy.cjs');
+var QueryClientProvider = require('./QueryClientProvider.legacy.cjs');
+var isRestoring = require('./isRestoring.legacy.cjs');
+var errorBoundaryUtils = require('./errorBoundaryUtils.legacy.cjs');
+var suspense = require('./suspense.legacy.cjs');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+
+function useBaseQuery(options, Observer, queryClient) {
+  const client = QueryClientProvider.useQueryClient(queryClient);
+  const isRestoring$1 = isRestoring.useIsRestoring();
+  const errorResetBoundary = QueryErrorResetBoundary.useQueryErrorResetBoundary();
+  const defaultedOptions = client.defaultQueryOptions(options);
+
+  // Make sure results are optimistically set in fetching state before subscribing or updating options
+  defaultedOptions._optimisticResults = isRestoring$1 ? 'isRestoring' : 'optimistic';
+  suspense.ensureStaleTime(defaultedOptions);
+  errorBoundaryUtils.ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary);
+  errorBoundaryUtils.useClearResetErrorBoundary(errorResetBoundary);
+  const [observer] = React__namespace.useState(() => new Observer(client, defaultedOptions));
+  const result = observer.getOptimisticResult(defaultedOptions);
+  React__namespace.useSyncExternalStore(React__namespace.useCallback(onStoreChange => {
+    const unsubscribe = isRestoring$1 ? () => undefined : observer.subscribe(queryCore.notifyManager.batchCalls(onStoreChange));
+
+    // Update result to make sure we did not miss any query updates
+    // between creating the observer and subscribing to it.
+    observer.updateResult();
+    return unsubscribe;
+  }, [observer, isRestoring$1]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
+  React__namespace.useEffect(() => {
+    // Do not notify on updates because of changes in the options because
+    // these changes should already be reflected in the optimistic result.
+    observer.setOptions(defaultedOptions, {
+      listeners: false
+    });
+  }, [defaultedOptions, observer]);
+
+  // Handle suspense
+  if (suspense.shouldSuspend(defaultedOptions, result, isRestoring$1)) {
+    throw suspense.fetchOptimistic(defaultedOptions, observer, errorResetBoundary);
+  }
+
+  // Handle error boundary
+  if (errorBoundaryUtils.getHasError({
+    result,
+    errorResetBoundary,
+    throwOnError: defaultedOptions.throwOnError,
+    query: observer.getCurrentQuery()
+  })) {
+    throw result.error;
+  }
+
+  // Handle result property usage tracking
+  return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
+}
+
+exports.useBaseQuery = useBaseQuery;
+//# sourceMappingURL=useBaseQuery.legacy.cjs.map