@suspensive/react-query-4 3.18.0 → 3.19.0

package/dist/{IsFetching-CThOxeZB.d.cts → IsFetching-CmAXgxBe.d.cts}

@@ -1,4 +1,4 @@
-import * as react_jsx_runtime5 from "react/jsx-runtime";
+import * as react_jsx_runtime7 from "react/jsx-runtime";
 import { QueryFilters, useIsFetching } from "@tanstack/react-query";
 import { ReactNode } from "react";
 
@@ -10,7 +10,7 @@ declare const IsFetching: ({
   children
 }: QueryFilters & {
   children: (isFetching: ReturnType<typeof useIsFetching>) => ReactNode;
-}) => react_jsx_runtime5.JSX.Element;
+}) => react_jsx_runtime7.JSX.Element;
 //#endregion
 export { IsFetching as t };
-//# sourceMappingURL=IsFetching-CThOxeZB.d.cts.map
+//# sourceMappingURL=IsFetching-CmAXgxBe.d.cts.map

package/dist/{IsFetching-CThOxeZB.d.cts.map → IsFetching-CmAXgxBe.d.cts.map}

@@ -1 +1 @@
-{"version":3,"file":"IsFetching-CThOxeZB.d.cts","names":[],"sources":["../src/IsFetching.tsx"],"sourcesContent":[],"mappings":";;;;;;;;AAQa,cAAA,UAIZ,EAAA,CAAA;EAAA;CAAA,EAFE,YAEF,GAAA;EAJ0B,QAAA,EAAA,CAAA,UAAA,EAEgB,UAFhB,CAAA,OAEkC,aAFlC,CAAA,EAAA,GAEqD,SAFrD;CAExB,EAAA,GAAwF,kBAAA,CAAA,GAAA,CAAA,OAAxF"}
+{"version":3,"file":"IsFetching-CmAXgxBe.d.cts","names":[],"sources":["../src/IsFetching.tsx"],"sourcesContent":[],"mappings":";;;;;;;;AAQa,cAAA,UAIZ,EAAA,CAAA;EAAA;CAAA,EAFE,YAEF,GAAA;EAJ0B,QAAA,EAAA,CAAA,UAAA,EAEgB,UAFhB,CAAA,OAEkC,aAFlC,CAAA,EAAA,GAEqD,SAFrD;CAExB,EAAA,GAAwF,kBAAA,CAAA,GAAA,CAAA,OAAxF"}

package/dist/IsFetching.d.cts

@@ -1,2 +1,2 @@
-import { t as IsFetching } from "./IsFetching-CThOxeZB.cjs";
+import { t as IsFetching } from "./IsFetching-CmAXgxBe.cjs";
 export { IsFetching };

package/dist/{PrefetchInfiniteQuery-C4FsMPPo.d.cts → PrefetchInfiniteQuery-BewcG5rR.d.cts}

@@ -1,4 +1,4 @@
-import * as react_jsx_runtime4 from "react/jsx-runtime";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
 import { FetchInfiniteQueryOptions, QueryKey } from "@tanstack/react-query";
 
 //#region src/PrefetchInfiniteQuery.d.ts
@@ -11,7 +11,7 @@ import { FetchInfiniteQueryOptions, QueryKey } from "@tanstack/react-query";
  * <PrefetchInfiniteQuery queryKey={['queryKey']} queryFn={queryFn} />
  * ```
  */
-declare function PrefetchInfiniteQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>): react_jsx_runtime4.JSX.Element;
+declare function PrefetchInfiniteQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>): react_jsx_runtime0.JSX.Element;
 //#endregion
 export { PrefetchInfiniteQuery as t };
-//# sourceMappingURL=PrefetchInfiniteQuery-C4FsMPPo.d.cts.map
+//# sourceMappingURL=PrefetchInfiniteQuery-BewcG5rR.d.cts.map

package/dist/{PrefetchInfiniteQuery-C4FsMPPo.d.cts.map → PrefetchInfiniteQuery-BewcG5rR.d.cts.map}

@@ -1 +1 @@
-{"version":3,"file":"PrefetchInfiniteQuery-C4FsMPPo.d.cts","names":[],"sources":["../src/PrefetchInfiniteQuery.tsx"],"sourcesContent":[],"mappings":";;;;;;;;AAaA;;;;;AAKmD,iBALnC,qBAKmC,CAAA,eAAA,OAAA,EAAA,SAAA,OAAA,EAAA,QAFzC,YAEyC,EAAA,kBAD/B,QAC+B,GADpB,QACoB,CAAA,CAAA,OAAA,EAAxC,yBAAwC,CAAd,YAAc,EAAA,MAAA,EAAQ,KAAR,EAAe,SAAf,CAAA,CAAA,EAAyB,kBAAA,CAAA,GAAA,CAAA,OAAzB"}
+{"version":3,"file":"PrefetchInfiniteQuery-BewcG5rR.d.cts","names":[],"sources":["../src/PrefetchInfiniteQuery.tsx"],"sourcesContent":[],"mappings":";;;;;;;;AAaA;;;;;AAKmD,iBALnC,qBAKmC,CAAA,eAAA,OAAA,EAAA,SAAA,OAAA,EAAA,QAFzC,YAEyC,EAAA,kBAD/B,QAC+B,GADpB,QACoB,CAAA,CAAA,OAAA,EAAxC,yBAAwC,CAAd,YAAc,EAAA,MAAA,EAAQ,KAAR,EAAe,SAAf,CAAA,CAAA,EAAyB,kBAAA,CAAA,GAAA,CAAA,OAAzB"}

package/dist/PrefetchInfiniteQuery.d.cts

@@ -1,2 +1,2 @@
-import { t as PrefetchInfiniteQuery } from "./PrefetchInfiniteQuery-C4FsMPPo.cjs";
+import { t as PrefetchInfiniteQuery } from "./PrefetchInfiniteQuery-BewcG5rR.cjs";
 export { PrefetchInfiniteQuery };

package/dist/{PrefetchQuery-DFwiRhmK.d.cts → PrefetchQuery-C3h9DidM.d.cts}

@@ -1,4 +1,4 @@
-import * as react_jsx_runtime7 from "react/jsx-runtime";
+import * as react_jsx_runtime1 from "react/jsx-runtime";
 import { FetchQueryOptions, QueryKey } from "@tanstack/react-query";
 
 //#region src/PrefetchQuery.d.ts
@@ -11,7 +11,7 @@ import { FetchQueryOptions, QueryKey } from "@tanstack/react-query";
  * <PrefetchQuery queryKey={['queryKey']} queryFn={queryFn} />
  * ```
  */
-declare function PrefetchQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>): react_jsx_runtime7.JSX.Element;
+declare function PrefetchQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>): react_jsx_runtime1.JSX.Element;
 //#endregion
 export { PrefetchQuery as t };
-//# sourceMappingURL=PrefetchQuery-DFwiRhmK.d.cts.map
+//# sourceMappingURL=PrefetchQuery-C3h9DidM.d.cts.map

package/dist/{PrefetchQuery-DFwiRhmK.d.cts.map → PrefetchQuery-C3h9DidM.d.cts.map}

@@ -1 +1 @@
-{"version":3,"file":"PrefetchQuery-DFwiRhmK.d.cts","names":[],"sources":["../src/PrefetchQuery.tsx"],"sourcesContent":[],"mappings":";;;;;;;;AAaA;;;;;AAK2C,iBAL3B,aAK2B,CAAA,eAAA,OAAA,EAAA,SAAA,OAAA,EAAA,QAFjC,YAEiC,EAAA,kBADvB,QACuB,GADZ,QACY,CAAA,CAAA,OAAA,EAAhC,iBAAgC,CAAd,YAAc,EAAA,MAAA,EAAQ,KAAR,EAAe,SAAf,CAAA,CAAA,EAAyB,kBAAA,CAAA,GAAA,CAAA,OAAzB"}
+{"version":3,"file":"PrefetchQuery-C3h9DidM.d.cts","names":[],"sources":["../src/PrefetchQuery.tsx"],"sourcesContent":[],"mappings":";;;;;;;;AAaA;;;;;AAK2C,iBAL3B,aAK2B,CAAA,eAAA,OAAA,EAAA,SAAA,OAAA,EAAA,QAFjC,YAEiC,EAAA,kBADvB,QACuB,GADZ,QACY,CAAA,CAAA,OAAA,EAAhC,iBAAgC,CAAd,YAAc,EAAA,MAAA,EAAQ,KAAR,EAAe,SAAf,CAAA,CAAA,EAAyB,kBAAA,CAAA,GAAA,CAAA,OAAzB"}

package/dist/PrefetchQuery.d.cts

@@ -1,2 +1,2 @@
-import { t as PrefetchQuery } from "./PrefetchQuery-DFwiRhmK.cjs";
+import { t as PrefetchQuery } from "./PrefetchQuery-C3h9DidM.cjs";
 export { PrefetchQuery };

package/dist/{QueriesHydration-BrMSJHsz.mjs → QueriesHydration-27lFZeB8.mjs}

@@ -36,7 +36,8 @@ const _excluded = [
 	"queries",
 	"children",
 	"queryClient",
-	"skipSsrOnError"
+	"skipSsrOnError",
+	"timeout"
 ];
 /**
 * A server component that fetches multiple queries on the server and hydrates them to the client.
@@ -107,10 +108,14 @@ function QueriesHydration(_x) {
 }
 function _QueriesHydration() {
 	_QueriesHydration = _asyncToGenerator(function* (_ref) {
-		let { queries, children, queryClient = new QueryClient(), skipSsrOnError = true } = _ref, props = _objectWithoutProperties(_ref, _excluded);
+		let { queries, children, queryClient = new QueryClient(), skipSsrOnError = true, timeout } = _ref, props = _objectWithoutProperties(_ref, _excluded);
+		const timeoutController = timeout != null && timeout >= 0 ? createTimeoutController(timeout, `QueriesHydration: timeout after ${timeout} ms)`) : void 0;
 		try {
-			yield Promise.all(queries.map((query) => "getNextPageParam" in query ? queryClient.fetchInfiniteQuery(query) : queryClient.fetchQuery(query)));
+			const queriesPromise = Promise.all(queries.map((query) => "getNextPageParam" in query ? queryClient.fetchInfiniteQuery(query) : queryClient.fetchQuery(query)));
+			yield timeoutController != null ? Promise.race([queriesPromise, timeoutController.promise]) : queriesPromise;
+			timeoutController === null || timeoutController === void 0 || timeoutController.clear();
 		} catch (_unused) {
+			timeoutController === null || timeoutController === void 0 || timeoutController.clear();
 			if (skipSsrOnError) return /* @__PURE__ */ jsx(ClientOnly, {
 				fallback: skipSsrOnError === true ? void 0 : skipSsrOnError.fallback,
 				children
@@ -123,7 +128,16 @@ function _QueriesHydration() {
 	});
 	return _QueriesHydration.apply(this, arguments);
 }
+const createTimeoutController = (ms, errorMessage) => {
+	let timerId;
+	return {
+		promise: new Promise((_, reject) => {
+			timerId = setTimeout(() => reject(new Error(errorMessage)), ms);
+		}),
+		clear: () => timerId != null && clearTimeout(timerId)
+	};
+};
 
 //#endregion
 export { QueriesHydration as t };
-//# sourceMappingURL=QueriesHydration-BrMSJHsz.mjs.map
+//# sourceMappingURL=QueriesHydration-27lFZeB8.mjs.map

package/dist/QueriesHydration-27lFZeB8.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueriesHydration-27lFZeB8.mjs","names":["timerId: ReturnType<typeof setTimeout> | undefined"],"sources":["../src/QueriesHydration.tsx"],"sourcesContent":["import {\n  Hydrate,\n  type HydrateProps,\n  type OmitKeyof,\n  QueryClient,\n  type QueryOptions,\n  type UseInfiniteQueryOptions,\n  type WithRequired,\n  dehydrate,\n} from '@tanstack/react-query'\nimport type { ReactNode } from 'react'\nimport { ClientOnly } from './components/ClientOnly'\n\n/**\n * A server component that fetches multiple queries on the server and hydrates them to the client.\n *\n * @experimental This component is experimental and may be changed or removed in the future.\n *\n * @description\n * QueriesHydration is designed for React Server Components (RSC).\n * It pre-fetches multiple queries on the server side and automatically hydrates\n * the data to the client, enabling seamless data synchronization between server and client.\n *\n * When errors occur during server-side fetching, the component gracefully falls back\n * to client-side rendering, ensuring your application remains resilient.\n *\n * @example\n * ```tsx\n * // app/page.tsx (Server Component)\n * import { Suspense } from 'react'\n * import { QueriesHydration } from '@suspensive/react-query'\n * import { queryOptions } from '@tanstack/react-query'\n *\n * const userQueryOptions = (userId: string) => queryOptions({\n *   queryKey: ['user', userId],\n *   queryFn: () => fetchUser(userId)\n * })\n *\n * const postsQueryOptions = () => queryOptions({\n *   queryKey: ['posts'],\n *   queryFn: () => fetchPosts()\n * })\n *\n * export default function Page({ userId }: { userId: string }) {\n *   return (\n *     <>\n *       <Suspense fallback={<div>Loading user...</div>}>\n *         <QueriesHydration queries={[userQueryOptions(userId)]}>\n *           <UserProfile />\n *         </QueriesHydration>\n *       </Suspense>\n *\n *       <Suspense fallback={<div>Loading posts...</div>}>\n *         <QueriesHydration queries={[postsQueryOptions()]}>\n *           <PostsList />\n *         </QueriesHydration>\n *       </Suspense>\n *     </>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * // With custom error fallback\n * <Suspense fallback={<div>Loading user...</div>}>\n *   <QueriesHydration\n *     queries={[userQueryOptions(userId)]}\n *     skipSsrOnError={{ fallback: <div>Fetching on client...</div> }}\n *   >\n *     <UserProfile />\n *   </QueriesHydration>\n * </Suspense>\n * ```\n *\n * @see {@link https://suspensive.org/docs/react-query/QueriesHydration Documentation}\n */\nexport async function QueriesHydration({\n  queries,\n  children,\n  queryClient = new QueryClient(),\n  skipSsrOnError = true,\n  timeout,\n  ...props\n}: {\n  /**\n   * The QueryClient instance to use for fetching queries.\n   */\n  queryClient?: QueryClient\n  /**\n   * An array of query options or infinite query options to be fetched on the server. Each query must include a `queryKey`.\n   * You can mix regular queries and infinite queries in the same array.\n   */\n  queries: (\n    | WithRequired<QueryOptions<any, any, any, any>, 'queryKey'>\n    | WithRequired<UseInfiniteQueryOptions<any, any, any, any, any>, 'queryKey'>\n  )[]\n  /**\n   * Controls error handling behavior:\n   * - `true` (default): Skips SSR and falls back to client-side rendering when server fetch fails\n   * - `false`: Proceeds with SSR without hydration (retry fetching on client component server rendering)\n   * - `{ fallback: ReactNode }`: Skips SSR with custom fallback UI during client-side rendering\n   */\n  skipSsrOnError?:\n    | boolean\n    | {\n        fallback: ReactNode\n      }\n  /**\n   * The timeout in milliseconds for the query.\n   * If the query takes longer than the timeout, it will be considered as an error.\n   * When not set, no timeout is applied.\n   */\n  timeout?: number\n} & OmitKeyof<HydrateProps, 'state'>) {\n  const timeoutController =\n    timeout != null && timeout >= 0\n      ? createTimeoutController(timeout, `QueriesHydration: timeout after ${timeout} ms)`)\n      : undefined\n  try {\n    const queriesPromise = Promise.all(\n      queries.map((query) =>\n        'getNextPageParam' in query ? queryClient.fetchInfiniteQuery(query) : queryClient.fetchQuery(query)\n      )\n    )\n    await (timeoutController != null ? Promise.race([queriesPromise, timeoutController.promise]) : queriesPromise)\n    timeoutController?.clear()\n  } catch {\n    timeoutController?.clear()\n    if (skipSsrOnError) {\n      return (\n        <ClientOnly fallback={skipSsrOnError === true ? undefined : skipSsrOnError.fallback}>{children}</ClientOnly>\n      )\n    }\n  }\n  return (\n    <Hydrate {...props} state={dehydrate(queryClient)}>\n      {children}\n    </Hydrate>\n  )\n}\n\nconst createTimeoutController = (ms: number, errorMessage: string) => {\n  let timerId: ReturnType<typeof setTimeout> | undefined\n  return {\n    promise: new Promise<never>((_, reject) => {\n      timerId = setTimeout(() => reject(new Error(errorMessage)), ms)\n    }),\n    clear: () => timerId != null && clearTimeout(timerId),\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8EE;CACA;CACA;CACA;CACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AALF,SAAsB,iBAAiB;;;;wDAqCD;MArCC,EACrC,SACA,UACA,cAAc,IAAI,aAAa,EAC/B,iBAAiB,MACjB,kBACG;EAgCH,MAAM,oBACJ,WAAW,QAAQ,WAAW,IAC1B,wBAAwB,SAAS,mCAAmC,QAAQ,MAAM,GAClF;AACN,MAAI;GACF,MAAM,iBAAiB,QAAQ,IAC7B,QAAQ,KAAK,UACX,sBAAsB,QAAQ,YAAY,mBAAmB,MAAM,GAAG,YAAY,WAAW,MAAM,CACpG,CACF;AACD,SAAO,qBAAqB,OAAO,QAAQ,KAAK,CAAC,gBAAgB,kBAAkB,QAAQ,CAAC,GAAG;AAC/F,mFAAmB,OAAO;oBACpB;AACN,mFAAmB,OAAO;AAC1B,OAAI,eACF,QACE,oBAAC;IAAW,UAAU,mBAAmB,OAAO,SAAY,eAAe;IAAW;KAAsB;;AAIlH,SACE,oBAAC,2CAAY;GAAO,OAAO,UAAU,YAAY;GAC9C;KACO;;;;AAId,MAAM,2BAA2B,IAAY,iBAAyB;CACpE,IAAIA;AACJ,QAAO;EACL,SAAS,IAAI,SAAgB,GAAG,WAAW;AACzC,aAAU,iBAAiB,OAAO,IAAI,MAAM,aAAa,CAAC,EAAE,GAAG;IAC/D;EACF,aAAa,WAAW,QAAQ,aAAa,QAAQ;EACtD"}

package/dist/{QueriesHydration-BARmyHJu.cjs → QueriesHydration-BYKU-Mte.cjs}

@@ -36,7 +36,8 @@ const _excluded = [
 	"queries",
 	"children",
 	"queryClient",
-	"skipSsrOnError"
+	"skipSsrOnError",
+	"timeout"
 ];
 /**
 * A server component that fetches multiple queries on the server and hydrates them to the client.
@@ -107,10 +108,14 @@ function QueriesHydration(_x) {
 }
 function _QueriesHydration() {
 	_QueriesHydration = _asyncToGenerator(function* (_ref) {
-		let { queries, children, queryClient = new __tanstack_react_query.QueryClient(), skipSsrOnError = true } = _ref, props = require_objectWithoutProperties._objectWithoutProperties(_ref, _excluded);
+		let { queries, children, queryClient = new __tanstack_react_query.QueryClient(), skipSsrOnError = true, timeout } = _ref, props = require_objectWithoutProperties._objectWithoutProperties(_ref, _excluded);
+		const timeoutController = timeout != null && timeout >= 0 ? createTimeoutController(timeout, `QueriesHydration: timeout after ${timeout} ms)`) : void 0;
 		try {
-			yield Promise.all(queries.map((query) => "getNextPageParam" in query ? queryClient.fetchInfiniteQuery(query) : queryClient.fetchQuery(query)));
+			const queriesPromise = Promise.all(queries.map((query) => "getNextPageParam" in query ? queryClient.fetchInfiniteQuery(query) : queryClient.fetchQuery(query)));
+			yield timeoutController != null ? Promise.race([queriesPromise, timeoutController.promise]) : queriesPromise;
+			timeoutController === null || timeoutController === void 0 || timeoutController.clear();
 		} catch (_unused) {
+			timeoutController === null || timeoutController === void 0 || timeoutController.clear();
 			if (skipSsrOnError) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_ClientOnly.ClientOnly, {
 				fallback: skipSsrOnError === true ? void 0 : skipSsrOnError.fallback,
 				children
@@ -123,6 +128,15 @@ function _QueriesHydration() {
 	});
 	return _QueriesHydration.apply(this, arguments);
 }
+const createTimeoutController = (ms, errorMessage) => {
+	let timerId;
+	return {
+		promise: new Promise((_, reject) => {
+			timerId = setTimeout(() => reject(new Error(errorMessage)), ms);
+		}),
+		clear: () => timerId != null && clearTimeout(timerId)
+	};
+};
 
 //#endregion
 Object.defineProperty(exports, 'QueriesHydration', {
@@ -131,4 +145,4 @@ Object.defineProperty(exports, 'QueriesHydration', {
     return QueriesHydration;
   }
 });
-//# sourceMappingURL=QueriesHydration-BARmyHJu.cjs.map
+//# sourceMappingURL=QueriesHydration-BYKU-Mte.cjs.map

package/dist/QueriesHydration-BYKU-Mte.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueriesHydration-BYKU-Mte.cjs","names":["QueryClient","ClientOnly","Hydrate","timerId: ReturnType<typeof setTimeout> | undefined"],"sources":["../src/QueriesHydration.tsx"],"sourcesContent":["import {\n  Hydrate,\n  type HydrateProps,\n  type OmitKeyof,\n  QueryClient,\n  type QueryOptions,\n  type UseInfiniteQueryOptions,\n  type WithRequired,\n  dehydrate,\n} from '@tanstack/react-query'\nimport type { ReactNode } from 'react'\nimport { ClientOnly } from './components/ClientOnly'\n\n/**\n * A server component that fetches multiple queries on the server and hydrates them to the client.\n *\n * @experimental This component is experimental and may be changed or removed in the future.\n *\n * @description\n * QueriesHydration is designed for React Server Components (RSC).\n * It pre-fetches multiple queries on the server side and automatically hydrates\n * the data to the client, enabling seamless data synchronization between server and client.\n *\n * When errors occur during server-side fetching, the component gracefully falls back\n * to client-side rendering, ensuring your application remains resilient.\n *\n * @example\n * ```tsx\n * // app/page.tsx (Server Component)\n * import { Suspense } from 'react'\n * import { QueriesHydration } from '@suspensive/react-query'\n * import { queryOptions } from '@tanstack/react-query'\n *\n * const userQueryOptions = (userId: string) => queryOptions({\n *   queryKey: ['user', userId],\n *   queryFn: () => fetchUser(userId)\n * })\n *\n * const postsQueryOptions = () => queryOptions({\n *   queryKey: ['posts'],\n *   queryFn: () => fetchPosts()\n * })\n *\n * export default function Page({ userId }: { userId: string }) {\n *   return (\n *     <>\n *       <Suspense fallback={<div>Loading user...</div>}>\n *         <QueriesHydration queries={[userQueryOptions(userId)]}>\n *           <UserProfile />\n *         </QueriesHydration>\n *       </Suspense>\n *\n *       <Suspense fallback={<div>Loading posts...</div>}>\n *         <QueriesHydration queries={[postsQueryOptions()]}>\n *           <PostsList />\n *         </QueriesHydration>\n *       </Suspense>\n *     </>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * // With custom error fallback\n * <Suspense fallback={<div>Loading user...</div>}>\n *   <QueriesHydration\n *     queries={[userQueryOptions(userId)]}\n *     skipSsrOnError={{ fallback: <div>Fetching on client...</div> }}\n *   >\n *     <UserProfile />\n *   </QueriesHydration>\n * </Suspense>\n * ```\n *\n * @see {@link https://suspensive.org/docs/react-query/QueriesHydration Documentation}\n */\nexport async function QueriesHydration({\n  queries,\n  children,\n  queryClient = new QueryClient(),\n  skipSsrOnError = true,\n  timeout,\n  ...props\n}: {\n  /**\n   * The QueryClient instance to use for fetching queries.\n   */\n  queryClient?: QueryClient\n  /**\n   * An array of query options or infinite query options to be fetched on the server. Each query must include a `queryKey`.\n   * You can mix regular queries and infinite queries in the same array.\n   */\n  queries: (\n    | WithRequired<QueryOptions<any, any, any, any>, 'queryKey'>\n    | WithRequired<UseInfiniteQueryOptions<any, any, any, any, any>, 'queryKey'>\n  )[]\n  /**\n   * Controls error handling behavior:\n   * - `true` (default): Skips SSR and falls back to client-side rendering when server fetch fails\n   * - `false`: Proceeds with SSR without hydration (retry fetching on client component server rendering)\n   * - `{ fallback: ReactNode }`: Skips SSR with custom fallback UI during client-side rendering\n   */\n  skipSsrOnError?:\n    | boolean\n    | {\n        fallback: ReactNode\n      }\n  /**\n   * The timeout in milliseconds for the query.\n   * If the query takes longer than the timeout, it will be considered as an error.\n   * When not set, no timeout is applied.\n   */\n  timeout?: number\n} & OmitKeyof<HydrateProps, 'state'>) {\n  const timeoutController =\n    timeout != null && timeout >= 0\n      ? createTimeoutController(timeout, `QueriesHydration: timeout after ${timeout} ms)`)\n      : undefined\n  try {\n    const queriesPromise = Promise.all(\n      queries.map((query) =>\n        'getNextPageParam' in query ? queryClient.fetchInfiniteQuery(query) : queryClient.fetchQuery(query)\n      )\n    )\n    await (timeoutController != null ? Promise.race([queriesPromise, timeoutController.promise]) : queriesPromise)\n    timeoutController?.clear()\n  } catch {\n    timeoutController?.clear()\n    if (skipSsrOnError) {\n      return (\n        <ClientOnly fallback={skipSsrOnError === true ? undefined : skipSsrOnError.fallback}>{children}</ClientOnly>\n      )\n    }\n  }\n  return (\n    <Hydrate {...props} state={dehydrate(queryClient)}>\n      {children}\n    </Hydrate>\n  )\n}\n\nconst createTimeoutController = (ms: number, errorMessage: string) => {\n  let timerId: ReturnType<typeof setTimeout> | undefined\n  return {\n    promise: new Promise<never>((_, reject) => {\n      timerId = setTimeout(() => reject(new Error(errorMessage)), ms)\n    }),\n    clear: () => timerId != null && clearTimeout(timerId),\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8EE;CACA;CACA;CACA;CACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AALF,SAAsB,iBAAiB;;;;wDAqCD;MArCC,EACrC,SACA,UACA,cAAc,IAAIA,oCAAa,EAC/B,iBAAiB,MACjB,kBACG;EAgCH,MAAM,oBACJ,WAAW,QAAQ,WAAW,IAC1B,wBAAwB,SAAS,mCAAmC,QAAQ,MAAM,GAClF;AACN,MAAI;GACF,MAAM,iBAAiB,QAAQ,IAC7B,QAAQ,KAAK,UACX,sBAAsB,QAAQ,YAAY,mBAAmB,MAAM,GAAG,YAAY,WAAW,MAAM,CACpG,CACF;AACD,SAAO,qBAAqB,OAAO,QAAQ,KAAK,CAAC,gBAAgB,kBAAkB,QAAQ,CAAC,GAAG;AAC/F,mFAAmB,OAAO;oBACpB;AACN,mFAAmB,OAAO;AAC1B,OAAI,eACF,QACE,2CAACC;IAAW,UAAU,mBAAmB,OAAO,SAAY,eAAe;IAAW;KAAsB;;AAIlH,SACE,2CAACC,8GAAY;GAAO,6CAAiB,YAAY;GAC9C;KACO;;;;AAId,MAAM,2BAA2B,IAAY,iBAAyB;CACpE,IAAIC;AACJ,QAAO;EACL,SAAS,IAAI,SAAgB,GAAG,WAAW;AACzC,aAAU,iBAAiB,OAAO,IAAI,MAAM,aAAa,CAAC,EAAE,GAAG;IAC/D;EACF,aAAa,WAAW,QAAQ,aAAa,QAAQ;EACtD"}

package/dist/{QueriesHydration-M2zoVGgJ.d.mts → QueriesHydration-BeMkJU3l.d.mts}

@@ -73,6 +73,7 @@ declare function QueriesHydration({
   children,
   queryClient,
   skipSsrOnError,
+  timeout,
   ...props
 }: {
   /**
@@ -93,7 +94,13 @@ declare function QueriesHydration({
   skipSsrOnError?: boolean | {
     fallback: ReactNode;
   };
+  /**
+   * The timeout in milliseconds for the query.
+   * If the query takes longer than the timeout, it will be considered as an error.
+   * When not set, no timeout is applied.
+   */
+  timeout?: number;
 } & OmitKeyof<HydrateProps, 'state'>): Promise<react_jsx_runtime3.JSX.Element>;
 //#endregion
 export { QueriesHydration as t };
-//# sourceMappingURL=QueriesHydration-M2zoVGgJ.d.mts.map
+//# sourceMappingURL=QueriesHydration-BeMkJU3l.d.mts.map

package/dist/QueriesHydration-BeMkJU3l.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueriesHydration-BeMkJU3l.d.mts","names":[],"sources":["../src/QueriesHydration.tsx"],"sourcesContent":[],"mappings":";;;;;;;;;AA6EA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAsB,gBAAA;;;;;;;;;;;gBAWN;;;;;YAMV,aAAa,gDACb,aAAa;;;;;;;;cAWD;;;;;;;;IAQd,UAAU,yBAAsB,QAAA,kBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/{QueriesHydration-99AzKj29.d.cts → QueriesHydration-DQiuolCU.d.cts}

@@ -1,4 +1,4 @@
-import * as react_jsx_runtime0 from "react/jsx-runtime";
+import * as react_jsx_runtime2 from "react/jsx-runtime";
 import { HydrateProps, OmitKeyof, QueryClient, QueryOptions, UseInfiniteQueryOptions, WithRequired } from "@tanstack/react-query";
 import { ReactNode } from "react";
 
@@ -73,6 +73,7 @@ declare function QueriesHydration({
   children,
   queryClient,
   skipSsrOnError,
+  timeout,
   ...props
 }: {
   /**
@@ -93,7 +94,13 @@ declare function QueriesHydration({
   skipSsrOnError?: boolean | {
     fallback: ReactNode;
   };
-} & OmitKeyof<HydrateProps, 'state'>): Promise<react_jsx_runtime0.JSX.Element>;
+  /**
+   * The timeout in milliseconds for the query.
+   * If the query takes longer than the timeout, it will be considered as an error.
+   * When not set, no timeout is applied.
+   */
+  timeout?: number;
+} & OmitKeyof<HydrateProps, 'state'>): Promise<react_jsx_runtime2.JSX.Element>;
 //#endregion
 export { QueriesHydration as t };
-//# sourceMappingURL=QueriesHydration-99AzKj29.d.cts.map
+//# sourceMappingURL=QueriesHydration-DQiuolCU.d.cts.map

package/dist/QueriesHydration-DQiuolCU.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueriesHydration-DQiuolCU.d.cts","names":[],"sources":["../src/QueriesHydration.tsx"],"sourcesContent":[],"mappings":";;;;;;;;;AA6EA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAsB,gBAAA;;;;;;;;;;;gBAWN;;;;;YAMV,aAAa,gDACb,aAAa;;;;;;;;cAWD;;;;;;;;IAQd,UAAU,yBAAsB,QAAA,kBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/QueriesHydration.cjs

@@ -1,3 +1,3 @@
-const require_QueriesHydration = require('./QueriesHydration-BARmyHJu.cjs');
+const require_QueriesHydration = require('./QueriesHydration-BYKU-Mte.cjs');
 
 exports.QueriesHydration = require_QueriesHydration.QueriesHydration;

package/dist/QueriesHydration.d.cts

@@ -1,2 +1,2 @@
-import { t as QueriesHydration } from "./QueriesHydration-99AzKj29.cjs";
+import { t as QueriesHydration } from "./QueriesHydration-DQiuolCU.cjs";
 export { QueriesHydration };

package/dist/QueriesHydration.d.mts

@@ -1,2 +1,2 @@
-import { t as QueriesHydration } from "./QueriesHydration-M2zoVGgJ.mjs";
+import { t as QueriesHydration } from "./QueriesHydration-BeMkJU3l.mjs";
 export { QueriesHydration };

package/dist/QueriesHydration.mjs

@@ -1,3 +1,3 @@
-import { t as QueriesHydration } from "./QueriesHydration-BrMSJHsz.mjs";
+import { t as QueriesHydration } from "./QueriesHydration-27lFZeB8.mjs";
 
 export { QueriesHydration };

package/dist/{QueryClientConsumer-BGHJsJCv.d.cts → QueryClientConsumer-D3h25GmM.d.cts}

@@ -1,4 +1,4 @@
-import * as react_jsx_runtime1 from "react/jsx-runtime";
+import * as react_jsx_runtime3 from "react/jsx-runtime";
 import { QueryClient } from "@tanstack/react-query";
 import { Context, ReactNode } from "react";
 
@@ -12,7 +12,7 @@ declare function QueryClientConsumer({
 }: {
   children: (queryClient: QueryClient) => ReactNode;
   context?: Context<QueryClient | undefined>;
-}): react_jsx_runtime1.JSX.Element;
+}): react_jsx_runtime3.JSX.Element;
 //#endregion
 export { QueryClientConsumer as t };
-//# sourceMappingURL=QueryClientConsumer-BGHJsJCv.d.cts.map
+//# sourceMappingURL=QueryClientConsumer-D3h25GmM.d.cts.map

package/dist/{QueryClientConsumer-BGHJsJCv.d.cts.map → QueryClientConsumer-D3h25GmM.d.cts.map}

@@ -1 +1 @@
-{"version":3,"file":"QueryClientConsumer-BGHJsJCv.d.cts","names":[],"sources":["../src/QueryClientConsumer.tsx"],"sourcesContent":[],"mappings":";;;;;;;;AAQgB,iBAAA,mBAAA,CAAmB;EAAA,QAAA;EAAA;CAAA,EAAA;EACjC,QAAA,EAAA,CAAA,WAAA,EAGwB,WAHxB,EAAA,GAGwC,SAHxC;EACA,OAAA,CAAA,EAGU,OAHV,CAGkB,WAHlB,GAAA,SAAA,CAAA;CAEwB,CAAA,EAEzB,kBAAA,CAAA,GAAA,CAAA,OAFyB"}
+{"version":3,"file":"QueryClientConsumer-D3h25GmM.d.cts","names":[],"sources":["../src/QueryClientConsumer.tsx"],"sourcesContent":[],"mappings":";;;;;;;;AAQgB,iBAAA,mBAAA,CAAmB;EAAA,QAAA;EAAA;CAAA,EAAA;EACjC,QAAA,EAAA,CAAA,WAAA,EAGwB,WAHxB,EAAA,GAGwC,SAHxC;EACA,OAAA,CAAA,EAGU,OAHV,CAGkB,WAHlB,GAAA,SAAA,CAAA;CAEwB,CAAA,EAEzB,kBAAA,CAAA,GAAA,CAAA,OAFyB"}

package/dist/QueryClientConsumer.d.cts

@@ -1,2 +1,2 @@
-import { t as QueryClientConsumer } from "./QueryClientConsumer-BGHJsJCv.cjs";
+import { t as QueryClientConsumer } from "./QueryClientConsumer-D3h25GmM.cjs";
 export { QueryClientConsumer };

package/dist/{SuspenseInfiniteQuery-BwSKmJgm.d.cts → SuspenseInfiniteQuery-CBf92CTq.d.cts}

@@ -1,5 +1,5 @@
 import { t as UseSuspenseInfiniteQueryOptions } from "./useSuspenseInfiniteQuery-xXu-A7cX.cjs";
-import * as react_jsx_runtime3 from "react/jsx-runtime";
+import * as react_jsx_runtime4 from "react/jsx-runtime";
 import { QueryKey, UseSuspenseInfiniteQueryResult } from "@tanstack/react-query";
 import { ReactNode } from "react";
 
@@ -26,7 +26,7 @@ declare const SuspenseInfiniteQuery: <TQueryFnData = unknown, TError = unknown,
   ...options
 }: UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
   children: (query: UseSuspenseInfiniteQueryResult<TData, TError>) => ReactNode;
-}) => react_jsx_runtime3.JSX.Element;
+}) => react_jsx_runtime4.JSX.Element;
 //#endregion
 export { SuspenseInfiniteQuery as t };
-//# sourceMappingURL=SuspenseInfiniteQuery-BwSKmJgm.d.cts.map
+//# sourceMappingURL=SuspenseInfiniteQuery-CBf92CTq.d.cts.map

package/dist/{SuspenseInfiniteQuery-BwSKmJgm.d.cts.map → SuspenseInfiniteQuery-CBf92CTq.d.cts.map}

@@ -1 +1 @@
-{"version":3,"file":"SuspenseInfiniteQuery-BwSKmJgm.d.cts","names":[],"sources":["../src/SuspenseInfiniteQuery.tsx"],"sourcesContent":[],"mappings":";;;;;;;;;;AAqBA;;;;;;;;;;;;;AASsE,cATzD,qBASyD,EAAA,CAAA,eAAA,OAAA,EAAA,SAAA,OAAA,EAAA,QAN5D,YAM4D,EAAA,kBALlD,QAKkD,GALvC,QAKuC,CAAA,CAAA;EAAA,QAAA;EAAA,GAAA;CAAA,EADnE,+BACmE,CADnC,YACmC,EADrB,MACqB,EADb,KACa,EADN,SACM,CAAA,GAAA;EACrE,QAAA,EAAA,CAAA,KAAA,EADmB,8BACnB,CADkD,KAClD,EADyD,MACzD,CAAA,EAAA,GADqE,SACrE;CAAuD,EAAA,GAAvD,kBAAA,CAAA,GAAA,CAAA,OAAuD"}
+{"version":3,"file":"SuspenseInfiniteQuery-CBf92CTq.d.cts","names":[],"sources":["../src/SuspenseInfiniteQuery.tsx"],"sourcesContent":[],"mappings":";;;;;;;;;;AAqBA;;;;;;;;;;;;;AASsE,cATzD,qBASyD,EAAA,CAAA,eAAA,OAAA,EAAA,SAAA,OAAA,EAAA,QAN5D,YAM4D,EAAA,kBALlD,QAKkD,GALvC,QAKuC,CAAA,CAAA;EAAA,QAAA;EAAA,GAAA;CAAA,EADnE,+BACmE,CADnC,YACmC,EADrB,MACqB,EADb,KACa,EADN,SACM,CAAA,GAAA;EACrE,QAAA,EAAA,CAAA,KAAA,EADmB,8BACnB,CADkD,KAClD,EADyD,MACzD,CAAA,EAAA,GADqE,SACrE;CAAuD,EAAA,GAAvD,kBAAA,CAAA,GAAA,CAAA,OAAuD"}

package/dist/SuspenseInfiniteQuery.d.cts

@@ -1,2 +1,2 @@
-import { t as SuspenseInfiniteQuery } from "./SuspenseInfiniteQuery-BwSKmJgm.cjs";
+import { t as SuspenseInfiniteQuery } from "./SuspenseInfiniteQuery-CBf92CTq.cjs";
 export { SuspenseInfiniteQuery };

package/dist/{SuspenseQueries-B-UR1dnn.d.cts → SuspenseQueries-wO-fCk30.d.cts}

@@ -1,4 +1,4 @@
-import * as react_jsx_runtime6 from "react/jsx-runtime";
+import * as react_jsx_runtime5 from "react/jsx-runtime";
 import { SuspenseQueriesOptions, SuspenseQueriesResults } from "@tanstack/react-query";
 import { ReactNode } from "react";
 
@@ -25,7 +25,7 @@ declare function SuspenseQueries<T extends any[]>({
 }: {
   queries: readonly [...SuspenseQueriesOptions<T>];
   children: (queries: SuspenseQueriesResults<T>) => ReactNode;
-}): react_jsx_runtime6.JSX.Element;
+}): react_jsx_runtime5.JSX.Element;
 //#endregion
 export { SuspenseQueries as t };
-//# sourceMappingURL=SuspenseQueries-B-UR1dnn.d.cts.map
+//# sourceMappingURL=SuspenseQueries-wO-fCk30.d.cts.map

package/dist/{SuspenseQueries-B-UR1dnn.d.cts.map → SuspenseQueries-wO-fCk30.d.cts.map}

@@ -1 +1 @@
-{"version":3,"file":"SuspenseQueries-B-UR1dnn.d.cts","names":[],"sources":["../src/SuspenseQueries.tsx"],"sourcesContent":[],"mappings":";;;;;;;;;AAoBA;;;;;;;;;;;;iBAAgB;;;;wBAIQ,uBAAuB;sBACzB,uBAAuB,OAAO;IACnD,kBAAA,CAAA,GAAA,CAAA"}
+{"version":3,"file":"SuspenseQueries-wO-fCk30.d.cts","names":[],"sources":["../src/SuspenseQueries.tsx"],"sourcesContent":[],"mappings":";;;;;;;;;AAoBA;;;;;;;;;;;;iBAAgB;;;;wBAIQ,uBAAuB;sBACzB,uBAAuB,OAAO;IACnD,kBAAA,CAAA,GAAA,CAAA"}

package/dist/SuspenseQueries.d.cts

@@ -1,2 +1,2 @@
-import { t as SuspenseQueries } from "./SuspenseQueries-B-UR1dnn.cjs";
+import { t as SuspenseQueries } from "./SuspenseQueries-wO-fCk30.cjs";
 export { SuspenseQueries };

package/dist/{SuspenseQuery-BT6EsguP.d.cts → SuspenseQuery-DzwOaqvu.d.cts}

@@ -1,4 +1,4 @@
-import * as react_jsx_runtime2 from "react/jsx-runtime";
+import * as react_jsx_runtime6 from "react/jsx-runtime";
 import { QueryKey, UseSuspenseQueryOptions, UseSuspenseQueryResult } from "@tanstack/react-query";
 import { ReactNode } from "react";
 
@@ -25,7 +25,7 @@ declare const SuspenseQuery: <TQueryFnData = unknown, TError = unknown, TData =
   ...options
 }: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
   children: (queryResult: UseSuspenseQueryResult<TData, TError>) => ReactNode;
-}) => react_jsx_runtime2.JSX.Element;
+}) => react_jsx_runtime6.JSX.Element;
 //#endregion
 export { SuspenseQuery as t };
-//# sourceMappingURL=SuspenseQuery-BT6EsguP.d.cts.map
+//# sourceMappingURL=SuspenseQuery-DzwOaqvu.d.cts.map

package/dist/{SuspenseQuery-BT6EsguP.d.cts.map → SuspenseQuery-DzwOaqvu.d.cts.map}

@@ -1 +1 @@
-{"version":3,"file":"SuspenseQuery-BT6EsguP.d.cts","names":[],"sources":["../src/SuspenseQuery.tsx"],"sourcesContent":[],"mappings":";;;;;;;;;AA0BA;;;;;;;;;;;;;AASoE,cATvD,aASuD,EAAA,CAAA,eAAA,OAAA,EAAA,SAAA,OAAA,EAAA,QAN1D,YAM0D,EAAA,kBALhD,QAKgD,GALrC,QAKqC,CAAA,CAAA;EAAA,QAAA;EAAA,GAAA;CAAA,EADjE,uBACiE,CADzC,YACyC,EAD3B,MAC2B,EADnB,KACmB,EADZ,SACY,CAAA,GAAA;EACnE,QAAA,EAAA,CAAA,WAAA,EADyB,sBACzB,CADgD,KAChD,EADuD,MACvD,CAAA,EAAA,GADmE,SACnE;CAA+C,EAAA,GAA/C,kBAAA,CAAA,GAAA,CAAA,OAA+C"}
+{"version":3,"file":"SuspenseQuery-DzwOaqvu.d.cts","names":[],"sources":["../src/SuspenseQuery.tsx"],"sourcesContent":[],"mappings":";;;;;;;;;AA0BA;;;;;;;;;;;;;AASoE,cATvD,aASuD,EAAA,CAAA,eAAA,OAAA,EAAA,SAAA,OAAA,EAAA,QAN1D,YAM0D,EAAA,kBALhD,QAKgD,GALrC,QAKqC,CAAA,CAAA;EAAA,QAAA;EAAA,GAAA;CAAA,EADjE,uBACiE,CADzC,YACyC,EAD3B,MAC2B,EADnB,KACmB,EADZ,SACY,CAAA,GAAA;EACnE,QAAA,EAAA,CAAA,WAAA,EADyB,sBACzB,CADgD,KAChD,EADuD,MACvD,CAAA,EAAA,GADmE,SACnE;CAA+C,EAAA,GAA/C,kBAAA,CAAA,GAAA,CAAA,OAA+C"}

package/dist/SuspenseQuery.d.cts

@@ -1,2 +1,2 @@
-import { t as SuspenseQuery } from "./SuspenseQuery-BT6EsguP.cjs";
+import { t as SuspenseQuery } from "./SuspenseQuery-DzwOaqvu.cjs";
 export { SuspenseQuery };

package/dist/index.cjs

@@ -4,7 +4,7 @@ const require_usePrefetchInfiniteQuery = require('./usePrefetchInfiniteQuery-BmZ
 const require_PrefetchInfiniteQuery = require('./PrefetchInfiniteQuery-cCSXqKVR.cjs');
 const require_usePrefetchQuery = require('./usePrefetchQuery-woiivAJc.cjs');
 const require_PrefetchQuery = require('./PrefetchQuery-0pdYNtpS.cjs');
-const require_QueriesHydration = require('./QueriesHydration-BARmyHJu.cjs');
+const require_QueriesHydration = require('./QueriesHydration-BYKU-Mte.cjs');
 const require_QueryClientConsumer = require('./QueryClientConsumer-mF0OUwkq.cjs');
 const require_SuspenseInfiniteQuery = require('./SuspenseInfiniteQuery-Dq97Dear.cjs');
 const require_SuspenseQueries = require('./SuspenseQueries-Brk6gtMw.cjs');

package/dist/index.d.cts

@@ -1,13 +1,13 @@
-import { t as IsFetching } from "./IsFetching-CThOxeZB.cjs";
+import { t as IsFetching } from "./IsFetching-CmAXgxBe.cjs";
 import { t as Mutation } from "./Mutation-Dt5kUsd8.cjs";
-import { t as PrefetchInfiniteQuery } from "./PrefetchInfiniteQuery-C4FsMPPo.cjs";
-import { t as PrefetchQuery } from "./PrefetchQuery-DFwiRhmK.cjs";
-import { t as QueriesHydration } from "./QueriesHydration-99AzKj29.cjs";
-import { t as QueryClientConsumer } from "./QueryClientConsumer-BGHJsJCv.cjs";
+import { t as PrefetchInfiniteQuery } from "./PrefetchInfiniteQuery-BewcG5rR.cjs";
+import { t as PrefetchQuery } from "./PrefetchQuery-C3h9DidM.cjs";
+import { t as QueriesHydration } from "./QueriesHydration-DQiuolCU.cjs";
+import { t as QueryClientConsumer } from "./QueryClientConsumer-D3h25GmM.cjs";
 import { n as UseSuspenseInfiniteQueryResult, r as useSuspenseInfiniteQuery, t as UseSuspenseInfiniteQueryOptions } from "./useSuspenseInfiniteQuery-xXu-A7cX.cjs";
-import { t as SuspenseInfiniteQuery } from "./SuspenseInfiniteQuery-BwSKmJgm.cjs";
-import { t as SuspenseQueries } from "./SuspenseQueries-B-UR1dnn.cjs";
-import { t as SuspenseQuery } from "./SuspenseQuery-BT6EsguP.cjs";
+import { t as SuspenseInfiniteQuery } from "./SuspenseInfiniteQuery-CBf92CTq.cjs";
+import { t as SuspenseQueries } from "./SuspenseQueries-wO-fCk30.cjs";
+import { t as SuspenseQuery } from "./SuspenseQuery-DzwOaqvu.cjs";
 import { t as createGetQueryClient } from "./createGetQueryClient-iXoXO7so.cjs";
 import { n as UnSelectedInfiniteOptions, r as infiniteQueryOptions, t as SelectedInfiniteOptions } from "./infiniteQueryOptions-Be7VYTUR.cjs";
 import { n as UnSelectedQueryOptions, r as queryOptions, t as SelectedQueryOptions } from "./queryOptions-DNGHeGX5.cjs";

package/dist/index.d.mts

@@ -2,7 +2,7 @@ import { t as IsFetching } from "./IsFetching-D3xmE2Kn.mjs";
 import { t as Mutation } from "./Mutation-CGpbCg54.mjs";
 import { t as PrefetchInfiniteQuery } from "./PrefetchInfiniteQuery-Dzjm5lf8.mjs";
 import { t as PrefetchQuery } from "./PrefetchQuery-DAqAWOeP.mjs";
-import { t as QueriesHydration } from "./QueriesHydration-M2zoVGgJ.mjs";
+import { t as QueriesHydration } from "./QueriesHydration-BeMkJU3l.mjs";
 import { t as QueryClientConsumer } from "./QueryClientConsumer-BW1kmzJX.mjs";
 import { n as UseSuspenseInfiniteQueryResult, r as useSuspenseInfiniteQuery, t as UseSuspenseInfiniteQueryOptions } from "./useSuspenseInfiniteQuery-Bh0nh8Kc.mjs";
 import { t as SuspenseInfiniteQuery } from "./SuspenseInfiniteQuery-B6hHnPDQ.mjs";

package/dist/index.mjs

@@ -4,7 +4,7 @@ import { t as usePrefetchInfiniteQuery } from "./usePrefetchInfiniteQuery-CQSN-P
 import { t as PrefetchInfiniteQuery } from "./PrefetchInfiniteQuery-RS3Qz-7B.mjs";
 import { t as usePrefetchQuery } from "./usePrefetchQuery-CtrJciA6.mjs";
 import { t as PrefetchQuery } from "./PrefetchQuery-uh4idoXK.mjs";
-import { t as QueriesHydration } from "./QueriesHydration-BrMSJHsz.mjs";
+import { t as QueriesHydration } from "./QueriesHydration-27lFZeB8.mjs";
 import { t as QueryClientConsumer } from "./QueryClientConsumer-e7PyaFF3.mjs";
 import { t as SuspenseInfiniteQuery } from "./SuspenseInfiniteQuery-DwW5I_M2.mjs";
 import { t as SuspenseQueries } from "./SuspenseQueries-C0mF_XD_.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suspensive/react-query-4",
-  "version": "3.18.0",
+  "version": "3.19.0",
   "description": "Suspensive interfaces for @tanstack/react-query@4",
   "keywords": [
     "suspensive",
@@ -43,8 +43,8 @@
     "@types/react": "^19.2.7",
     "react": "^19.2.3",
     "@suspensive/eslint-config": "0.0.1",
-    "@suspensive/tsconfig": "0.0.0-development",
-    "@suspensive/tsdown": "0.0.0"
+    "@suspensive/tsdown": "0.0.0",
+    "@suspensive/tsconfig": "0.0.0-development"
   },
   "peerDependencies": {
     "@tanstack/react-query": "*",

package/src/QueriesHydration.spec.tsx

@@ -1,4 +1,4 @@
-import { QueryClient, dehydrate, infiniteQueryOptions } from '@tanstack/react-query'
+import { QueryClient, QueryClientProvider, dehydrate, infiniteQueryOptions } from '@tanstack/react-query'
 import { render, screen } from '@testing-library/react'
 import type { ComponentProps, ReactNode } from 'react'
 import { describe, expect, it, vi } from 'vitest'
@@ -351,4 +351,41 @@ describe('<QueriesHydration/>', () => {
       pageParams: [undefined],
     })
   })
+
+  it('should timeout when query takes longer than the timeout', async () => {
+    const serverQueryClient = new QueryClient()
+    const timeoutMs = 100
+    const queryDelayMs = 200
+    const mockQueryFn = vi
+      .fn()
+      .mockImplementation(
+        () => new Promise((resolve) => setTimeout(() => resolve({ data: 'test-data' }), queryDelayMs))
+      )
+
+    const queries = [
+      {
+        queryKey: ['test-query'],
+        queryFn: mockQueryFn,
+      },
+    ]
+
+    const ClientChild = () => {
+      return <div>Client Child</div>
+    }
+
+    const result = await QueriesHydration({
+      queries,
+      queryClient: serverQueryClient,
+      timeout: timeoutMs,
+      children: <ClientChild />,
+    })
+
+    expect(mockQueryFn).toHaveBeenCalledTimes(1)
+    expect(screen.queryByText('Client Child')).not.toBeInTheDocument()
+
+    const clientQueryClient = new QueryClient()
+    render(<QueryClientProvider client={clientQueryClient}>{result}</QueryClientProvider>)
+    expect(screen.getByTestId('client-only')).toBeInTheDocument()
+    expect(screen.getByText('Client Child')).toBeInTheDocument()
+  })
 })

package/src/QueriesHydration.tsx

@@ -80,6 +80,7 @@ export async function QueriesHydration({
   children,
   queryClient = new QueryClient(),
   skipSsrOnError = true,
+  timeout,
   ...props
 }: {
   /**
@@ -105,14 +106,27 @@ export async function QueriesHydration({
     | {
         fallback: ReactNode
       }
+  /**
+   * The timeout in milliseconds for the query.
+   * If the query takes longer than the timeout, it will be considered as an error.
+   * When not set, no timeout is applied.
+   */
+  timeout?: number
 } & OmitKeyof<HydrateProps, 'state'>) {
+  const timeoutController =
+    timeout != null && timeout >= 0
+      ? createTimeoutController(timeout, `QueriesHydration: timeout after ${timeout} ms)`)
+      : undefined
   try {
-    await Promise.all(
+    const queriesPromise = Promise.all(
       queries.map((query) =>
         'getNextPageParam' in query ? queryClient.fetchInfiniteQuery(query) : queryClient.fetchQuery(query)
       )
     )
+    await (timeoutController != null ? Promise.race([queriesPromise, timeoutController.promise]) : queriesPromise)
+    timeoutController?.clear()
   } catch {
+    timeoutController?.clear()
     if (skipSsrOnError) {
       return (
         <ClientOnly fallback={skipSsrOnError === true ? undefined : skipSsrOnError.fallback}>{children}</ClientOnly>
@@ -125,3 +139,13 @@ export async function QueriesHydration({
     </Hydrate>
   )
 }
+
+const createTimeoutController = (ms: number, errorMessage: string) => {
+  let timerId: ReturnType<typeof setTimeout> | undefined
+  return {
+    promise: new Promise<never>((_, reject) => {
+      timerId = setTimeout(() => reject(new Error(errorMessage)), ms)
+    }),
+    clear: () => timerId != null && clearTimeout(timerId),
+  }
+}

package/dist/QueriesHydration-99AzKj29.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueriesHydration-99AzKj29.d.cts","names":[],"sources":["../src/QueriesHydration.tsx"],"sourcesContent":[],"mappings":";;;;;;;;;AA6EA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAsB,gBAAA;;;;;;;;;;gBAUN;;;;;YAMV,aAAa,gDACb,aAAa;;;;;;;;cAWD;;IAEd,UAAU,yBAAsB,QAAA,kBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/QueriesHydration-BARmyHJu.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueriesHydration-BARmyHJu.cjs","names":["QueryClient","ClientOnly","Hydrate"],"sources":["../src/QueriesHydration.tsx"],"sourcesContent":["import {\n  Hydrate,\n  type HydrateProps,\n  type OmitKeyof,\n  QueryClient,\n  type QueryOptions,\n  type UseInfiniteQueryOptions,\n  type WithRequired,\n  dehydrate,\n} from '@tanstack/react-query'\nimport type { ReactNode } from 'react'\nimport { ClientOnly } from './components/ClientOnly'\n\n/**\n * A server component that fetches multiple queries on the server and hydrates them to the client.\n *\n * @experimental This component is experimental and may be changed or removed in the future.\n *\n * @description\n * QueriesHydration is designed for React Server Components (RSC).\n * It pre-fetches multiple queries on the server side and automatically hydrates\n * the data to the client, enabling seamless data synchronization between server and client.\n *\n * When errors occur during server-side fetching, the component gracefully falls back\n * to client-side rendering, ensuring your application remains resilient.\n *\n * @example\n * ```tsx\n * // app/page.tsx (Server Component)\n * import { Suspense } from 'react'\n * import { QueriesHydration } from '@suspensive/react-query'\n * import { queryOptions } from '@tanstack/react-query'\n *\n * const userQueryOptions = (userId: string) => queryOptions({\n *   queryKey: ['user', userId],\n *   queryFn: () => fetchUser(userId)\n * })\n *\n * const postsQueryOptions = () => queryOptions({\n *   queryKey: ['posts'],\n *   queryFn: () => fetchPosts()\n * })\n *\n * export default function Page({ userId }: { userId: string }) {\n *   return (\n *     <>\n *       <Suspense fallback={<div>Loading user...</div>}>\n *         <QueriesHydration queries={[userQueryOptions(userId)]}>\n *           <UserProfile />\n *         </QueriesHydration>\n *       </Suspense>\n *\n *       <Suspense fallback={<div>Loading posts...</div>}>\n *         <QueriesHydration queries={[postsQueryOptions()]}>\n *           <PostsList />\n *         </QueriesHydration>\n *       </Suspense>\n *     </>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * // With custom error fallback\n * <Suspense fallback={<div>Loading user...</div>}>\n *   <QueriesHydration\n *     queries={[userQueryOptions(userId)]}\n *     skipSsrOnError={{ fallback: <div>Fetching on client...</div> }}\n *   >\n *     <UserProfile />\n *   </QueriesHydration>\n * </Suspense>\n * ```\n *\n * @see {@link https://suspensive.org/docs/react-query/QueriesHydration Documentation}\n */\nexport async function QueriesHydration({\n  queries,\n  children,\n  queryClient = new QueryClient(),\n  skipSsrOnError = true,\n  ...props\n}: {\n  /**\n   * The QueryClient instance to use for fetching queries.\n   */\n  queryClient?: QueryClient\n  /**\n   * An array of query options or infinite query options to be fetched on the server. Each query must include a `queryKey`.\n   * You can mix regular queries and infinite queries in the same array.\n   */\n  queries: (\n    | WithRequired<QueryOptions<any, any, any, any>, 'queryKey'>\n    | WithRequired<UseInfiniteQueryOptions<any, any, any, any, any>, 'queryKey'>\n  )[]\n  /**\n   * Controls error handling behavior:\n   * - `true` (default): Skips SSR and falls back to client-side rendering when server fetch fails\n   * - `false`: Proceeds with SSR without hydration (retry fetching on client component server rendering)\n   * - `{ fallback: ReactNode }`: Skips SSR with custom fallback UI during client-side rendering\n   */\n  skipSsrOnError?:\n    | boolean\n    | {\n        fallback: ReactNode\n      }\n} & OmitKeyof<HydrateProps, 'state'>) {\n  try {\n    await Promise.all(\n      queries.map((query) =>\n        'getNextPageParam' in query ? queryClient.fetchInfiniteQuery(query) : queryClient.fetchQuery(query)\n      )\n    )\n  } catch {\n    if (skipSsrOnError) {\n      return (\n        <ClientOnly fallback={skipSsrOnError === true ? undefined : skipSsrOnError.fallback}>{children}</ClientOnly>\n      )\n    }\n  }\n  return (\n    <Hydrate {...props} state={dehydrate(queryClient)}>\n      {children}\n    </Hydrate>\n  )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8EE;CACA;CACA;CACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAJF,SAAsB,iBAAiB;;;;wDA8BD;MA9BC,EACrC,SACA,UACA,cAAc,IAAIA,oCAAa,EAC/B,iBAAiB,eACd;AA0BH,MAAI;AACF,SAAM,QAAQ,IACZ,QAAQ,KAAK,UACX,sBAAsB,QAAQ,YAAY,mBAAmB,MAAM,GAAG,YAAY,WAAW,MAAM,CACpG,CACF;oBACK;AACN,OAAI,eACF,QACE,2CAACC;IAAW,UAAU,mBAAmB,OAAO,SAAY,eAAe;IAAW;KAAsB;;AAIlH,SACE,2CAACC,8GAAY;GAAO,6CAAiB,YAAY;GAC9C;KACO"}

package/dist/QueriesHydration-BrMSJHsz.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueriesHydration-BrMSJHsz.mjs","names":[],"sources":["../src/QueriesHydration.tsx"],"sourcesContent":["import {\n  Hydrate,\n  type HydrateProps,\n  type OmitKeyof,\n  QueryClient,\n  type QueryOptions,\n  type UseInfiniteQueryOptions,\n  type WithRequired,\n  dehydrate,\n} from '@tanstack/react-query'\nimport type { ReactNode } from 'react'\nimport { ClientOnly } from './components/ClientOnly'\n\n/**\n * A server component that fetches multiple queries on the server and hydrates them to the client.\n *\n * @experimental This component is experimental and may be changed or removed in the future.\n *\n * @description\n * QueriesHydration is designed for React Server Components (RSC).\n * It pre-fetches multiple queries on the server side and automatically hydrates\n * the data to the client, enabling seamless data synchronization between server and client.\n *\n * When errors occur during server-side fetching, the component gracefully falls back\n * to client-side rendering, ensuring your application remains resilient.\n *\n * @example\n * ```tsx\n * // app/page.tsx (Server Component)\n * import { Suspense } from 'react'\n * import { QueriesHydration } from '@suspensive/react-query'\n * import { queryOptions } from '@tanstack/react-query'\n *\n * const userQueryOptions = (userId: string) => queryOptions({\n *   queryKey: ['user', userId],\n *   queryFn: () => fetchUser(userId)\n * })\n *\n * const postsQueryOptions = () => queryOptions({\n *   queryKey: ['posts'],\n *   queryFn: () => fetchPosts()\n * })\n *\n * export default function Page({ userId }: { userId: string }) {\n *   return (\n *     <>\n *       <Suspense fallback={<div>Loading user...</div>}>\n *         <QueriesHydration queries={[userQueryOptions(userId)]}>\n *           <UserProfile />\n *         </QueriesHydration>\n *       </Suspense>\n *\n *       <Suspense fallback={<div>Loading posts...</div>}>\n *         <QueriesHydration queries={[postsQueryOptions()]}>\n *           <PostsList />\n *         </QueriesHydration>\n *       </Suspense>\n *     </>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * // With custom error fallback\n * <Suspense fallback={<div>Loading user...</div>}>\n *   <QueriesHydration\n *     queries={[userQueryOptions(userId)]}\n *     skipSsrOnError={{ fallback: <div>Fetching on client...</div> }}\n *   >\n *     <UserProfile />\n *   </QueriesHydration>\n * </Suspense>\n * ```\n *\n * @see {@link https://suspensive.org/docs/react-query/QueriesHydration Documentation}\n */\nexport async function QueriesHydration({\n  queries,\n  children,\n  queryClient = new QueryClient(),\n  skipSsrOnError = true,\n  ...props\n}: {\n  /**\n   * The QueryClient instance to use for fetching queries.\n   */\n  queryClient?: QueryClient\n  /**\n   * An array of query options or infinite query options to be fetched on the server. Each query must include a `queryKey`.\n   * You can mix regular queries and infinite queries in the same array.\n   */\n  queries: (\n    | WithRequired<QueryOptions<any, any, any, any>, 'queryKey'>\n    | WithRequired<UseInfiniteQueryOptions<any, any, any, any, any>, 'queryKey'>\n  )[]\n  /**\n   * Controls error handling behavior:\n   * - `true` (default): Skips SSR and falls back to client-side rendering when server fetch fails\n   * - `false`: Proceeds with SSR without hydration (retry fetching on client component server rendering)\n   * - `{ fallback: ReactNode }`: Skips SSR with custom fallback UI during client-side rendering\n   */\n  skipSsrOnError?:\n    | boolean\n    | {\n        fallback: ReactNode\n      }\n} & OmitKeyof<HydrateProps, 'state'>) {\n  try {\n    await Promise.all(\n      queries.map((query) =>\n        'getNextPageParam' in query ? queryClient.fetchInfiniteQuery(query) : queryClient.fetchQuery(query)\n      )\n    )\n  } catch {\n    if (skipSsrOnError) {\n      return (\n        <ClientOnly fallback={skipSsrOnError === true ? undefined : skipSsrOnError.fallback}>{children}</ClientOnly>\n      )\n    }\n  }\n  return (\n    <Hydrate {...props} state={dehydrate(queryClient)}>\n      {children}\n    </Hydrate>\n  )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8EE;CACA;CACA;CACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAJF,SAAsB,iBAAiB;;;;wDA8BD;MA9BC,EACrC,SACA,UACA,cAAc,IAAI,aAAa,EAC/B,iBAAiB,eACd;AA0BH,MAAI;AACF,SAAM,QAAQ,IACZ,QAAQ,KAAK,UACX,sBAAsB,QAAQ,YAAY,mBAAmB,MAAM,GAAG,YAAY,WAAW,MAAM,CACpG,CACF;oBACK;AACN,OAAI,eACF,QACE,oBAAC;IAAW,UAAU,mBAAmB,OAAO,SAAY,eAAe;IAAW;KAAsB;;AAIlH,SACE,oBAAC,2CAAY;GAAO,OAAO,UAAU,YAAY;GAC9C;KACO"}

package/dist/QueriesHydration-M2zoVGgJ.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueriesHydration-M2zoVGgJ.d.mts","names":[],"sources":["../src/QueriesHydration.tsx"],"sourcesContent":[],"mappings":";;;;;;;;;AA6EA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAsB,gBAAA;;;;;;;;;;gBAUN;;;;;YAMV,aAAa,gDACb,aAAa;;;;;;;;cAWD;;IAEd,UAAU,yBAAsB,QAAA,kBAAA,CAAA,GAAA,CAAA,OAAA"}