@suspensive/react-query-4 3.14.0 → 3.15.1

package/dist/usePrefetchQuery.mjs

@@ -0,0 +1,6 @@
+'use client';
+
+
+import { t as usePrefetchQuery } from "./usePrefetchQuery-RuK6ZS1I.mjs";
+
+export { usePrefetchQuery };

package/dist/{useSuspenseInfiniteQuery-CPSFNa3R.js → useSuspenseInfiniteQuery-BVmSR5yZ.mjs}

@@ -14,4 +14,4 @@ const useSuspenseInfiniteQuery$1 = useSuspenseInfiniteQuery;
 
 //#endregion
 export { useSuspenseInfiniteQuery$1 as t };
-//# sourceMappingURL=useSuspenseInfiniteQuery-CPSFNa3R.js.map
+//# sourceMappingURL=useSuspenseInfiniteQuery-BVmSR5yZ.mjs.map

package/dist/useSuspenseInfiniteQuery-BVmSR5yZ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSuspenseInfiniteQuery-BVmSR5yZ.mjs","names":["useSuspenseInfiniteQuery","original_useSuspenseInfiniteQuery"],"sources":["../src/useSuspenseInfiniteQuery.ts"],"sourcesContent":["'use client'\n\nimport {\n  type OmitKeyof,\n  type QueryKey,\n  type UseInfiniteQueryOptions,\n  type WithRequired,\n  useSuspenseInfiniteQuery as original_useSuspenseInfiniteQuery,\n} from '@tanstack/react-query'\n\nexport type { UseSuspenseInfiniteQueryResult } from '@tanstack/react-query'\n\nexport type UseSuspenseInfiniteQueryOptions<\n  TQueryFnData = unknown,\n  TError = unknown,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n> = WithRequired<\n  OmitKeyof<\n    UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>,\n    'suspense' | 'useErrorBoundary' | 'enabled' | 'placeholderData' | 'networkMode' | 'initialData'\n  >,\n  'queryKey'\n>\n\n/**\n * This feature is officially supported in \\@tanstack/react-query@^4.41.0, You can proceed with the migration.\n * @deprecated Use `useSuspenseInfiniteQuery` from \\@tanstack/react-query@^4.41.0\n * @example\n * ```diff\n * - import { useSuspenseInfiniteQuery } from '@suspensive/react-query'\n * + import { useSuspenseInfiniteQuery } from '@tanstack/react-query'\n * ```\n */\nexport const useSuspenseInfiniteQuery = original_useSuspenseInfiniteQuery\n"],"mappings":";;;;;;;;;;;;AAkCA,MAAaA,6BAA2BC"}

package/dist/{useSuspenseInfiniteQuery-Cu93Uy03.d.cts → useSuspenseInfiniteQuery-CMhbiMDc.d.cts}

@@ -14,4 +14,4 @@ type UseSuspenseInfiniteQueryOptions<TQueryFnData = unknown, TError = unknown, T
 declare const useSuspenseInfiniteQuery$1: typeof useSuspenseInfiniteQuery;
 //#endregion
 export { UseSuspenseInfiniteQueryResult$1 as n, useSuspenseInfiniteQuery$1 as r, UseSuspenseInfiniteQueryOptions as t };
-//# sourceMappingURL=useSuspenseInfiniteQuery-Cu93Uy03.d.cts.map
+//# sourceMappingURL=useSuspenseInfiniteQuery-CMhbiMDc.d.cts.map

package/dist/useSuspenseInfiniteQuery-CMhbiMDc.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSuspenseInfiniteQuery-CMhbiMDc.d.cts","names":[],"sources":["../src/useSuspenseInfiniteQuery.ts"],"sourcesContent":[],"mappings":";;;KAYY,kFAGF,gCACU,WAAW,YAC3B,aACF,UACE,wBAAwB,cAAc,QAAQ,OAAO,cAAc;AAPvE;;;;;;;;;AAOI,cAeS,0BAfT,EAAA,OAeiC,wBAfjC"}

package/dist/{useSuspenseInfiniteQuery-Bb0CuB92.d.ts → useSuspenseInfiniteQuery-Dvy7bTQq.d.mts}

@@ -14,4 +14,4 @@ type UseSuspenseInfiniteQueryOptions<TQueryFnData = unknown, TError = unknown, T
 declare const useSuspenseInfiniteQuery$1: typeof useSuspenseInfiniteQuery;
 //#endregion
 export { UseSuspenseInfiniteQueryResult$1 as n, useSuspenseInfiniteQuery$1 as r, UseSuspenseInfiniteQueryOptions as t };
-//# sourceMappingURL=useSuspenseInfiniteQuery-Bb0CuB92.d.ts.map
+//# sourceMappingURL=useSuspenseInfiniteQuery-Dvy7bTQq.d.mts.map

package/dist/useSuspenseInfiniteQuery-Dvy7bTQq.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSuspenseInfiniteQuery-Dvy7bTQq.d.mts","names":[],"sources":["../src/useSuspenseInfiniteQuery.ts"],"sourcesContent":[],"mappings":";;;KAYY,kFAGF,gCACU,WAAW,YAC3B,aACF,UACE,wBAAwB,cAAc,QAAQ,OAAO,cAAc;AAPvE;;;;;;;;;AAOI,cAeS,0BAfT,EAAA,OAeiC,wBAfjC"}

package/dist/useSuspenseInfiniteQuery.d.cts

@@ -1,2 +1,2 @@
-import { n as UseSuspenseInfiniteQueryResult, r as useSuspenseInfiniteQuery, t as UseSuspenseInfiniteQueryOptions } from "./useSuspenseInfiniteQuery-Cu93Uy03.cjs";
+import { n as UseSuspenseInfiniteQueryResult, r as useSuspenseInfiniteQuery, t as UseSuspenseInfiniteQueryOptions } from "./useSuspenseInfiniteQuery-CMhbiMDc.cjs";
 export { UseSuspenseInfiniteQueryOptions, UseSuspenseInfiniteQueryResult, useSuspenseInfiniteQuery };

package/dist/{useSuspenseInfiniteQuery.d.ts → useSuspenseInfiniteQuery.d.mts}

@@ -1,2 +1,2 @@
-import { n as UseSuspenseInfiniteQueryResult, r as useSuspenseInfiniteQuery, t as UseSuspenseInfiniteQueryOptions } from "./useSuspenseInfiniteQuery-Bb0CuB92.js";
+import { n as UseSuspenseInfiniteQueryResult, r as useSuspenseInfiniteQuery, t as UseSuspenseInfiniteQueryOptions } from "./useSuspenseInfiniteQuery-Dvy7bTQq.mjs";
 export { UseSuspenseInfiniteQueryOptions, UseSuspenseInfiniteQueryResult, useSuspenseInfiniteQuery };

package/dist/{useSuspenseInfiniteQuery.js → useSuspenseInfiniteQuery.mjs}

@@ -1,6 +1,6 @@
 'use client';
 
 
-import { t as useSuspenseInfiniteQuery } from "./useSuspenseInfiniteQuery-CPSFNa3R.js";
+import { t as useSuspenseInfiniteQuery } from "./useSuspenseInfiniteQuery-BVmSR5yZ.mjs";
 
 export { useSuspenseInfiniteQuery };

package/dist/{useSuspenseQueries-B5ixNUu4.d.cts → useSuspenseQueries-DFtL_xO-.d.mts}

@@ -34,4 +34,4 @@ type SuspenseQueriesResults$1<T extends Array<any>, TResult extends Array<any> =
 declare const useSuspenseQueries$1: typeof useSuspenseQueries;
 //#endregion
 export { SuspenseQueriesResults$1 as n, useSuspenseQueries$1 as r, SuspenseQueriesOptions$1 as t };
-//# sourceMappingURL=useSuspenseQueries-B5ixNUu4.d.cts.map
+//# sourceMappingURL=useSuspenseQueries-DFtL_xO-.d.mts.map

package/dist/useSuspenseQueries-DFtL_xO-.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSuspenseQueries-DFtL_xO-.d.mts","names":[],"sources":["../src/useSuspenseQueries.ts"],"sourcesContent":[],"mappings":";;;;;;AAiBA;;;;;;;AAII,KAJQ,wBAIR,CAAA,UAHQ,KAGR,CAAA,GAAA,CAAA,EAAA,gBAFc,KAEd,CAAA,GAAA,CAAA,GAAA,EAAA,EAAA,eADa,aACb,CAAA,MAAA,CAAA,GAAA,EAAA,CAAA,GAAA,sBAAA,CAAgC,CAAhC,EAAmC,OAAnC,EAA4C,MAA5C,CAAA;;AAWJ;;;;;;;;AAImC,KAJvB,wBAIuB,CAAA,UAHvB,KAGuB,CAAA,GAAA,CAAA,EAAA,gBAFjB,KAEiB,CAAA,GAAA,CAAA,GAAA,EAAA,EAAA,eADlB,aACkB,CAAA,MAAA,CAAA,GAAA,EAAA,CAAA,GAA/B,sBAA+B,CAAC,CAAD,EAAI,OAAJ,EAAa,MAAb,CAAA;AAWnC;;;;;;;;;cAAa,6BAAkB"}

package/dist/{useSuspenseQueries-DWeObNoR.d.ts → useSuspenseQueries-DNZH-duj.d.cts}

@@ -34,4 +34,4 @@ type SuspenseQueriesResults$1<T extends Array<any>, TResult extends Array<any> =
 declare const useSuspenseQueries$1: typeof useSuspenseQueries;
 //#endregion
 export { SuspenseQueriesResults$1 as n, useSuspenseQueries$1 as r, SuspenseQueriesOptions$1 as t };
-//# sourceMappingURL=useSuspenseQueries-DWeObNoR.d.ts.map
+//# sourceMappingURL=useSuspenseQueries-DNZH-duj.d.cts.map

package/dist/useSuspenseQueries-DNZH-duj.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSuspenseQueries-DNZH-duj.d.cts","names":[],"sources":["../src/useSuspenseQueries.ts"],"sourcesContent":[],"mappings":";;;;;;AAiBA;;;;;;;AAII,KAJQ,wBAIR,CAAA,UAHQ,KAGR,CAAA,GAAA,CAAA,EAAA,gBAFc,KAEd,CAAA,GAAA,CAAA,GAAA,EAAA,EAAA,eADa,aACb,CAAA,MAAA,CAAA,GAAA,EAAA,CAAA,GAAA,sBAAA,CAAgC,CAAhC,EAAmC,OAAnC,EAA4C,MAA5C,CAAA;;AAWJ;;;;;;;;AAImC,KAJvB,wBAIuB,CAAA,UAHvB,KAGuB,CAAA,GAAA,CAAA,EAAA,gBAFjB,KAEiB,CAAA,GAAA,CAAA,GAAA,EAAA,EAAA,eADlB,aACkB,CAAA,MAAA,CAAA,GAAA,EAAA,CAAA,GAA/B,sBAA+B,CAAC,CAAD,EAAI,OAAJ,EAAa,MAAb,CAAA;AAWnC;;;;;;;;;cAAa,6BAAkB"}

package/dist/{useSuspenseQueries-B9xL4GvG.js → useSuspenseQueries-DqT8AKu2.mjs}

@@ -14,4 +14,4 @@ const useSuspenseQueries$1 = useSuspenseQueries;
 
 //#endregion
 export { useSuspenseQueries$1 as t };
-//# sourceMappingURL=useSuspenseQueries-B9xL4GvG.js.map
+//# sourceMappingURL=useSuspenseQueries-DqT8AKu2.mjs.map

package/dist/useSuspenseQueries-DqT8AKu2.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSuspenseQueries-DqT8AKu2.mjs","names":["useSuspenseQueries","original_useSuspenseQueries"],"sources":["../src/useSuspenseQueries.ts"],"sourcesContent":["'use client'\n\nimport {\n  type SuspenseQueriesOptions as original_SuspenseQueriesOptions,\n  type SuspenseQueriesResults as original_SuspenseQueriesResults,\n  useSuspenseQueries as original_useSuspenseQueries,\n} from '@tanstack/react-query'\n\n/**\n * This feature is officially supported in \\@tanstack/react-query@^4.40.0, You can proceed with the migration.\n * @deprecated Use `SuspenseQueriesOptions` from \\@tanstack/react-query@^4.40.0\n * @example\n * ```diff\n * - import type { SuspenseQueriesOptions } from '@suspensive/react-query'\n * + import type { SuspenseQueriesOptions } from '@tanstack/react-query'\n * ```\n */\nexport type SuspenseQueriesOptions<\n  T extends Array<any>,\n  TResult extends Array<any> = [],\n  TDepth extends ReadonlyArray<number> = [],\n> = original_SuspenseQueriesOptions<T, TResult, TDepth>\n\n/**\n * This feature is officially supported in \\@tanstack/react-query@^4.40.0, You can proceed with the migration.\n * @deprecated Use `SuspenseQueriesResults` from \\@tanstack/react-query@^4.40.0\n * @example\n * ```diff\n * - import type { SuspenseQueriesResults } from '@suspensive/react-query'\n * + import type { SuspenseQueriesResults } from '@tanstack/react-query'\n * ```\n */\nexport type SuspenseQueriesResults<\n  T extends Array<any>,\n  TResult extends Array<any> = [],\n  TDepth extends ReadonlyArray<number> = [],\n> = original_SuspenseQueriesResults<T, TResult, TDepth>\n\n/**\n * This feature is officially supported in \\@tanstack/react-query@^4.40.0, You can proceed with the migration.\n * @deprecated Use `useSuspenseQueries` from \\@tanstack/react-query@^4.40.0\n * @example\n * ```diff\n * - import { useSuspenseQueries } from '@suspensive/react-query'\n * + import { useSuspenseQueries } from '@tanstack/react-query'\n * ```\n */\nexport const useSuspenseQueries = original_useSuspenseQueries\n"],"mappings":";;;;;;;;;;;;AA+CA,MAAaA,uBAAqBC"}

package/dist/useSuspenseQueries.d.cts

@@ -1,2 +1,2 @@
-import { n as SuspenseQueriesResults, r as useSuspenseQueries, t as SuspenseQueriesOptions } from "./useSuspenseQueries-B5ixNUu4.cjs";
+import { n as SuspenseQueriesResults, r as useSuspenseQueries, t as SuspenseQueriesOptions } from "./useSuspenseQueries-DNZH-duj.cjs";
 export { SuspenseQueriesOptions, SuspenseQueriesResults, useSuspenseQueries };

package/dist/{useSuspenseQueries.d.ts → useSuspenseQueries.d.mts}

@@ -1,2 +1,2 @@
-import { n as SuspenseQueriesResults, r as useSuspenseQueries, t as SuspenseQueriesOptions } from "./useSuspenseQueries-DWeObNoR.js";
+import { n as SuspenseQueriesResults, r as useSuspenseQueries, t as SuspenseQueriesOptions } from "./useSuspenseQueries-DFtL_xO-.mjs";
 export { SuspenseQueriesOptions, SuspenseQueriesResults, useSuspenseQueries };

package/dist/useSuspenseQueries.mjs

@@ -0,0 +1,6 @@
+'use client';
+
+
+import { t as useSuspenseQueries } from "./useSuspenseQueries-DqT8AKu2.mjs";
+
+export { useSuspenseQueries };

package/dist/{useSuspenseQuery-CDzxlQHt.d.ts → useSuspenseQuery-07kIGch-.d.cts}

@@ -34,4 +34,4 @@ type UseSuspenseQueryResult$1 = UseSuspenseQueryResult;
 declare const useSuspenseQuery$1: typeof useSuspenseQuery;
 //#endregion
 export { UseSuspenseQueryResult$1 as n, useSuspenseQuery$1 as r, UseSuspenseQueryOptions$1 as t };
-//# sourceMappingURL=useSuspenseQuery-CDzxlQHt.d.ts.map
+//# sourceMappingURL=useSuspenseQuery-07kIGch-.d.cts.map

package/dist/{useSuspenseQuery-DKMYNG6m.d.cts.map → useSuspenseQuery-07kIGch-.d.cts.map}

@@ -1 +1 @@
-{"version":3,"file":"useSuspenseQuery-DKMYNG6m.d.cts","names":[],"sources":["../src/useSuspenseQuery.ts"],"sourcesContent":[],"mappings":";;;;;;AAiBA;AAWA;AAWA;;;;;KAtBY,yBAAA,GAA0B;;;;;;;;;;KAW1B,wBAAA,GAAyB;;;;;;;;;;cAWxB,2BAAgB"}
+{"version":3,"file":"useSuspenseQuery-07kIGch-.d.cts","names":[],"sources":["../src/useSuspenseQuery.ts"],"sourcesContent":[],"mappings":";;;;;;AAiBA;AAWA;AAWA;;;;;KAtBY,yBAAA,GAA0B;;;;;;;;;;KAW1B,wBAAA,GAAyB;;;;;;;;;;cAWxB,2BAAgB"}

package/dist/{useSuspenseQuery--Hz9YbA-.js → useSuspenseQuery-BvMsQ1Ho.mjs}

@@ -14,4 +14,4 @@ const useSuspenseQuery$1 = useSuspenseQuery;
 
 //#endregion
 export { useSuspenseQuery$1 as t };
-//# sourceMappingURL=useSuspenseQuery--Hz9YbA-.js.map
+//# sourceMappingURL=useSuspenseQuery-BvMsQ1Ho.mjs.map

package/dist/useSuspenseQuery-BvMsQ1Ho.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSuspenseQuery-BvMsQ1Ho.mjs","names":["useSuspenseQuery","original_useSuspenseQuery"],"sources":["../src/useSuspenseQuery.ts"],"sourcesContent":["'use client'\n\nimport {\n  type UseSuspenseQueryOptions as original_UseSuspenseQueryOptions,\n  type UseSuspenseQueryResult as original_UseSuspenseQueryResult,\n  useSuspenseQuery as original_useSuspenseQuery,\n} from '@tanstack/react-query'\n\n/**\n * This feature is officially supported in \\@tanstack/react-query@^4.40.0, You can proceed with the migration.\n * @deprecated Use `UseSuspenseQueryOptions` from \\@tanstack/react-query@^4.40.0\n * @example\n * ```diff\n * - import type { UseSuspenseQueryOptions } from '@suspensive/react-query'\n * + import type { UseSuspenseQueryOptions } from '@tanstack/react-query'\n * ```\n */\nexport type UseSuspenseQueryOptions = original_UseSuspenseQueryOptions\n\n/**\n * This feature is officially supported in \\@tanstack/react-query@^4.40.0, You can proceed with the migration.\n * @deprecated Use `UseSuspenseQueryResult` from \\@tanstack/react-query@^4.40.0\n * @example\n * ```diff\n * - import type { UseSuspenseQueryResult } from '@suspensive/react-query'\n * + import type { UseSuspenseQueryResult } from '@tanstack/react-query'\n * ```\n */\nexport type UseSuspenseQueryResult = original_UseSuspenseQueryResult\n\n/**\n * This feature is officially supported in \\@tanstack/react-query@^4.40.0, You can proceed with the migration.\n * @deprecated Use `useSuspenseQuery` from \\@tanstack/react-query@^4.40.0\n * @example\n * ```diff\n * - import { useSuspenseQuery } from '@suspensive/react-query'\n * + import { useSuspenseQuery } from '@tanstack/react-query'\n * ```\n */\nexport const useSuspenseQuery = original_useSuspenseQuery\n"],"mappings":";;;;;;;;;;;;AAuCA,MAAaA,qBAAmBC"}

package/dist/{useSuspenseQuery-DKMYNG6m.d.cts → useSuspenseQuery-CMEH7kZ8.d.mts}

@@ -34,4 +34,4 @@ type UseSuspenseQueryResult$1 = UseSuspenseQueryResult;
 declare const useSuspenseQuery$1: typeof useSuspenseQuery;
 //#endregion
 export { UseSuspenseQueryResult$1 as n, useSuspenseQuery$1 as r, UseSuspenseQueryOptions$1 as t };
-//# sourceMappingURL=useSuspenseQuery-DKMYNG6m.d.cts.map
+//# sourceMappingURL=useSuspenseQuery-CMEH7kZ8.d.mts.map

package/dist/useSuspenseQuery-CMEH7kZ8.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSuspenseQuery-CMEH7kZ8.d.mts","names":[],"sources":["../src/useSuspenseQuery.ts"],"sourcesContent":[],"mappings":";;;;;;AAiBA;AAWA;AAWA;;;;;KAtBY,yBAAA,GAA0B;;;;;;;;;;KAW1B,wBAAA,GAAyB;;;;;;;;;;cAWxB,2BAAgB"}

package/dist/useSuspenseQuery.d.cts

@@ -1,2 +1,2 @@
-import { n as UseSuspenseQueryResult, r as useSuspenseQuery, t as UseSuspenseQueryOptions } from "./useSuspenseQuery-DKMYNG6m.cjs";
+import { n as UseSuspenseQueryResult, r as useSuspenseQuery, t as UseSuspenseQueryOptions } from "./useSuspenseQuery-07kIGch-.cjs";
 export { UseSuspenseQueryOptions, UseSuspenseQueryResult, useSuspenseQuery };

package/dist/{useSuspenseQuery.d.ts → useSuspenseQuery.d.mts}

@@ -1,2 +1,2 @@
-import { n as UseSuspenseQueryResult, r as useSuspenseQuery, t as UseSuspenseQueryOptions } from "./useSuspenseQuery-CDzxlQHt.js";
+import { n as UseSuspenseQueryResult, r as useSuspenseQuery, t as UseSuspenseQueryOptions } from "./useSuspenseQuery-CMEH7kZ8.mjs";
 export { UseSuspenseQueryOptions, UseSuspenseQueryResult, useSuspenseQuery };

package/dist/useSuspenseQuery.mjs

@@ -0,0 +1,6 @@
+'use client';
+
+
+import { t as useSuspenseQuery } from "./useSuspenseQuery-BvMsQ1Ho.mjs";
+
+export { useSuspenseQuery };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suspensive/react-query-4",
-  "version": "3.14.0",
+  "version": "3.15.1",
   "description": "Suspensive interfaces for @tanstack/react-query@4",
   "keywords": [
     "suspensive",
@@ -21,8 +21,8 @@
   "exports": {
     ".": {
       "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
       },
       "require": {
         "types": "./dist/index.d.cts",
@@ -32,8 +32,8 @@
     "./package.json": "./package.json"
   },
   "main": "dist/index.cjs",
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.mts",
   "files": [
     "dist",
     "src"

package/src/{QueriesHydrationBoundary.tsx → QueriesHydration.tsx}

@@ -2,7 +2,7 @@ import {
   Hydrate,
   type HydrateProps,
   type OmitKeyof,
-  type QueryClient,
+  QueryClient,
   type QueryOptions,
   type WithRequired,
   dehydrate,
@@ -16,7 +16,7 @@ import { ClientOnly } from './components/ClientOnly'
  * @experimental This component is experimental and may be changed or removed in the future.
  *
  * @description
- * QueriesHydrationBoundary is designed for React Server Components (RSC).
+ * QueriesHydration is designed for React Server Components (RSC).
  * It pre-fetches multiple queries on the server side and automatically hydrates
  * the data to the client, enabling seamless data synchronization between server and client.
  *
@@ -27,32 +27,32 @@ import { ClientOnly } from './components/ClientOnly'
  * ```tsx
  * // app/page.tsx (Server Component)
  * import { Suspense } from 'react'
- * import { QueriesHydrationBoundary } from '@suspensive/react-query'
+ * import { QueriesHydration } from '@suspensive/react-query'
  * import { queryOptions } from '@tanstack/react-query'
  *
- * const userQuery = queryOptions({
- *   queryKey: ['user', id],
- *   queryFn: () => fetchUser(id)
+ * const userQueryOptions = (userId: string) => queryOptions({
+ *   queryKey: ['user', userId],
+ *   queryFn: () => fetchUser(userId)
  * })
  *
- * const postsQuery = queryOptions({
+ * const postsQueryOptions = () => queryOptions({
  *   queryKey: ['posts'],
  *   queryFn: () => fetchPosts()
  * })
  *
- * export default function Page() {
+ * export default function Page({ userId }: { userId: string }) {
  *   return (
  *     <>
  *       <Suspense fallback={<div>Loading user...</div>}>
- *         <QueriesHydrationBoundary queries={[userQuery]}>
+ *         <QueriesHydration queries={[userQueryOptions(userId)]}>
  *           <UserProfile />
- *         </QueriesHydrationBoundary>
+ *         </QueriesHydration>
  *       </Suspense>
  *
  *       <Suspense fallback={<div>Loading posts...</div>}>
- *         <QueriesHydrationBoundary queries={[postsQuery]}>
+ *         <QueriesHydration queries={[postsQueryOptions()]}>
  *           <PostsList />
- *         </QueriesHydrationBoundary>
+ *         </QueriesHydration>
  *       </Suspense>
  *     </>
  *   )
@@ -63,28 +63,28 @@ import { ClientOnly } from './components/ClientOnly'
  * ```tsx
  * // With custom error fallback
  * <Suspense fallback={<div>Loading user...</div>}>
- *   <QueriesHydrationBoundary
- *     queries={[userQuery]}
+ *   <QueriesHydration
+ *     queries={[userQueryOptions(userId)]}
  *     skipSsrOnError={{ fallback: <div>Fetching on client...</div> }}
  *   >
  *     <UserProfile />
- *   </QueriesHydrationBoundary>
+ *   </QueriesHydration>
  * </Suspense>
  * ```
  *
- * @see {@link https://suspensive.org/docs/react-query/QueriesHydrationBoundary Documentation}
+ * @see {@link https://suspensive.org/docs/react-query/QueriesHydration Documentation}
  */
-export async function QueriesHydrationBoundary({
+export async function QueriesHydration({
   queries,
   children,
-  queryClient,
+  queryClient = new QueryClient(),
   skipSsrOnError = true,
   ...props
 }: {
   /**
    * The QueryClient instance to use for fetching queries.
    */
-  queryClient: QueryClient
+  queryClient?: QueryClient
   /**
    * An array of query options to be fetched on the server. Each query must include a `queryKey`.
    */

package/src/index.ts

@@ -1,6 +1,6 @@
 export { infiniteQueryOptions } from './infiniteQueryOptions'
 export type { SelectedInfiniteOptions, UnSelectedInfiniteOptions } from './infiniteQueryOptions'
-export { QueriesHydrationBoundary } from './QueriesHydrationBoundary'
+export { QueriesHydration } from './QueriesHydration'
 export { queryOptions } from './queryOptions'
 export type { SelectedQueryOptions, UnSelectedQueryOptions } from './queryOptions'
 export { usePrefetchInfiniteQuery } from './usePrefetchInfiniteQuery'

package/dist/ClientOnly-DH55RkfW.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ClientOnly-DH55RkfW.js","names":[],"sources":["../src/components/ClientOnly.tsx"],"sourcesContent":["'use client'\n\nimport { useSyncExternalStore } from 'react'\n\nconst useIsClient = () => useSyncExternalStore(emptySubscribe, getSnapshot, getServerSnapshot)\n\nconst emptySubscribe = () => () => {}\nconst getSnapshot = () => true\nconst getServerSnapshot = () => false\n\nexport const ClientOnly = ({ children, fallback }: { children: React.ReactNode; fallback: React.ReactNode }) => (\n  <>{useIsClient() ? children : fallback}</>\n)\n"],"mappings":";;;;AAIA,MAAM,oBAAoB,qBAAqB,gBAAgB,aAAa,kBAAkB;AAE9F,MAAM,6BAA6B;AACnC,MAAM,oBAAoB;AAC1B,MAAM,0BAA0B;AAEhC,MAAa,cAAc,EAAE,UAAU,eACrC,0CAAG,aAAa,GAAG,WAAW,WAAY"}

package/dist/IsFetching-CUZZV-rO.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IsFetching-CUZZV-rO.d.cts","names":[],"sources":["../src/IsFetching.tsx"],"sourcesContent":[],"mappings":";;;;;;;;AAQa,cAAA,UAIZ,EAAA,CAAA;EAAA;CAAA,EAFE,YAEF,GAAA;EAAA,QAAA,EAAA,CAAA,UAAA,EAF0C,UAE1C,CAAA,OAF4D,aAE5D,CAAA,EAAA,GAF+E,SAE/E;MAF0F,kBAAA,CAAA,GAAA,CAAA,OAFhE"}

package/dist/IsFetching-DknEssbS.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"IsFetching-DknEssbS.js","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 * @experimental This is an experimental feature.\n */\nexport const IsFetching = ({\n  children,\n}: QueryFilters & { children: (isFetching: ReturnType<typeof useIsFetching>) => ReactNode }) => (\n  <>{children(useIsFetching())}</>\n)\n"],"mappings":";;;;;;;AAQA,MAAa,cAAc,EACzB,eAEA,0CAAG,SAAS,eAAe,CAAC,GAAI"}

package/dist/IsFetching-NswbU7_3.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IsFetching-NswbU7_3.d.ts","names":[],"sources":["../src/IsFetching.tsx"],"sourcesContent":[],"mappings":";;;;;;;;AAQa,cAAA,UAIZ,EAAA,CAAA;EAAA;CAAA,EAFE,YAEF,GAAA;EAAA,QAAA,EAAA,CAAA,UAAA,EAF0C,UAE1C,CAAA,OAF4D,aAE5D,CAAA,EAAA,GAF+E,SAE/E;MAF0F,kBAAA,CAAA,GAAA,CAAA,OAFhE"}

package/dist/IsFetching.d.ts

@@ -1,2 +0,0 @@
-import { t as IsFetching } from "./IsFetching-NswbU7_3.js";
-export { IsFetching };

package/dist/IsFetching.js

@@ -1,6 +0,0 @@
-'use client';
-
-
-import { t as IsFetching } from "./IsFetching-DknEssbS.js";
-
-export { IsFetching };

package/dist/Mutation-BXxdgixl.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Mutation-BXxdgixl.d.ts","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-ChNqI8IT.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Mutation-ChNqI8IT.js","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.d.ts

@@ -1,2 +0,0 @@
-import { t as Mutation } from "./Mutation-BXxdgixl.js";
-export { Mutation };

package/dist/Mutation.js

@@ -1,7 +0,0 @@
-'use client';
-
-
-import "./objectWithoutProperties-hKN8srXd.js";
-import { t as Mutation } from "./Mutation-ChNqI8IT.js";
-
-export { Mutation };

package/dist/PrefetchInfiniteQuery-DUo4NQFu.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"PrefetchInfiniteQuery-DUo4NQFu.js","names":[],"sources":["../src/PrefetchInfiniteQuery.tsx"],"sourcesContent":["'use client'\n\nimport { type FetchInfiniteQueryOptions, type QueryKey } from '@tanstack/react-query'\nimport { usePrefetchInfiniteQuery } from './usePrefetchInfiniteQuery'\n\n/**\n * A component that allows you to use `usePrefetchInfiniteQuery` in JSX, avoiding the limitations of React hooks.\n * @see {@link https://suspensive.org/docs/react-query/PrefetchInfiniteQuery Suspensive Docs}\n * @example\n * ```tsx\n * <PrefetchInfiniteQuery queryKey={['queryKey']} queryFn={queryFn} />\n * ```\n */\nexport function PrefetchInfiniteQuery<\n  TQueryFnData = unknown,\n  TError = unknown,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>) {\n  usePrefetchInfiniteQuery(options)\n  return <></>\n}\n"],"mappings":";;;;;;;;;;;;AAaA,SAAgB,sBAKd,SAA4E;AAC5E,0BAAyB,QAAQ;AACjC,QAAO,iCAAK"}

package/dist/PrefetchInfiniteQuery-DeqbqFn3.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PrefetchInfiniteQuery-DeqbqFn3.d.cts","names":[],"sources":["../src/PrefetchInfiniteQuery.tsx"],"sourcesContent":[],"mappings":";;;;;;;;AAaA;;;;;AAKqC,iBALrB,qBAKqB,CAAA,eAAA,OAAA,EAAA,SAAA,OAAA,EAAA,QAF3B,YAE2B,EAAA,kBADjB,QACiB,GADN,QACM,CAAA,CAAA,OAAA,EAA1B,yBAA0B,CAAA,YAAA,EAAc,MAAd,EAAsB,KAAtB,EAA6B,SAA7B,CAAA,CAAA,EAAuC,kBAAA,CAAA,GAAA,CAAA,OAAvC"}

package/dist/PrefetchInfiniteQuery-XgWIoyZf.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PrefetchInfiniteQuery-XgWIoyZf.d.ts","names":[],"sources":["../src/PrefetchInfiniteQuery.tsx"],"sourcesContent":[],"mappings":";;;;;;;;AAaA;;;;;AAKqC,iBALrB,qBAKqB,CAAA,eAAA,OAAA,EAAA,SAAA,OAAA,EAAA,QAF3B,YAE2B,EAAA,kBADjB,QACiB,GADN,QACM,CAAA,CAAA,OAAA,EAA1B,yBAA0B,CAAA,YAAA,EAAc,MAAd,EAAsB,KAAtB,EAA6B,SAA7B,CAAA,CAAA,EAAuC,kBAAA,CAAA,GAAA,CAAA,OAAvC"}

package/dist/PrefetchInfiniteQuery.js

@@ -1,7 +0,0 @@
-'use client';
-
-
-import "./usePrefetchInfiniteQuery-K7YH3Qy-.js";
-import { t as PrefetchInfiniteQuery } from "./PrefetchInfiniteQuery-DUo4NQFu.js";
-
-export { PrefetchInfiniteQuery };

package/dist/PrefetchQuery-2dr_x_It.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PrefetchQuery-2dr_x_It.d.ts","names":[],"sources":["../src/PrefetchQuery.tsx"],"sourcesContent":[],"mappings":";;;;;;;;AAaA;;;;;AAK6B,iBALb,aAKa,CAAA,eAAA,OAAA,EAAA,SAAA,OAAA,EAAA,QAFnB,YAEmB,EAAA,kBADT,QACS,GADE,QACF,CAAA,CAAA,OAAA,EAAlB,iBAAkB,CAAA,YAAA,EAAc,MAAd,EAAsB,KAAtB,EAA6B,SAA7B,CAAA,CAAA,EAAuC,kBAAA,CAAA,GAAA,CAAA,OAAvC"}

package/dist/PrefetchQuery-DLH4RnOr.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PrefetchQuery-DLH4RnOr.d.cts","names":[],"sources":["../src/PrefetchQuery.tsx"],"sourcesContent":[],"mappings":";;;;;;;;AAaA;;;;;AAK6B,iBALb,aAKa,CAAA,eAAA,OAAA,EAAA,SAAA,OAAA,EAAA,QAFnB,YAEmB,EAAA,kBADT,QACS,GADE,QACF,CAAA,CAAA,OAAA,EAAlB,iBAAkB,CAAA,YAAA,EAAc,MAAd,EAAsB,KAAtB,EAA6B,SAA7B,CAAA,CAAA,EAAuC,kBAAA,CAAA,GAAA,CAAA,OAAvC"}

package/dist/PrefetchQuery-DsA87P_Q.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"PrefetchQuery-DsA87P_Q.js","names":[],"sources":["../src/PrefetchQuery.tsx"],"sourcesContent":["'use client'\n\nimport { type FetchQueryOptions, type QueryKey } from '@tanstack/react-query'\nimport { usePrefetchQuery } from './usePrefetchQuery'\n\n/**\n * A component that allows you to use usePrefetchQuery in JSX, avoiding the limitations of React hooks.\n * @see {@link https://suspensive.org/docs/react-query/PrefetchQuery Suspensive Docs}\n * @example\n * ```tsx\n * <PrefetchQuery queryKey={['queryKey']} queryFn={queryFn} />\n * ```\n */\nexport function PrefetchQuery<\n  TQueryFnData = unknown,\n  TError = unknown,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>) {\n  usePrefetchQuery(options)\n  return <></>\n}\n"],"mappings":";;;;;;;;;;;;AAaA,SAAgB,cAKd,SAAoE;AACpE,kBAAiB,QAAQ;AACzB,QAAO,iCAAK"}

package/dist/PrefetchQuery.d.ts

@@ -1,2 +0,0 @@
-import { t as PrefetchQuery } from "./PrefetchQuery-2dr_x_It.js";
-export { PrefetchQuery };

package/dist/PrefetchQuery.js

@@ -1,7 +0,0 @@
-'use client';
-
-
-import "./usePrefetchQuery-HaCGXPNG.js";
-import { t as PrefetchQuery } from "./PrefetchQuery-DsA87P_Q.js";
-
-export { PrefetchQuery };

package/dist/QueriesHydrationBoundary-B0-SThJ9.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueriesHydrationBoundary-B0-SThJ9.js","names":[],"sources":["../src/QueriesHydrationBoundary.tsx"],"sourcesContent":["import {\n  Hydrate,\n  type HydrateProps,\n  type OmitKeyof,\n  type QueryClient,\n  type QueryOptions,\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 * QueriesHydrationBoundary 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 { QueriesHydrationBoundary } from '@suspensive/react-query'\n * import { queryOptions } from '@tanstack/react-query'\n *\n * const userQuery = queryOptions({\n *   queryKey: ['user', id],\n *   queryFn: () => fetchUser(id)\n * })\n *\n * const postsQuery = queryOptions({\n *   queryKey: ['posts'],\n *   queryFn: () => fetchPosts()\n * })\n *\n * export default function Page() {\n *   return (\n *     <>\n *       <Suspense fallback={<div>Loading user...</div>}>\n *         <QueriesHydrationBoundary queries={[userQuery]}>\n *           <UserProfile />\n *         </QueriesHydrationBoundary>\n *       </Suspense>\n *\n *       <Suspense fallback={<div>Loading posts...</div>}>\n *         <QueriesHydrationBoundary queries={[postsQuery]}>\n *           <PostsList />\n *         </QueriesHydrationBoundary>\n *       </Suspense>\n *     </>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * // With custom error fallback\n * <Suspense fallback={<div>Loading user...</div>}>\n *   <QueriesHydrationBoundary\n *     queries={[userQuery]}\n *     skipSsrOnError={{ fallback: <div>Fetching on client...</div> }}\n *   >\n *     <UserProfile />\n *   </QueriesHydrationBoundary>\n * </Suspense>\n * ```\n *\n * @see {@link https://suspensive.org/docs/react-query/QueriesHydrationBoundary Documentation}\n */\nexport async function QueriesHydrationBoundary({\n  queries,\n  children,\n  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 to be fetched on the server. Each query must include a `queryKey`.\n   */\n  queries: WithRequired<QueryOptions<any, any, any, any>, 'queryKey'>[]\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(queries.map((query) => queryClient.ensureQueryData(query)))\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6EE;CACA;CACA;CACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAJF,SAAsB,yBAAyB;;;;gEA0BT;MA1BS,EAC7C,SACA,UACA,aACA,iBAAiB,eACd;AAsBH,MAAI;AACF,SAAM,QAAQ,IAAI,QAAQ,KAAK,UAAU,YAAY,gBAAgB,MAAM,CAAC,CAAC;oBACvE;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/QueriesHydrationBoundary-CCKy06Iw.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueriesHydrationBoundary-CCKy06Iw.cjs","names":["ClientOnly","Hydrate"],"sources":["../src/QueriesHydrationBoundary.tsx"],"sourcesContent":["import {\n  Hydrate,\n  type HydrateProps,\n  type OmitKeyof,\n  type QueryClient,\n  type QueryOptions,\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 * QueriesHydrationBoundary 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 { QueriesHydrationBoundary } from '@suspensive/react-query'\n * import { queryOptions } from '@tanstack/react-query'\n *\n * const userQuery = queryOptions({\n *   queryKey: ['user', id],\n *   queryFn: () => fetchUser(id)\n * })\n *\n * const postsQuery = queryOptions({\n *   queryKey: ['posts'],\n *   queryFn: () => fetchPosts()\n * })\n *\n * export default function Page() {\n *   return (\n *     <>\n *       <Suspense fallback={<div>Loading user...</div>}>\n *         <QueriesHydrationBoundary queries={[userQuery]}>\n *           <UserProfile />\n *         </QueriesHydrationBoundary>\n *       </Suspense>\n *\n *       <Suspense fallback={<div>Loading posts...</div>}>\n *         <QueriesHydrationBoundary queries={[postsQuery]}>\n *           <PostsList />\n *         </QueriesHydrationBoundary>\n *       </Suspense>\n *     </>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * // With custom error fallback\n * <Suspense fallback={<div>Loading user...</div>}>\n *   <QueriesHydrationBoundary\n *     queries={[userQuery]}\n *     skipSsrOnError={{ fallback: <div>Fetching on client...</div> }}\n *   >\n *     <UserProfile />\n *   </QueriesHydrationBoundary>\n * </Suspense>\n * ```\n *\n * @see {@link https://suspensive.org/docs/react-query/QueriesHydrationBoundary Documentation}\n */\nexport async function QueriesHydrationBoundary({\n  queries,\n  children,\n  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 to be fetched on the server. Each query must include a `queryKey`.\n   */\n  queries: WithRequired<QueryOptions<any, any, any, any>, 'queryKey'>[]\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(queries.map((query) => queryClient.ensureQueryData(query)))\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6EE;CACA;CACA;CACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAJF,SAAsB,yBAAyB;;;;gEA0BT;MA1BS,EAC7C,SACA,UACA,aACA,iBAAiB,eACd;AAsBH,MAAI;AACF,SAAM,QAAQ,IAAI,QAAQ,KAAK,UAAU,YAAY,gBAAgB,MAAM,CAAC,CAAC;oBACvE;AACN,OAAI,eACF,QACE,2CAACA;IAAW,UAAU,mBAAmB,OAAO,SAAY,eAAe;IAAW;KAAsB;;AAIlH,SACE,2CAACC,kEAAY;GAAO,6CAAiB,YAAY;GAC9C;KACO"}

package/dist/QueriesHydrationBoundary-YPalBVSC.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueriesHydrationBoundary-YPalBVSC.d.cts","names":[],"sources":["../src/QueriesHydrationBoundary.tsx"],"sourcesContent":[],"mappings":";;;;;;;;;AA4EA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAsB,wBAAA;;;;;;;;;;eAUP;;;;WAIJ,aAAa;;;;;;;;cAUN;;IAEd,UAAU,yBAAsB,QAAA,kBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/QueriesHydrationBoundary-ltKHcdNU.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueriesHydrationBoundary-ltKHcdNU.d.ts","names":[],"sources":["../src/QueriesHydrationBoundary.tsx"],"sourcesContent":[],"mappings":";;;;;;;;;AA4EA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAsB,wBAAA;;;;;;;;;;eAUP;;;;WAIJ,aAAa;;;;;;;;cAUN;;IAEd,UAAU,yBAAsB,QAAA,kBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/QueriesHydrationBoundary.cjs

@@ -1,5 +0,0 @@
-require('./objectWithoutProperties-wiuk62IC.cjs');
-require('./ClientOnly-Dvf8t__-.cjs');
-const require_QueriesHydrationBoundary = require('./QueriesHydrationBoundary-CCKy06Iw.cjs');
-
-exports.QueriesHydrationBoundary = require_QueriesHydrationBoundary.QueriesHydrationBoundary;

package/dist/QueriesHydrationBoundary.d.cts

@@ -1,2 +0,0 @@
-import { t as QueriesHydrationBoundary } from "./QueriesHydrationBoundary-YPalBVSC.cjs";
-export { QueriesHydrationBoundary };

package/dist/QueriesHydrationBoundary.d.ts

@@ -1,2 +0,0 @@
-import { t as QueriesHydrationBoundary } from "./QueriesHydrationBoundary-ltKHcdNU.js";
-export { QueriesHydrationBoundary };

package/dist/QueriesHydrationBoundary.js

@@ -1,5 +0,0 @@
-import "./objectWithoutProperties-hKN8srXd.js";
-import "./ClientOnly-DH55RkfW.js";
-import { t as QueriesHydrationBoundary } from "./QueriesHydrationBoundary-B0-SThJ9.js";
-
-export { QueriesHydrationBoundary };

package/dist/QueryClientConsumer-BEhkrgN2.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueryClientConsumer-BEhkrgN2.d.cts","names":[],"sources":["../src/QueryClientConsumer.tsx"],"sourcesContent":[],"mappings":";;;;;;;;AAQgB,iBAAA,mBAAA,CAAmB;EAAA,QAAA;EAAA;CAAA,EAAA;EAAA,QAAA,EAAA,CAAA,WAAA,EAIT,WAJS,EAAA,GAIO,SAJP;SACjC,CAAA,EAIU,OAJV,CAIkB,WAJlB,GAAA,SAAA,CAAA;IAKD,kBAAA,CAAA,GAAA,CAAA,OAJC"}

package/dist/QueryClientConsumer-CXreZ3Qo.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueryClientConsumer-CXreZ3Qo.js","names":[],"sources":["../src/QueryClientConsumer.tsx"],"sourcesContent":["'use client'\n\nimport { type QueryClient, useQueryClient } from '@tanstack/react-query'\nimport type { Context, ReactNode } from 'react'\n\n/**\n * @experimental This is experimental feature.\n */\nexport function QueryClientConsumer({\n  children,\n  context,\n}: {\n  children: (queryClient: QueryClient) => ReactNode\n  context?: Context<QueryClient | undefined>\n}) {\n  return <>{children(useQueryClient({ context: context as any }))}</>\n}\n"],"mappings":";;;;;;;AAQA,SAAgB,oBAAoB,EAClC,UACA,WAIC;AACD,QAAO,0CAAG,SAAS,eAAe,EAAW,SAAgB,CAAC,CAAC,GAAI"}

package/dist/QueryClientConsumer-CbHc2ncp.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueryClientConsumer-CbHc2ncp.d.ts","names":[],"sources":["../src/QueryClientConsumer.tsx"],"sourcesContent":[],"mappings":";;;;;;;;AAQgB,iBAAA,mBAAA,CAAmB;EAAA,QAAA;EAAA;CAAA,EAAA;EAAA,QAAA,EAAA,CAAA,WAAA,EAIT,WAJS,EAAA,GAIO,SAJP;SACjC,CAAA,EAIU,OAJV,CAIkB,WAJlB,GAAA,SAAA,CAAA;IAKD,kBAAA,CAAA,GAAA,CAAA,OAJC"}

package/dist/SuspenseInfiniteQuery-493uCstF.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SuspenseInfiniteQuery-493uCstF.d.cts","names":[],"sources":["../src/SuspenseInfiniteQuery.tsx"],"sourcesContent":[],"mappings":";;;;;;;;;;AAqBA;;;;;;;;;;;;;AASoB,cATP,qBASO,EAAA,CAAA,eAAA,OAAA,EAAA,SAAA,OAAA,EAAA,QANV,YAMU,EAAA,kBALA,QAKA,GALW,QAKX,CAAA,CAAA;EAAA,QAAA;EAAA,GAAA;CAAA,EADjB,+BACiB,CADe,YACf,EAD6B,MAC7B,EADqC,KACrC,EAD4C,SAC5C,CAAA,GAAA;UAAkD,EAAA,CAAA,KAAA,EAAlD,8BAAkD,CAAnB,KAAmB,EAAZ,MAAY,CAAA,EAAA,GAAA,SAAA;MACrE,kBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/SuspenseInfiniteQuery-aUCIM1wn.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SuspenseInfiniteQuery-aUCIM1wn.d.ts","names":[],"sources":["../src/SuspenseInfiniteQuery.tsx"],"sourcesContent":[],"mappings":";;;;;;;;;;AAqBA;;;;;;;;;;;;;AASoB,cATP,qBASO,EAAA,CAAA,eAAA,OAAA,EAAA,SAAA,OAAA,EAAA,QANV,YAMU,EAAA,kBALA,QAKA,GALW,QAKX,CAAA,CAAA;EAAA,QAAA;EAAA,GAAA;CAAA,EADjB,+BACiB,CADe,YACf,EAD6B,MAC7B,EADqC,KACrC,EAD4C,SAC5C,CAAA,GAAA;UAAkD,EAAA,CAAA,KAAA,EAAlD,8BAAkD,CAAnB,KAAmB,EAAZ,MAAY,CAAA,EAAA,GAAA,SAAA;MACrE,kBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/SuspenseInfiniteQuery-d5K3FWJK.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SuspenseInfiniteQuery-d5K3FWJK.js","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.d.ts

@@ -1,3 +0,0 @@
-import "./useSuspenseInfiniteQuery-Bb0CuB92.js";
-import { t as SuspenseInfiniteQuery } from "./SuspenseInfiniteQuery-aUCIM1wn.js";
-export { SuspenseInfiniteQuery };

package/dist/SuspenseInfiniteQuery.js

@@ -1,7 +0,0 @@
-'use client';
-
-
-import "./objectWithoutProperties-hKN8srXd.js";
-import { t as SuspenseInfiniteQuery } from "./SuspenseInfiniteQuery-d5K3FWJK.js";
-
-export { SuspenseInfiniteQuery };

package/dist/SuspenseQueries-BdrwpuQr.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SuspenseQueries-BdrwpuQr.js","names":[],"sources":["../src/SuspenseQueries.tsx"],"sourcesContent":["'use client'\n\nimport { type SuspenseQueriesOptions, type SuspenseQueriesResults, useSuspenseQueries } from '@tanstack/react-query'\nimport type { ReactNode } from 'react'\n\n/**\n * We provide these components to clearly express what causes suspense at the same depth.\n * `<SuspenseQueries/>` serves to make `useSuspenseQueries` easier to use in jsx.\n * @see {@link https://suspensive.org/docs/react-query/SuspenseQueries Suspensive Docs}\n * @example\n * ```tsx\n * import { SuspenseQueries } from '@suspensive/react-query'\n *\n * <SuspenseQueries queries={[firstQueryOptions(), secondQueryOptions()]}>\n *   {([{ data: firstQueryData }, { data: secondQueryData }]) => {\n *     return <></>\n *   }}\n * </SuspenseQueries>\n * ```\n */\nexport function SuspenseQueries<T extends any[]>({\n  children,\n  queries,\n}: {\n  queries: readonly [...SuspenseQueriesOptions<T>]\n  children: (queries: SuspenseQueriesResults<T>) => ReactNode\n}) {\n  return <>{children(useSuspenseQueries({ queries }))}</>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,gBAAiC,EAC/C,UACA,WAIC;AACD,QAAO,0CAAG,SAAS,mBAAmB,EAAE,SAAS,CAAC,CAAC,GAAI"}

package/dist/SuspenseQueries-U51bGPhv.d.ts.map

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

package/dist/SuspenseQueries.d.ts

@@ -1,2 +0,0 @@
-import { t as SuspenseQueries } from "./SuspenseQueries-U51bGPhv.js";
-export { SuspenseQueries };

package/dist/SuspenseQueries.js

@@ -1,6 +0,0 @@
-'use client';
-
-
-import { t as SuspenseQueries } from "./SuspenseQueries-BdrwpuQr.js";
-
-export { SuspenseQueries };

package/dist/SuspenseQuery-Bi9HwyhA.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SuspenseQuery-Bi9HwyhA.d.ts","names":[],"sources":["../src/SuspenseQuery.tsx"],"sourcesContent":[],"mappings":";;;;;;;;;AA0BA;;;;;;;;;;;;;AAS0B,cATb,aASa,EAAA,CAAA,eAAA,OAAA,EAAA,SAAA,OAAA,EAAA,QANhB,YAMgB,EAAA,kBALN,QAKM,GALK,QAKL,CAAA,CAAA;EAAA,QAAA;EAAA,GAAA;CAAA,EADvB,uBACuB,CADC,YACD,EADe,MACf,EADuB,KACvB,EAD8B,SAC9B,CAAA,GAAA;UAA0C,EAAA,CAAA,WAAA,EAA1C,sBAA0C,CAAnB,KAAmB,EAAZ,MAAY,CAAA,EAAA,GAAA,SAAA;MACnE,kBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/SuspenseQuery-D0Vt5tKg.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SuspenseQuery-D0Vt5tKg.d.cts","names":[],"sources":["../src/SuspenseQuery.tsx"],"sourcesContent":[],"mappings":";;;;;;;;;AA0BA;;;;;;;;;;;;;AAS0B,cATb,aASa,EAAA,CAAA,eAAA,OAAA,EAAA,SAAA,OAAA,EAAA,QANhB,YAMgB,EAAA,kBALN,QAKM,GALK,QAKL,CAAA,CAAA;EAAA,QAAA;EAAA,GAAA;CAAA,EADvB,uBACuB,CADC,YACD,EADe,MACf,EADuB,KACvB,EAD8B,SAC9B,CAAA,GAAA;UAA0C,EAAA,CAAA,WAAA,EAA1C,sBAA0C,CAAnB,KAAmB,EAAZ,MAAY,CAAA,EAAA,GAAA,SAAA;MACnE,kBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/SuspenseQuery-Owa-DnJP.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SuspenseQuery-Owa-DnJP.js","names":[],"sources":["../src/SuspenseQuery.tsx"],"sourcesContent":["'use client'\n\nimport {\n  type QueryKey,\n  type UseSuspenseQueryOptions,\n  type UseSuspenseQueryResult,\n  useSuspenseQuery,\n} from '@tanstack/react-query'\nimport type { ReactNode } from 'react'\n\n/**\n * We provide these components to clearly express what causes suspense at the same depth.\n * `<SuspenseQuery/>` serves to make `useSuspenseQuery` easier to use in jsx.\n * @see {@link https://suspensive.org/docs/react-query/SuspenseQuery Suspensive Docs}\n * @example\n * ```tsx\n * import { SuspenseQuery } from '@suspensive/react-query'\n *\n * // You can use QueryOptions as props.\n * <SuspenseQuery {...queryOptions()}>\n *   {({ data, isLoading }) => {\n *     return <></>\n *   }\n * </SuspenseQuery>\n * ```\n */\nexport const SuspenseQuery = <\n  TQueryFnData = unknown,\n  TError = unknown,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>({\n  children,\n  ...options\n}: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {\n  children: (queryResult: UseSuspenseQueryResult<TData, TError>) => ReactNode\n}) => <>{children(useSuspenseQuery(options))}</>\n"],"mappings":";;;;;mBAgCE;;;;;;;;;;;;;;;;;AANF,MAAa,iBAKX,SAKI;KALJ,EACA;AAII,kDAAG,SAAS,2DAAyB,CAAC,GAAI"}

package/dist/SuspenseQuery.d.ts

@@ -1,2 +0,0 @@
-import { t as SuspenseQuery } from "./SuspenseQuery-Bi9HwyhA.js";
-export { SuspenseQuery };

package/dist/SuspenseQuery.js

@@ -1,7 +0,0 @@
-'use client';
-
-
-import "./objectWithoutProperties-hKN8srXd.js";
-import { t as SuspenseQuery } from "./SuspenseQuery-Owa-DnJP.js";
-
-export { SuspenseQuery };

package/dist/components/ClientOnly.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ClientOnly.d.ts","names":[],"sources":["../../src/components/ClientOnly.tsx"],"sourcesContent":[],"mappings":";;;cAUa;;;AAAb;YAA+D,KAAA,CAAM;YAAqB,KAAA,CAAM;AAAhG,CAAA,EAAA,GAA2G,kBAAA,CAAA,GAAA,CAAA,OAE1G"}

package/dist/components/ClientOnly.js

@@ -1,6 +0,0 @@
-'use client';
-
-
-import { t as ClientOnly } from "../ClientOnly-DH55RkfW.js";
-
-export { ClientOnly };