@suspensive/react-query-4 3.19.1 → 3.19.2

package/dist/IsFetching-BYkNw1cs.mjs

@@ -0,0 +1,18 @@
+import { t as _objectWithoutProperties } from "./objectWithoutProperties-BYP50gyF.mjs";
+import { useIsFetching } from "@tanstack/react-query";
+import { Fragment, jsx } from "react/jsx-runtime";
+
+//#region src/IsFetching.tsx
+const _excluded = ["children"];
+/**
+* Renders the current fetching count for queries that match the given filters.
+* @experimental This is an experimental feature.
+*/
+const IsFetching = (_ref) => {
+	let { children } = _ref;
+	return /* @__PURE__ */ jsx(Fragment, { children: children(useIsFetching(_objectWithoutProperties(_ref, _excluded))) });
+};
+
+//#endregion
+export { IsFetching as t };
+//# sourceMappingURL=IsFetching-BYkNw1cs.mjs.map

package/dist/IsFetching-BYkNw1cs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsFetching-BYkNw1cs.mjs","names":[],"sources":["../src/IsFetching.tsx"],"sourcesContent":["'use client'\n\nimport { type QueryFilters, useIsFetching } from '@tanstack/react-query'\nimport type { ReactNode } from 'react'\n\n/**\n * Renders the current fetching count for queries that match the given filters.\n * @experimental This is an experimental feature.\n */\nexport const IsFetching = ({\n  children,\n  ...filter\n}: QueryFilters & { children: (isFetching: ReturnType<typeof useIsFetching>) => ReactNode }) => (\n  <>{children(useIsFetching(filter))}</>\n)\n"],"mappings":";;;;;mBAUE;;;;;AADF,MAAa,cAAc,SAGqE;KAHrE,EACzB;AAE8F,QAC9F,0CAAG,SAAS,wDAAqB,CAAC,GAAI"}

package/dist/{IsFetching-D3xmE2Kn.d.mts → IsFetching-BfIQ3Qek.d.mts}

@@ -3,14 +3,17 @@ import * as react_jsx_runtime0 from "react/jsx-runtime";
 import { ReactNode } from "react";
 
 //#region src/IsFetching.d.ts
+
 /**
+ * Renders the current fetching count for queries that match the given filters.
  * @experimental This is an experimental feature.
  */
 declare const IsFetching: ({
-  children
+  children,
+  ...filter
 }: QueryFilters & {
   children: (isFetching: ReturnType<typeof useIsFetching>) => ReactNode;
 }) => react_jsx_runtime0.JSX.Element;
 //#endregion
 export { IsFetching as t };
-//# sourceMappingURL=IsFetching-D3xmE2Kn.d.mts.map
+//# sourceMappingURL=IsFetching-BfIQ3Qek.d.mts.map

package/dist/IsFetching-BfIQ3Qek.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsFetching-BfIQ3Qek.d.mts","names":[],"sources":["../src/IsFetching.tsx"],"sourcesContent":[],"mappings":";;;;;;;;;AASA;AAA2B,cAAd,UAAc,EAAA,CAAA;EAAA,QAAA;EAAA,GAAA;CAAA,EAGxB,YAHwB,GAAA;EAGxB,QAAA,EAAA,CAAA,UAAA,EAAwC,UAAxC,CAAA,OAA0D,aAA1D,CAAA,EAAA,GAA6E,SAA7E;CAA0D,EAAA,GAA8B,kBAAA,CAAA,GAAA,CAAA,OAA9B"}

package/dist/IsFetching-BhOgGqrs.cjs

@@ -0,0 +1,23 @@
+const require_objectWithoutProperties = require('./objectWithoutProperties-CYXRK7DS.cjs');
+let __tanstack_react_query = require("@tanstack/react-query");
+let react_jsx_runtime = require("react/jsx-runtime");
+
+//#region src/IsFetching.tsx
+const _excluded = ["children"];
+/**
+* Renders the current fetching count for queries that match the given filters.
+* @experimental This is an experimental feature.
+*/
+const IsFetching = (_ref) => {
+	let { children } = _ref;
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: children((0, __tanstack_react_query.useIsFetching)(require_objectWithoutProperties._objectWithoutProperties(_ref, _excluded))) });
+};
+
+//#endregion
+Object.defineProperty(exports, 'IsFetching', {
+  enumerable: true,
+  get: function () {
+    return IsFetching;
+  }
+});
+//# sourceMappingURL=IsFetching-BhOgGqrs.cjs.map

package/dist/IsFetching-BhOgGqrs.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsFetching-BhOgGqrs.cjs","names":[],"sources":["../src/IsFetching.tsx"],"sourcesContent":["'use client'\n\nimport { type QueryFilters, useIsFetching } from '@tanstack/react-query'\nimport type { ReactNode } from 'react'\n\n/**\n * Renders the current fetching count for queries that match the given filters.\n * @experimental This is an experimental feature.\n */\nexport const IsFetching = ({\n  children,\n  ...filter\n}: QueryFilters & { children: (isFetching: ReturnType<typeof useIsFetching>) => ReactNode }) => (\n  <>{children(useIsFetching(filter))}</>\n)\n"],"mappings":";;;;;mBAUE;;;;;AADF,MAAa,cAAc,SAGqE;KAHrE,EACzB;AAE8F,QAC9F,mFAAG,6HAA8B,CAAC,GAAI"}

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

@@ -1,16 +1,19 @@
-import * as react_jsx_runtime5 from "react/jsx-runtime";
+import * as react_jsx_runtime8 from "react/jsx-runtime";
 import { QueryFilters, useIsFetching } from "@tanstack/react-query";
 import { ReactNode } from "react";
 
 //#region src/IsFetching.d.ts
+
 /**
+ * Renders the current fetching count for queries that match the given filters.
  * @experimental This is an experimental feature.
  */
 declare const IsFetching: ({
-  children
+  children,
+  ...filter
 }: QueryFilters & {
   children: (isFetching: ReturnType<typeof useIsFetching>) => ReactNode;
-}) => react_jsx_runtime5.JSX.Element;
+}) => react_jsx_runtime8.JSX.Element;
 //#endregion
 export { IsFetching as t };
-//# sourceMappingURL=IsFetching-CThOxeZB.d.cts.map
+//# sourceMappingURL=IsFetching-CuftXnaJ.d.cts.map

package/dist/IsFetching-CuftXnaJ.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsFetching-CuftXnaJ.d.cts","names":[],"sources":["../src/IsFetching.tsx"],"sourcesContent":[],"mappings":";;;;;;;;;AASA;AAA2B,cAAd,UAAc,EAAA,CAAA;EAAA,QAAA;EAAA,GAAA;CAAA,EAGxB,YAHwB,GAAA;EAGxB,QAAA,EAAA,CAAA,UAAA,EAAwC,UAAxC,CAAA,OAA0D,aAA1D,CAAA,EAAA,GAA6E,SAA7E;CAA0D,EAAA,GAA8B,kBAAA,CAAA,GAAA,CAAA,OAA9B"}

package/dist/IsFetching.cjs

@@ -1,5 +1,5 @@
 'use client';
 
-const require_IsFetching = require('./IsFetching-BGIRMA6C.cjs');
+const require_IsFetching = require('./IsFetching-BhOgGqrs.cjs');
 
 exports.IsFetching = require_IsFetching.IsFetching;

package/dist/IsFetching.d.cts

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

package/dist/IsFetching.d.mts

@@ -1,2 +1,2 @@
-import { t as IsFetching } from "./IsFetching-D3xmE2Kn.mjs";
+import { t as IsFetching } from "./IsFetching-BfIQ3Qek.mjs";
 export { IsFetching };

package/dist/IsFetching.mjs

@@ -1,5 +1,5 @@
 'use client';
 
-import { t as IsFetching } from "./IsFetching-94upYqWP.mjs";
+import { t as IsFetching } from "./IsFetching-BYkNw1cs.mjs";
 
 export { IsFetching };

package/dist/{Mutation-BWER242k.cjs → Mutation-CGUYEkKX.cjs}

@@ -1,4 +1,4 @@
-const require_objectWithoutProperties = require('./objectWithoutProperties-BqF6LYLG.cjs');
+const require_objectWithoutProperties = require('./objectWithoutProperties-CYXRK7DS.cjs');
 let __tanstack_react_query = require("@tanstack/react-query");
 let react_jsx_runtime = require("react/jsx-runtime");
 
@@ -16,4 +16,4 @@ Object.defineProperty(exports, 'Mutation', {
     return Mutation;
   }
 });
-//# sourceMappingURL=Mutation-BWER242k.cjs.map
+//# sourceMappingURL=Mutation-CGUYEkKX.cjs.map

package/dist/{Mutation-BWER242k.cjs.map → Mutation-CGUYEkKX.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"Mutation-BWER242k.cjs","names":[],"sources":["../src/Mutation.tsx"],"sourcesContent":["'use client'\n\nimport { type UseMutationOptions, type UseMutationResult, useMutation } from '@tanstack/react-query'\nimport type { ReactNode } from 'react'\n\nexport function Mutation<TData = unknown, TError = unknown, TVariables = void, TContext = unknown>({\n  children,\n  ...options\n}: UseMutationOptions<TData, TError, TVariables, TContext> & {\n  children: (mutationResult: UseMutationResult<TData, TError, TVariables, TContext>) => ReactNode\n}) {\n  return <>{children(useMutation(options))}</>\n}\n"],"mappings":";;;;;mBAME;AADF,SAAgB,SAAmF,MAKhG;KALgG,EACjG;AAKA,QAAO,mFAAG,2HAA6B,CAAC,GAAI"}
+{"version":3,"file":"Mutation-CGUYEkKX.cjs","names":[],"sources":["../src/Mutation.tsx"],"sourcesContent":["'use client'\n\nimport { type UseMutationOptions, type UseMutationResult, useMutation } from '@tanstack/react-query'\nimport type { ReactNode } from 'react'\n\nexport function Mutation<TData = unknown, TError = unknown, TVariables = void, TContext = unknown>({\n  children,\n  ...options\n}: UseMutationOptions<TData, TError, TVariables, TContext> & {\n  children: (mutationResult: UseMutationResult<TData, TError, TVariables, TContext>) => ReactNode\n}) {\n  return <>{children(useMutation(options))}</>\n}\n"],"mappings":";;;;;mBAME;AADF,SAAgB,SAAmF,MAKhG;KALgG,EACjG;AAKA,QAAO,mFAAG,2HAA6B,CAAC,GAAI"}

package/dist/{Mutation-Dt5kUsd8.d.cts → Mutation-DGmP7HQI.d.cts}

@@ -1,4 +1,4 @@
-import * as react_jsx_runtime0 from "react/jsx-runtime";
+import * as react_jsx_runtime6 from "react/jsx-runtime";
 import { UseMutationOptions, UseMutationResult } from "@tanstack/react-query";
 import { ReactNode } from "react";
 
@@ -8,7 +8,7 @@ declare function Mutation<TData = unknown, TError = unknown, TVariables = void,
   ...options
 }: UseMutationOptions<TData, TError, TVariables, TContext> & {
   children: (mutationResult: UseMutationResult<TData, TError, TVariables, TContext>) => ReactNode;
-}): react_jsx_runtime0.JSX.Element;
+}): react_jsx_runtime6.JSX.Element;
 //#endregion
 export { Mutation as t };
-//# sourceMappingURL=Mutation-Dt5kUsd8.d.cts.map
+//# sourceMappingURL=Mutation-DGmP7HQI.d.cts.map

package/dist/{Mutation-Dt5kUsd8.d.cts.map → Mutation-DGmP7HQI.d.cts.map}

@@ -1 +1 @@
-{"version":3,"file":"Mutation-Dt5kUsd8.d.cts","names":[],"sources":["../src/Mutation.tsx"],"sourcesContent":[],"mappings":";;;;;iBAKgB;;;GAGb,mBAAmB,OAAO,QAAQ,YAAY;6BACpB,kBAAkB,OAAO,QAAQ,YAAY,cAAc;IACvF,kBAAA,CAAA,GAAA,CAAA"}
+{"version":3,"file":"Mutation-DGmP7HQI.d.cts","names":[],"sources":["../src/Mutation.tsx"],"sourcesContent":[],"mappings":";;;;;iBAKgB;;;GAGb,mBAAmB,OAAO,QAAQ,YAAY;6BACpB,kBAAkB,OAAO,QAAQ,YAAY,cAAc;IACvF,kBAAA,CAAA,GAAA,CAAA"}

package/dist/{Mutation-BJunfaUO.mjs → Mutation-DUJhz3rT.mjs}

@@ -1,4 +1,4 @@
-import { t as _objectWithoutProperties } from "./objectWithoutProperties-Drlt06jT.mjs";
+import { t as _objectWithoutProperties } from "./objectWithoutProperties-BYP50gyF.mjs";
 import { useMutation } from "@tanstack/react-query";
 import { Fragment, jsx } from "react/jsx-runtime";
 
@@ -11,4 +11,4 @@ function Mutation(_ref) {
 
 //#endregion
 export { Mutation as t };
-//# sourceMappingURL=Mutation-BJunfaUO.mjs.map
+//# sourceMappingURL=Mutation-DUJhz3rT.mjs.map

package/dist/{Mutation-BJunfaUO.mjs.map → Mutation-DUJhz3rT.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"Mutation-BJunfaUO.mjs","names":[],"sources":["../src/Mutation.tsx"],"sourcesContent":["'use client'\n\nimport { type UseMutationOptions, type UseMutationResult, useMutation } from '@tanstack/react-query'\nimport type { ReactNode } from 'react'\n\nexport function Mutation<TData = unknown, TError = unknown, TVariables = void, TContext = unknown>({\n  children,\n  ...options\n}: UseMutationOptions<TData, TError, TVariables, TContext> & {\n  children: (mutationResult: UseMutationResult<TData, TError, TVariables, TContext>) => ReactNode\n}) {\n  return <>{children(useMutation(options))}</>\n}\n"],"mappings":";;;;;mBAME;AADF,SAAgB,SAAmF,MAKhG;KALgG,EACjG;AAKA,QAAO,0CAAG,SAAS,sDAAoB,CAAC,GAAI"}
+{"version":3,"file":"Mutation-DUJhz3rT.mjs","names":[],"sources":["../src/Mutation.tsx"],"sourcesContent":["'use client'\n\nimport { type UseMutationOptions, type UseMutationResult, useMutation } from '@tanstack/react-query'\nimport type { ReactNode } from 'react'\n\nexport function Mutation<TData = unknown, TError = unknown, TVariables = void, TContext = unknown>({\n  children,\n  ...options\n}: UseMutationOptions<TData, TError, TVariables, TContext> & {\n  children: (mutationResult: UseMutationResult<TData, TError, TVariables, TContext>) => ReactNode\n}) {\n  return <>{children(useMutation(options))}</>\n}\n"],"mappings":";;;;;mBAME;AADF,SAAgB,SAAmF,MAKhG;KALgG,EACjG;AAKA,QAAO,0CAAG,SAAS,sDAAoB,CAAC,GAAI"}

package/dist/Mutation.cjs

@@ -1,5 +1,5 @@
 'use client';
 
-const require_Mutation = require('./Mutation-BWER242k.cjs');
+const require_Mutation = require('./Mutation-CGUYEkKX.cjs');
 
 exports.Mutation = require_Mutation.Mutation;

package/dist/Mutation.d.cts

@@ -1,2 +1,2 @@
-import { t as Mutation } from "./Mutation-Dt5kUsd8.cjs";
+import { t as Mutation } from "./Mutation-DGmP7HQI.cjs";
 export { Mutation };

package/dist/Mutation.mjs

@@ -1,5 +1,5 @@
 'use client';
 
-import { t as Mutation } from "./Mutation-BJunfaUO.mjs";
+import { t as Mutation } from "./Mutation-DUJhz3rT.mjs";
 
 export { Mutation };

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

@@ -1,5 +1,5 @@
+import * as react_jsx_runtime0 from "react/jsx-runtime";
 import { FetchInfiniteQueryOptions, QueryKey } from "@tanstack/react-query";
-import * as react_jsx_runtime1 from "react/jsx-runtime";
 
 //#region src/PrefetchInfiniteQuery.d.ts
 
@@ -11,7 +11,7 @@ import * as react_jsx_runtime1 from "react/jsx-runtime";
  * <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_runtime1.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-Dzjm5lf8.d.mts.map
+//# sourceMappingURL=PrefetchInfiniteQuery-BewcG5rR.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"PrefetchInfiniteQuery-DgZfL2Sb.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-DgZfL2Sb.d.cts → PrefetchInfiniteQuery-D-3dZMEz.d.mts}

@@ -1,5 +1,5 @@
-import * as react_jsx_runtime1 from "react/jsx-runtime";
 import { FetchInfiniteQueryOptions, QueryKey } from "@tanstack/react-query";
+import * as react_jsx_runtime4 from "react/jsx-runtime";
 
 //#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_runtime1.JSX.Element;
+declare function PrefetchInfiniteQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>): react_jsx_runtime4.JSX.Element;
 //#endregion
 export { PrefetchInfiniteQuery as t };
-//# sourceMappingURL=PrefetchInfiniteQuery-DgZfL2Sb.d.cts.map
+//# sourceMappingURL=PrefetchInfiniteQuery-D-3dZMEz.d.mts.map

package/dist/{PrefetchInfiniteQuery-Dzjm5lf8.d.mts.map → PrefetchInfiniteQuery-D-3dZMEz.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"PrefetchInfiniteQuery-Dzjm5lf8.d.mts","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-D-3dZMEz.d.mts","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-DgZfL2Sb.cjs";
+import { t as PrefetchInfiniteQuery } from "./PrefetchInfiniteQuery-BewcG5rR.cjs";
 export { PrefetchInfiniteQuery };

package/dist/PrefetchInfiniteQuery.d.mts

@@ -1,2 +1,2 @@
-import { t as PrefetchInfiniteQuery } from "./PrefetchInfiniteQuery-Dzjm5lf8.mjs";
+import { t as PrefetchInfiniteQuery } from "./PrefetchInfiniteQuery-D-3dZMEz.mjs";
 export { PrefetchInfiniteQuery };

package/dist/{PrefetchQuery-CeQ0yxDL.d.cts → PrefetchQuery-Ddbt43Fk.d.cts}

@@ -1,4 +1,4 @@
-import * as react_jsx_runtime2 from "react/jsx-runtime";
+import * as react_jsx_runtime0 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_runtime2.JSX.Element;
+declare function PrefetchQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>): react_jsx_runtime0.JSX.Element;
 //#endregion
 export { PrefetchQuery as t };
-//# sourceMappingURL=PrefetchQuery-CeQ0yxDL.d.cts.map
+//# sourceMappingURL=PrefetchQuery-Ddbt43Fk.d.cts.map

package/dist/{PrefetchQuery-CeQ0yxDL.d.cts.map → PrefetchQuery-Ddbt43Fk.d.cts.map}

@@ -1 +1 @@
-{"version":3,"file":"PrefetchQuery-CeQ0yxDL.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-Ddbt43Fk.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-DAqAWOeP.d.mts → PrefetchQuery-DqgbVdjY.d.mts}

@@ -1,5 +1,5 @@
 import { FetchQueryOptions, QueryKey } from "@tanstack/react-query";
-import * as react_jsx_runtime2 from "react/jsx-runtime";
+import * as react_jsx_runtime8 from "react/jsx-runtime";
 
 //#region src/PrefetchQuery.d.ts
 
@@ -11,7 +11,7 @@ import * as react_jsx_runtime2 from "react/jsx-runtime";
  * <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_runtime2.JSX.Element;
+declare function PrefetchQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>): react_jsx_runtime8.JSX.Element;
 //#endregion
 export { PrefetchQuery as t };
-//# sourceMappingURL=PrefetchQuery-DAqAWOeP.d.mts.map
+//# sourceMappingURL=PrefetchQuery-DqgbVdjY.d.mts.map

package/dist/{PrefetchQuery-DAqAWOeP.d.mts.map → PrefetchQuery-DqgbVdjY.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"PrefetchQuery-DAqAWOeP.d.mts","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-DqgbVdjY.d.mts","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-CeQ0yxDL.cjs";
+import { t as PrefetchQuery } from "./PrefetchQuery-Ddbt43Fk.cjs";
 export { PrefetchQuery };

package/dist/PrefetchQuery.d.mts

@@ -1,2 +1,2 @@
-import { t as PrefetchQuery } from "./PrefetchQuery-DAqAWOeP.mjs";
+import { t as PrefetchQuery } from "./PrefetchQuery-DqgbVdjY.mjs";
 export { PrefetchQuery };

package/dist/{QueriesHydration-B89HKn9y.d.cts → QueriesHydration-DPogKsc4.d.mts}

@@ -1,5 +1,5 @@
-import * as react_jsx_runtime4 from "react/jsx-runtime";
 import { HydrateProps, OmitKeyof, QueryClient, QueryOptions, UseInfiniteQueryOptions, WithRequired } from "@tanstack/react-query";
+import * as react_jsx_runtime2 from "react/jsx-runtime";
 import { ReactNode } from "react";
 
 //#region src/QueriesHydration.d.ts
@@ -100,7 +100,7 @@ declare function QueriesHydration({
    * When not set, no timeout is applied.
    */
   timeout?: number;
-} & OmitKeyof<HydrateProps, 'state'>): Promise<react_jsx_runtime4.JSX.Element>;
+} & OmitKeyof<HydrateProps, 'state'>): Promise<react_jsx_runtime2.JSX.Element>;
 //#endregion
 export { QueriesHydration as t };
-//# sourceMappingURL=QueriesHydration-B89HKn9y.d.cts.map
+//# sourceMappingURL=QueriesHydration-DPogKsc4.d.mts.map

package/dist/{QueriesHydration-B89HKn9y.d.cts.map → QueriesHydration-DPogKsc4.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"QueriesHydration-B89HKn9y.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"}
+{"version":3,"file":"QueriesHydration-DPogKsc4.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-BeMkJU3l.d.mts → QueriesHydration-DnlRrHJ3.d.cts}

@@ -1,5 +1,5 @@
+import * as react_jsx_runtime1 from "react/jsx-runtime";
 import { HydrateProps, OmitKeyof, QueryClient, QueryOptions, UseInfiniteQueryOptions, WithRequired } from "@tanstack/react-query";
-import * as react_jsx_runtime3 from "react/jsx-runtime";
 import { ReactNode } from "react";
 
 //#region src/QueriesHydration.d.ts
@@ -100,7 +100,7 @@ declare function QueriesHydration({
    * When not set, no timeout is applied.
    */
   timeout?: number;
-} & OmitKeyof<HydrateProps, 'state'>): Promise<react_jsx_runtime3.JSX.Element>;
+} & OmitKeyof<HydrateProps, 'state'>): Promise<react_jsx_runtime1.JSX.Element>;
 //#endregion
 export { QueriesHydration as t };
-//# sourceMappingURL=QueriesHydration-BeMkJU3l.d.mts.map
+//# sourceMappingURL=QueriesHydration-DnlRrHJ3.d.cts.map

package/dist/{QueriesHydration-BeMkJU3l.d.mts.map → QueriesHydration-DnlRrHJ3.d.cts.map}

@@ -1 +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"}
+{"version":3,"file":"QueriesHydration-DnlRrHJ3.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-27lFZeB8.mjs → QueriesHydration-GQxJe_Vu.mjs}

@@ -1,4 +1,4 @@
-import { t as _objectWithoutProperties } from "./objectWithoutProperties-Drlt06jT.mjs";
+import { t as _objectWithoutProperties } from "./objectWithoutProperties-BYP50gyF.mjs";
 import { t as ClientOnly } from "./ClientOnly-BdmzVYnI.mjs";
 import { t as _objectSpread2 } from "./objectSpread2-BFPIJj0i.mjs";
 import { Hydrate, QueryClient, dehydrate } from "@tanstack/react-query";
@@ -140,4 +140,4 @@ const createTimeoutController = (ms, errorMessage) => {
 
 //#endregion
 export { QueriesHydration as t };
-//# sourceMappingURL=QueriesHydration-27lFZeB8.mjs.map
+//# sourceMappingURL=QueriesHydration-GQxJe_Vu.mjs.map

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

@@ -1 +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"}
+{"version":3,"file":"QueriesHydration-GQxJe_Vu.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-BYKU-Mte.cjs → QueriesHydration-dcSAzQNT.cjs}

@@ -1,4 +1,4 @@
-const require_objectWithoutProperties = require('./objectWithoutProperties-BqF6LYLG.cjs');
+const require_objectWithoutProperties = require('./objectWithoutProperties-CYXRK7DS.cjs');
 const require_ClientOnly = require('./ClientOnly-Dvf8t__-.cjs');
 const require_objectSpread2 = require('./objectSpread2-CpqxxdM2.cjs');
 let __tanstack_react_query = require("@tanstack/react-query");
@@ -145,4 +145,4 @@ Object.defineProperty(exports, 'QueriesHydration', {
     return QueriesHydration;
   }
 });
-//# sourceMappingURL=QueriesHydration-BYKU-Mte.cjs.map
+//# sourceMappingURL=QueriesHydration-dcSAzQNT.cjs.map

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

@@ -1 +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"}
+{"version":3,"file":"QueriesHydration-dcSAzQNT.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.cjs

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

package/dist/QueriesHydration.d.cts

@@ -1,2 +1,2 @@
-import { t as QueriesHydration } from "./QueriesHydration-B89HKn9y.cjs";
+import { t as QueriesHydration } from "./QueriesHydration-DnlRrHJ3.cjs";
 export { QueriesHydration };

package/dist/QueriesHydration.d.mts

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

package/dist/QueriesHydration.mjs

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

package/dist/{QueryClientConsumer-D3h25GmM.d.cts → QueryClientConsumer-5PZLv_8g.d.mts}

@@ -1,5 +1,5 @@
-import * as react_jsx_runtime3 from "react/jsx-runtime";
 import { QueryClient } from "@tanstack/react-query";
+import * as react_jsx_runtime3 from "react/jsx-runtime";
 import { Context, ReactNode } from "react";
 
 //#region src/QueryClientConsumer.d.ts
@@ -15,4 +15,4 @@ declare function QueryClientConsumer({
 }): react_jsx_runtime3.JSX.Element;
 //#endregion
 export { QueryClientConsumer as t };
-//# sourceMappingURL=QueryClientConsumer-D3h25GmM.d.cts.map
+//# sourceMappingURL=QueryClientConsumer-5PZLv_8g.d.mts.map

package/dist/{QueryClientConsumer-D3h25GmM.d.cts.map → QueryClientConsumer-5PZLv_8g.d.mts.map}

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"QueryClientConsumer-5PZLv_8g.d.mts","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-DNkucS1e.d.mts → QueryClientConsumer-pihgMOoA.d.cts}

@@ -1,5 +1,5 @@
+import * as react_jsx_runtime2 from "react/jsx-runtime";
 import { QueryClient } from "@tanstack/react-query";
-import * as react_jsx_runtime5 from "react/jsx-runtime";
 import { Context, ReactNode } from "react";
 
 //#region src/QueryClientConsumer.d.ts
@@ -12,7 +12,7 @@ declare function QueryClientConsumer({
 }: {
   children: (queryClient: QueryClient) => ReactNode;
   context?: Context<QueryClient | undefined>;
-}): react_jsx_runtime5.JSX.Element;
+}): react_jsx_runtime2.JSX.Element;
 //#endregion
 export { QueryClientConsumer as t };
-//# sourceMappingURL=QueryClientConsumer-DNkucS1e.d.mts.map
+//# sourceMappingURL=QueryClientConsumer-pihgMOoA.d.cts.map

package/dist/{QueryClientConsumer-DNkucS1e.d.mts.map → QueryClientConsumer-pihgMOoA.d.cts.map}

@@ -1 +1 @@
-{"version":3,"file":"QueryClientConsumer-DNkucS1e.d.mts","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-pihgMOoA.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-D3h25GmM.cjs";
+import { t as QueryClientConsumer } from "./QueryClientConsumer-pihgMOoA.cjs";
 export { QueryClientConsumer };

package/dist/QueryClientConsumer.d.mts

@@ -1,2 +1,2 @@
-import { t as QueryClientConsumer } from "./QueryClientConsumer-DNkucS1e.mjs";
+import { t as QueryClientConsumer } from "./QueryClientConsumer-5PZLv_8g.mjs";
 export { QueryClientConsumer };

package/dist/{SuspenseInfiniteQuery-DwW5I_M2.mjs → SuspenseInfiniteQuery-BimBkaCe.mjs}

@@ -1,4 +1,4 @@
-import { t as _objectWithoutProperties } from "./objectWithoutProperties-Drlt06jT.mjs";
+import { t as _objectWithoutProperties } from "./objectWithoutProperties-BYP50gyF.mjs";
 import { useSuspenseInfiniteQuery } from "@tanstack/react-query";
 import { Fragment, jsx } from "react/jsx-runtime";
 
@@ -27,4 +27,4 @@ const SuspenseInfiniteQuery = (_ref) => {
 
 //#endregion
 export { SuspenseInfiniteQuery as t };
-//# sourceMappingURL=SuspenseInfiniteQuery-DwW5I_M2.mjs.map
+//# sourceMappingURL=SuspenseInfiniteQuery-BimBkaCe.mjs.map

package/dist/{SuspenseInfiniteQuery-DwW5I_M2.mjs.map → SuspenseInfiniteQuery-BimBkaCe.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"SuspenseInfiniteQuery-DwW5I_M2.mjs","names":[],"sources":["../src/SuspenseInfiniteQuery.tsx"],"sourcesContent":["'use client'\n\nimport { type QueryKey, type UseSuspenseInfiniteQueryResult, useSuspenseInfiniteQuery } from '@tanstack/react-query'\nimport type { ReactNode } from 'react'\nimport { type UseSuspenseInfiniteQueryOptions } from './useSuspenseInfiniteQuery'\n/**\n * We provide these components to clearly express what causes suspense at the same depth.\n * `<SuspenseInfiniteQuery/>` serves to make `useSuspenseInfiniteQuery` easier to use in jsx.\n * @see {@link https://suspensive.org/docs/react-query/SuspenseInfiniteQuery Suspensive Docs}\n * @example\n * ```tsx\n * import { SuspenseInfiniteQuery } from '@suspensive/react-query'\n *\n * // You can use infiniteQueryOptions as props.\n * <SuspenseInfiniteQuery {...infiniteQueryOptions()}>\n *   {({ data, fetchNextPage }) => {\n *     return <></>\n *   }}\n * </SuspenseInfiniteQuery>\n * ```\n */\nexport const SuspenseInfiniteQuery = <\n  TQueryFnData = unknown,\n  TError = unknown,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>({\n  children,\n  ...options\n}: UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {\n  children: (query: UseSuspenseInfiniteQueryResult<TData, TError>) => ReactNode\n}) => <>{children(useSuspenseInfiniteQuery(options))}</>\n"],"mappings":";;;;;mBA2BE;;;;;;;;;;;;;;;;;AANF,MAAa,yBAKX,SAKI;KALJ,EACA;AAII,kDAAG,SAAS,mEAAiC,CAAC,GAAI"}
+{"version":3,"file":"SuspenseInfiniteQuery-BimBkaCe.mjs","names":[],"sources":["../src/SuspenseInfiniteQuery.tsx"],"sourcesContent":["'use client'\n\nimport { type QueryKey, type UseSuspenseInfiniteQueryResult, useSuspenseInfiniteQuery } from '@tanstack/react-query'\nimport type { ReactNode } from 'react'\nimport { type UseSuspenseInfiniteQueryOptions } from './useSuspenseInfiniteQuery'\n/**\n * We provide these components to clearly express what causes suspense at the same depth.\n * `<SuspenseInfiniteQuery/>` serves to make `useSuspenseInfiniteQuery` easier to use in jsx.\n * @see {@link https://suspensive.org/docs/react-query/SuspenseInfiniteQuery Suspensive Docs}\n * @example\n * ```tsx\n * import { SuspenseInfiniteQuery } from '@suspensive/react-query'\n *\n * // You can use infiniteQueryOptions as props.\n * <SuspenseInfiniteQuery {...infiniteQueryOptions()}>\n *   {({ data, fetchNextPage }) => {\n *     return <></>\n *   }}\n * </SuspenseInfiniteQuery>\n * ```\n */\nexport const SuspenseInfiniteQuery = <\n  TQueryFnData = unknown,\n  TError = unknown,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>({\n  children,\n  ...options\n}: UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {\n  children: (query: UseSuspenseInfiniteQueryResult<TData, TError>) => ReactNode\n}) => <>{children(useSuspenseInfiniteQuery(options))}</>\n"],"mappings":";;;;;mBA2BE;;;;;;;;;;;;;;;;;AANF,MAAa,yBAKX,SAKI;KALJ,EACA;AAII,kDAAG,SAAS,mEAAiC,CAAC,GAAI"}

package/dist/{SuspenseInfiniteQuery-CSd2Hyym.d.mts → SuspenseInfiniteQuery-BtRviR-Z.d.mts}

@@ -1,6 +1,6 @@
 import { t as UseSuspenseInfiniteQueryOptions } from "./useSuspenseInfiniteQuery-Bh0nh8Kc.mjs";
 import { QueryKey, UseSuspenseInfiniteQueryResult } from "@tanstack/react-query";
-import * as react_jsx_runtime4 from "react/jsx-runtime";
+import * as react_jsx_runtime7 from "react/jsx-runtime";
 import { ReactNode } from "react";
 
 //#region src/SuspenseInfiniteQuery.d.ts
@@ -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_runtime4.JSX.Element;
+}) => react_jsx_runtime7.JSX.Element;
 //#endregion
 export { SuspenseInfiniteQuery as t };
-//# sourceMappingURL=SuspenseInfiniteQuery-CSd2Hyym.d.mts.map
+//# sourceMappingURL=SuspenseInfiniteQuery-BtRviR-Z.d.mts.map