@suspensive/react-query-4 3.19.5 → 4.0.0-next.0

package/dist/objectSpread2-DUnXKO-7.cjs

@@ -0,0 +1,73 @@
+
+//#region \0@oxc-project+runtime@0.101.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+		return typeof o$1;
+	} : function(o$1) {
+		return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+	}, _typeof(o);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.101.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.101.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.101.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.101.0/helpers/objectSpread2.js
+function ownKeys(e, r) {
+	var t = Object.keys(e);
+	if (Object.getOwnPropertySymbols) {
+		var o = Object.getOwnPropertySymbols(e);
+		r && (o = o.filter(function(r$1) {
+			return Object.getOwnPropertyDescriptor(e, r$1).enumerable;
+		})), t.push.apply(t, o);
+	}
+	return t;
+}
+function _objectSpread2(e) {
+	for (var r = 1; r < arguments.length; r++) {
+		var t = null != arguments[r] ? arguments[r] : {};
+		r % 2 ? ownKeys(Object(t), !0).forEach(function(r$1) {
+			_defineProperty(e, r$1, t[r$1]);
+		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r$1) {
+			Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t, r$1));
+		});
+	}
+	return e;
+}
+
+//#endregion
+Object.defineProperty(exports, '_objectSpread2', {
+  enumerable: true,
+  get: function () {
+    return _objectSpread2;
+  }
+});

package/dist/objectWithoutProperties-BqF6LYLG.cjs

@@ -0,0 +1,31 @@
+
+//#region \0@oxc-project+runtime@0.101.0/helpers/objectWithoutPropertiesLoose.js
+function _objectWithoutPropertiesLoose(r, e) {
+	if (null == r) return {};
+	var t = {};
+	for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+		if (e.includes(n)) continue;
+		t[n] = r[n];
+	}
+	return t;
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.101.0/helpers/objectWithoutProperties.js
+function _objectWithoutProperties(e, t) {
+	if (null == e) return {};
+	var o, r, i = _objectWithoutPropertiesLoose(e, t);
+	if (Object.getOwnPropertySymbols) {
+		var s = Object.getOwnPropertySymbols(e);
+		for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+	}
+	return i;
+}
+
+//#endregion
+Object.defineProperty(exports, '_objectWithoutProperties', {
+  enumerable: true,
+  get: function () {
+    return _objectWithoutProperties;
+  }
+});

package/dist/objectWithoutProperties-DB_n2qVi.mjs

@@ -0,0 +1,25 @@
+//#region \0@oxc-project+runtime@0.101.0/helpers/objectWithoutPropertiesLoose.js
+function _objectWithoutPropertiesLoose(r, e) {
+	if (null == r) return {};
+	var t = {};
+	for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+		if (e.includes(n)) continue;
+		t[n] = r[n];
+	}
+	return t;
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.101.0/helpers/objectWithoutProperties.js
+function _objectWithoutProperties(e, t) {
+	if (null == e) return {};
+	var o, r, i = _objectWithoutPropertiesLoose(e, t);
+	if (Object.getOwnPropertySymbols) {
+		var s = Object.getOwnPropertySymbols(e);
+		for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+	}
+	return i;
+}
+
+//#endregion
+export { _objectWithoutProperties as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suspensive/react-query-4",
-  "version": "3.19.5",
+  "version": "4.0.0-next.0",
   "description": "Suspensive interfaces for @tanstack/react-query@4",
   "keywords": [
     "suspensive",
@@ -40,14 +40,14 @@
   ],
   "devDependencies": {
     "@tanstack/react-query": "4.43.0",
-    "@types/react": "^19.2.14",
-    "react": "^19.2.4",
+    "@types/react": "^19.2.7",
+    "react": "^19.2.3",
     "@suspensive/eslint-config": "0.0.1",
     "@suspensive/tsconfig": "0.0.0-development",
     "@suspensive/tsdown": "0.0.0"
   },
   "peerDependencies": {
-    "@tanstack/react-query": "*",
+    "@tanstack/react-query": "^4",
     "react": "^18 || ^19"
   },
   "publishConfig": {

package/src/IsFetching.tsx

@@ -1,14 +1,13 @@
 'use client'
+
 import { type QueryFilters, useIsFetching } from '@tanstack/react-query'
 import type { ReactNode } from 'react'
 
 /**
- * Renders the current fetching count for queries that match the given filters.
  * @experimental This is an experimental feature.
  */
 export const IsFetching = ({
   children,
-  ...filter
 }: QueryFilters & { children: (isFetching: ReturnType<typeof useIsFetching>) => ReactNode }) => (
-  <>{children(useIsFetching(filter))}</>
+  <>{children(useIsFetching())}</>
 )

package/src/Mutation.tsx

@@ -1,4 +1,5 @@
 'use client'
+
 import { type UseMutationOptions, type UseMutationResult, useMutation } from '@tanstack/react-query'
 import type { ReactNode } from 'react'
 

package/src/PrefetchInfiniteQuery.tsx

@@ -1,6 +1,11 @@
 'use client'
-import { type FetchInfiniteQueryOptions, type QueryKey } from '@tanstack/react-query'
-import { usePrefetchInfiniteQuery } from './usePrefetchInfiniteQuery'
+
+import {
+  type FetchInfiniteQueryOptions,
+  type QueryKey,
+  type WithRequired,
+  usePrefetchInfiniteQuery,
+} from '@tanstack/react-query'
 
 /**
  * A component that allows you to use `usePrefetchInfiniteQuery` in JSX, avoiding the limitations of React hooks.
@@ -15,7 +20,7 @@ export function PrefetchInfiniteQuery<
   TError = unknown,
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
->(options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>) {
+>(options: WithRequired<FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey'>) {
   usePrefetchInfiniteQuery(options)
   return <></>
 }

package/src/PrefetchQuery.tsx

@@ -1,6 +1,6 @@
 'use client'
-import { type FetchQueryOptions, type QueryKey } from '@tanstack/react-query'
-import { usePrefetchQuery } from './usePrefetchQuery'
+
+import { type FetchQueryOptions, type QueryKey, type WithRequired, usePrefetchQuery } from '@tanstack/react-query'
 
 /**
  * A component that allows you to use usePrefetchQuery in JSX, avoiding the limitations of React hooks.
@@ -15,7 +15,7 @@ export function PrefetchQuery<
   TError = unknown,
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
->(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>) {
+>(options: WithRequired<FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey'>) {
   usePrefetchQuery(options)
   return <></>
 }

package/src/QueryClientConsumer.tsx

@@ -1,4 +1,5 @@
 'use client'
+
 import { type QueryClient, useQueryClient } from '@tanstack/react-query'
 import type { Context, ReactNode } from 'react'
 

package/src/SuspenseInfiniteQuery.tsx

@@ -1,7 +1,28 @@
 'use client'
-import { type QueryKey, type UseSuspenseInfiniteQueryResult, useSuspenseInfiniteQuery } from '@tanstack/react-query'
+
+import {
+  type OmitKeyof,
+  type QueryKey,
+  type UseInfiniteQueryOptions,
+  type UseSuspenseInfiniteQueryResult,
+  type WithRequired,
+  useSuspenseInfiniteQuery,
+} from '@tanstack/react-query'
 import type { ReactNode } from 'react'
-import { type UseSuspenseInfiniteQueryOptions } from './useSuspenseInfiniteQuery'
+
+type UseSuspenseInfiniteQueryOptions<
+  TQueryFnData = unknown,
+  TError = unknown,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+> = WithRequired<
+  OmitKeyof<
+    UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>,
+    'suspense' | 'useErrorBoundary' | 'enabled' | 'placeholderData' | 'networkMode' | 'initialData'
+  >,
+  'queryKey'
+>
+
 /**
  * We provide these components to clearly express what causes suspense at the same depth.
  * `<SuspenseInfiniteQuery/>` serves to make `useSuspenseInfiniteQuery` easier to use in jsx.

package/src/SuspenseQueries.tsx

@@ -1,4 +1,5 @@
 'use client'
+
 import { type SuspenseQueriesOptions, type SuspenseQueriesResults, useSuspenseQueries } from '@tanstack/react-query'
 import type { ReactNode } from 'react'
 

package/src/SuspenseQuery.tsx

@@ -1,4 +1,5 @@
 'use client'
+
 import {
   type QueryKey,
   type UseSuspenseQueryOptions,

package/src/components/ClientOnly.tsx

@@ -1,4 +1,5 @@
 'use client'
+
 import { useSyncExternalStore } from 'react'
 
 const useIsClient = () => useSyncExternalStore(emptySubscribe, getSnapshot, getServerSnapshot)

package/src/createGetQueryClient.spec.tsx

@@ -1,32 +1,45 @@
 import { QueryClient } from '@tanstack/react-query'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { createGetQueryClient } from './createGetQueryClient'
 
-const mock = { isServer: false }
-
-vi.mock(import('@tanstack/react-query'), async (importOriginal) => {
-  const actual = await importOriginal()
+// Mock isServer from @tanstack/react-query
+vi.mock('@tanstack/react-query', async () => {
+  const actual = await vi.importActual('@tanstack/react-query')
   return {
     ...actual,
-    get isServer() {
-      return mock.isServer
-    },
+    isServer: false,
   }
 })
 
-describe('getQueryClient (browser environment)', () => {
+describe('getQueryClient', () => {
   beforeEach(() => {
-    mock.isServer = false
+    // Reset modules to clear the browserQueryClient singleton
+    vi.resetModules()
   })
 
-  it('should return the same QueryClient instance on multiple calls', () => {
+  it('should return a QueryClient instance', async () => {
+    const { createGetQueryClient } = await import('./createGetQueryClient')
     const { getQueryClient } = createGetQueryClient()
-    expect(getQueryClient()).toBe(getQueryClient())
+    const queryClient = getQueryClient()
+    expect(queryClient).toBeInstanceOf(QueryClient)
   })
 
-  it('should apply config', () => {
+  it('should return the same QueryClient instance on multiple calls in browser environment', async () => {
+    const { createGetQueryClient } = await import('./createGetQueryClient')
+    const { getQueryClient } = createGetQueryClient()
+    const queryClient1 = getQueryClient()
+    const queryClient2 = getQueryClient()
+    expect(queryClient1).toBe(queryClient2)
+  })
+
+  it('should apply config when creating initial QueryClient', async () => {
+    const { createGetQueryClient } = await import('./createGetQueryClient')
     const { getQueryClient } = createGetQueryClient({
-      defaultOptions: { queries: { staleTime: 5000, retry: 3 } },
+      defaultOptions: {
+        queries: {
+          staleTime: 5000,
+          retry: 3,
+        },
+      },
     })
     const queryClient = getQueryClient()
     expect(queryClient).toBeInstanceOf(QueryClient)
@@ -34,33 +47,72 @@ describe('getQueryClient (browser environment)', () => {
     expect(queryClient.getDefaultOptions().queries?.retry).toBe(3)
   })
 
-  it('should not set cacheTime to Infinity', () => {
+  it('should use provided cacheTime value in browser environment (not Infinity)', async () => {
+    const { createGetQueryClient } = await import('./createGetQueryClient')
     const { getQueryClient } = createGetQueryClient({
-      defaultOptions: { queries: { cacheTime: 5000 } },
+      defaultOptions: {
+        queries: {
+          cacheTime: 5000,
+        },
+      },
     })
-    expect(getQueryClient().getDefaultOptions().queries?.cacheTime).toBe(5000)
+    const queryClient = getQueryClient()
+    // In browser, cacheTime should use the provided value, not Infinity
+    expect(queryClient.getDefaultOptions().queries?.cacheTime).toBe(5000)
+    expect(queryClient.getDefaultOptions().queries?.cacheTime).not.toBe(Infinity)
+  })
+
+  it('should not set cacheTime to Infinity in browser environment when no config provided', async () => {
+    const { createGetQueryClient } = await import('./createGetQueryClient')
+    const { getQueryClient } = createGetQueryClient()
+    const queryClient = getQueryClient()
+    // In browser, cacheTime should use default value (not Infinity)
+    // Default cacheTime in React Query v4 is 5 minutes (300000ms)
+    expect(queryClient.getDefaultOptions().queries?.cacheTime).not.toBe(Infinity)
   })
 })
 
 describe('getQueryClient (server environment)', () => {
   beforeEach(() => {
-    mock.isServer = true
+    vi.resetModules()
+    // Mock isServer as true for server tests
+    vi.doMock('@tanstack/react-query', async () => {
+      const actual = await vi.importActual('@tanstack/react-query')
+      return {
+        ...actual,
+        isServer: true,
+      }
+    })
   })
 
-  it('should return new QueryClient instance on each call', () => {
+  it('should return new QueryClient instance on each call in server environment', async () => {
+    const { createGetQueryClient } = await import('./createGetQueryClient')
     const { getQueryClient } = createGetQueryClient()
-    expect(getQueryClient()).not.toBe(getQueryClient())
+    const queryClient1 = getQueryClient()
+    const queryClient2 = getQueryClient()
+    expect(queryClient1).toBeInstanceOf(QueryClient)
+    expect(queryClient2).toBeInstanceOf(QueryClient)
+    expect(queryClient1).not.toBe(queryClient2)
   })
 
-  it('should set cacheTime to Infinity to prevent OOM', () => {
+  it('should set cacheTime to Infinity in server environment to prevent OOM', async () => {
+    const { createGetQueryClient } = await import('./createGetQueryClient')
     const { getQueryClient } = createGetQueryClient()
-    expect(getQueryClient().getDefaultOptions().queries?.cacheTime).toBe(Infinity)
+    const queryClient = getQueryClient()
+    expect(queryClient.getDefaultOptions().queries?.cacheTime).toBe(Infinity)
   })
 
-  it('should override cacheTime to Infinity even if config provides different value', () => {
+  it('should override cacheTime to Infinity even if config provides different value in server environment', async () => {
+    const { createGetQueryClient } = await import('./createGetQueryClient')
     const { getQueryClient } = createGetQueryClient({
-      defaultOptions: { queries: { cacheTime: 5000 } },
+      defaultOptions: {
+        queries: {
+          cacheTime: 5000,
+        },
+      },
     })
-    expect(getQueryClient().getDefaultOptions().queries?.cacheTime).toBe(Infinity)
+    const queryClient = getQueryClient()
+    // cacheTime should be Infinity regardless of config to prevent OOM on server
+    expect(queryClient.getDefaultOptions().queries?.cacheTime).toBe(Infinity)
   })
 })

package/src/index.ts

@@ -1,23 +1,10 @@
 export { createGetQueryClient } from './createGetQueryClient'
-export { infiniteQueryOptions } from './infiniteQueryOptions'
-export type { SelectedInfiniteOptions, UnSelectedInfiniteOptions } from './infiniteQueryOptions'
-export { QueriesHydration } from './QueriesHydration'
-export { queryOptions } from './queryOptions'
-export type { SelectedQueryOptions, UnSelectedQueryOptions } from './queryOptions'
-export { usePrefetchInfiniteQuery } from './usePrefetchInfiniteQuery'
-export { usePrefetchQuery } from './usePrefetchQuery'
-export { useSuspenseInfiniteQuery } from './useSuspenseInfiniteQuery'
-export type { UseSuspenseInfiniteQueryOptions, UseSuspenseInfiniteQueryResult } from './useSuspenseInfiniteQuery'
-export { useSuspenseQueries } from './useSuspenseQueries'
-export type { SuspenseQueriesOptions, SuspenseQueriesResults } from './useSuspenseQueries'
-export { useSuspenseQuery } from './useSuspenseQuery'
-export type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './useSuspenseQuery'
-
 export { IsFetching } from './IsFetching'
 export { Mutation } from './Mutation'
 export { mutationOptions } from './mutationOptions'
 export { PrefetchInfiniteQuery } from './PrefetchInfiniteQuery'
 export { PrefetchQuery } from './PrefetchQuery'
+export { QueriesHydration } from './QueriesHydration'
 export { QueryClientConsumer } from './QueryClientConsumer'
 export { SuspenseInfiniteQuery } from './SuspenseInfiniteQuery'
 export { SuspenseQueries } from './SuspenseQueries'

package/dist/IsFetching.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"IsFetching.cjs","names":[],"sources":["../src/IsFetching.tsx"],"sourcesContent":["'use client'\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":";;;;;;;;mBASE;;;;;AADF,MAAa,cAAc,SAGqE;KAHrE,EACzB;AAE8F,QAC9F,mFAAG,4HAA8B,CAAC,EAAI"}

package/dist/IsFetching.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IsFetching.d.cts","names":[],"sources":["../src/IsFetching.tsx"],"mappings":";;;;;;;;AAQA;cAAa,UAAA;EAAc,QAAA;EAAA,GAAA;AAAA,GAGxB,YAAA;EAAiB,QAAA,GAAW,UAAA,EAAY,UAAA,QAAkB,aAAA,MAAmB,SAAA;AAAA,MAAW,kBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/IsFetching.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IsFetching.d.mts","names":[],"sources":["../src/IsFetching.tsx"],"mappings":";;;;;;;;AAQA;cAAa,UAAA;EAAc,QAAA;EAAA,GAAA;AAAA,GAGxB,YAAA;EAAiB,QAAA,GAAW,UAAA,EAAY,UAAA,QAAkB,aAAA,MAAmB,SAAA;AAAA,MAAW,kBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/IsFetching.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"IsFetching.mjs","names":[],"sources":["../src/IsFetching.tsx"],"sourcesContent":["'use client'\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":";;;;;;;mBASE;;;;;AADF,MAAa,cAAc,SAGqE;KAHrE,EACzB;AAE8F,QAC9F,0CAAG,SAAS,wDAAqB,CAAC,EAAI"}

package/dist/Mutation.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Mutation.cjs","names":[],"sources":["../src/Mutation.tsx"],"sourcesContent":["'use client'\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":";;;;;;;;mBAKE;AADF,SAAgB,SAAmF,MAKhG;KALgG,EACjG;AAKA,QAAO,mFAAG,0HAA6B,CAAC,EAAI"}

package/dist/Mutation.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Mutation.d.cts","names":[],"sources":["../src/Mutation.tsx"],"mappings":";;;;;iBAIgB,QAAA,0EAAA,CAAA;EACd,QAAA;EAAA,GACG;AAAA,GACF,kBAAA,CAAmB,KAAA,EAAO,MAAA,EAAQ,UAAA,EAAY,QAAA;EAC/C,QAAA,GAAW,cAAA,EAAgB,iBAAA,CAAkB,KAAA,EAAO,MAAA,EAAQ,UAAA,EAAY,QAAA,MAAc,SAAA;AAAA,IACvF,kBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/Mutation.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Mutation.d.mts","names":[],"sources":["../src/Mutation.tsx"],"mappings":";;;;;iBAIgB,QAAA,0EAAA,CAAA;EACd,QAAA;EAAA,GACG;AAAA,GACF,kBAAA,CAAmB,KAAA,EAAO,MAAA,EAAQ,UAAA,EAAY,QAAA;EAC/C,QAAA,GAAW,cAAA,EAAgB,iBAAA,CAAkB,KAAA,EAAO,MAAA,EAAQ,UAAA,EAAY,QAAA,MAAc,SAAA;AAAA,IACvF,kBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/Mutation.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Mutation.mjs","names":[],"sources":["../src/Mutation.tsx"],"sourcesContent":["'use client'\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":";;;;;;;mBAKE;AADF,SAAgB,SAAmF,MAKhG;KALgG,EACjG;AAKA,QAAO,0CAAG,SAAS,sDAAoB,CAAC,EAAI"}

package/dist/PrefetchInfiniteQuery.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"PrefetchInfiniteQuery.cjs","names":[],"sources":["../src/PrefetchInfiniteQuery.tsx"],"sourcesContent":["'use client'\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":";;;;;;;;;;;;;;;AAYA,SAAgB,sBAKd,SAA4E;AAC5E,2DAAyB,QAAQ;AACjC,QAAO,yEAAK"}

package/dist/PrefetchInfiniteQuery.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PrefetchInfiniteQuery.d.cts","names":[],"sources":["../src/PrefetchInfiniteQuery.tsx"],"mappings":";;;;;;;AAYA;;;;;iBAAgB,qBAAA,mDAGN,YAAA,oBACU,QAAA,GAAW,QAAA,CAAA,CAC7B,OAAA,EAAS,yBAAA,CAA0B,YAAA,EAAc,MAAA,EAAQ,KAAA,EAAO,SAAA,IAAU,kBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/PrefetchInfiniteQuery.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PrefetchInfiniteQuery.d.mts","names":[],"sources":["../src/PrefetchInfiniteQuery.tsx"],"mappings":";;;;;;;AAYA;;;;;iBAAgB,qBAAA,mDAGN,YAAA,oBACU,QAAA,GAAW,QAAA,CAAA,CAC7B,OAAA,EAAS,yBAAA,CAA0B,YAAA,EAAc,MAAA,EAAQ,KAAA,EAAO,SAAA,IAAU,kBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/PrefetchInfiniteQuery.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"PrefetchInfiniteQuery.mjs","names":[],"sources":["../src/PrefetchInfiniteQuery.tsx"],"sourcesContent":["'use client'\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":";;;;;;;;;;;;;;AAYA,SAAgB,sBAKd,SAA4E;AAC5E,0BAAyB,QAAQ;AACjC,QAAO,gCAAK"}

package/dist/PrefetchQuery.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"PrefetchQuery.cjs","names":[],"sources":["../src/PrefetchQuery.tsx"],"sourcesContent":["'use client'\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":";;;;;;;;;;;;;;;AAYA,SAAgB,cAKd,SAAoE;AACpE,2CAAiB,QAAQ;AACzB,QAAO,yEAAK"}

package/dist/PrefetchQuery.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PrefetchQuery.d.cts","names":[],"sources":["../src/PrefetchQuery.tsx"],"mappings":";;;;;;;AAYA;;;;;iBAAgB,aAAA,mDAGN,YAAA,oBACU,QAAA,GAAW,QAAA,CAAA,CAC7B,OAAA,EAAS,iBAAA,CAAkB,YAAA,EAAc,MAAA,EAAQ,KAAA,EAAO,SAAA,IAAU,kBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/PrefetchQuery.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PrefetchQuery.d.mts","names":[],"sources":["../src/PrefetchQuery.tsx"],"mappings":";;;;;;;AAYA;;;;;iBAAgB,aAAA,mDAGN,YAAA,oBACU,QAAA,GAAW,QAAA,CAAA,CAC7B,OAAA,EAAS,iBAAA,CAAkB,YAAA,EAAc,MAAA,EAAQ,KAAA,EAAO,SAAA,IAAU,kBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/PrefetchQuery.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"PrefetchQuery.mjs","names":[],"sources":["../src/PrefetchQuery.tsx"],"sourcesContent":["'use client'\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":";;;;;;;;;;;;;;AAYA,SAAgB,cAKd,SAAoE;AACpE,kBAAiB,QAAQ;AACzB,QAAO,gCAAK"}

package/dist/QueriesHydration.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueriesHydration.cjs","names":["QueryClient","ClientOnly","Hydrate"],"sources":["../src/QueriesHydration.tsx"],"sourcesContent":["import {\n  Hydrate,\n  type HydrateProps,\n  type OmitKeyof,\n  QueryClient,\n  type QueryOptions,\n  type UseInfiniteQueryOptions,\n  type WithRequired,\n  dehydrate,\n} from '@tanstack/react-query'\nimport type { ReactNode } from 'react'\nimport { ClientOnly } from './components/ClientOnly'\n\n/**\n * A server component that fetches multiple queries on the server and hydrates them to the client.\n *\n * @experimental This component is experimental and may be changed or removed in the future.\n *\n * @description\n * QueriesHydration is designed for React Server Components (RSC).\n * It pre-fetches multiple queries on the server side and automatically hydrates\n * the data to the client, enabling seamless data synchronization between server and client.\n *\n * When errors occur during server-side fetching, the component gracefully falls back\n * to client-side rendering, ensuring your application remains resilient.\n *\n * @example\n * ```tsx\n * // app/page.tsx (Server Component)\n * import { Suspense } from 'react'\n * import { QueriesHydration } from '@suspensive/react-query'\n * import { queryOptions } from '@tanstack/react-query'\n *\n * const userQueryOptions = (userId: string) => queryOptions({\n *   queryKey: ['user', userId],\n *   queryFn: () => fetchUser(userId)\n * })\n *\n * const postsQueryOptions = () => queryOptions({\n *   queryKey: ['posts'],\n *   queryFn: () => fetchPosts()\n * })\n *\n * export default function Page({ userId }: { userId: string }) {\n *   return (\n *     <>\n *       <Suspense fallback={<div>Loading user...</div>}>\n *         <QueriesHydration queries={[userQueryOptions(userId)]}>\n *           <UserProfile />\n *         </QueriesHydration>\n *       </Suspense>\n *\n *       <Suspense fallback={<div>Loading posts...</div>}>\n *         <QueriesHydration queries={[postsQueryOptions()]}>\n *           <PostsList />\n *         </QueriesHydration>\n *       </Suspense>\n *     </>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * // With custom error fallback\n * <Suspense fallback={<div>Loading user...</div>}>\n *   <QueriesHydration\n *     queries={[userQueryOptions(userId)]}\n *     skipSsrOnError={{ fallback: <div>Fetching on client...</div> }}\n *   >\n *     <UserProfile />\n *   </QueriesHydration>\n * </Suspense>\n * ```\n *\n * @see {@link https://suspensive.org/docs/react-query/QueriesHydration Documentation}\n */\nexport async function QueriesHydration({\n  queries,\n  children,\n  queryClient = new QueryClient(),\n  skipSsrOnError = true,\n  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;;;;iFAqCD;MArCC,EACrC,SACA,UACA,cAAc,IAAIA,mCAAa,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,+BAAD;IAAY,UAAU,mBAAmB,OAAO,SAAY,eAAe;IAAW;IAAsB;;AAIlH,SACE,2CAACC,6GAAY;GAAO,4CAAiB,YAAY;GAC9C;IACO;;;;AAId,MAAM,2BAA2B,IAAY,iBAAyB;CACpE,IAAI;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.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueriesHydration.d.cts","names":[],"sources":["../src/QueriesHydration.tsx"],"mappings":";;;;;;;;AA6EA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAsB,gBAAA,CAAA;EACpB,OAAA;EACA,QAAA;EACA,WAAA;EACA,cAAA;EACA,OAAA;EAAA,GACG;AAAA;;;;EAKH,WAAA,GAAc,WAAA;;;;;EAKd,OAAA,GACI,YAAA,CAAa,YAAA,oCACb,YAAA,CAAa,uBAAA;;;;;;;EAQjB,cAAA;IAGM,QAAA,EAAU,SAAA;EAAA;;;;;;EAOhB,OAAA;AAAA,IACE,SAAA,CAAU,YAAA,aAAsB,OAAA,CAAA,kBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/QueriesHydration.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueriesHydration.d.mts","names":[],"sources":["../src/QueriesHydration.tsx"],"mappings":";;;;;;;;AA6EA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAsB,gBAAA,CAAA;EACpB,OAAA;EACA,QAAA;EACA,WAAA;EACA,cAAA;EACA,OAAA;EAAA,GACG;AAAA;;;;EAKH,WAAA,GAAc,WAAA;;;;;EAKd,OAAA,GACI,YAAA,CAAa,YAAA,oCACb,YAAA,CAAa,uBAAA;;;;;;;EAQjB,cAAA;IAGM,QAAA,EAAU,SAAA;EAAA;;;;;;EAOhB,OAAA;AAAA,IACE,SAAA,CAAU,YAAA,aAAsB,OAAA,CAAA,kBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/QueriesHydration.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueriesHydration.mjs","names":[],"sources":["../src/QueriesHydration.tsx"],"sourcesContent":["import {\n  Hydrate,\n  type HydrateProps,\n  type OmitKeyof,\n  QueryClient,\n  type QueryOptions,\n  type UseInfiniteQueryOptions,\n  type WithRequired,\n  dehydrate,\n} from '@tanstack/react-query'\nimport type { ReactNode } from 'react'\nimport { ClientOnly } from './components/ClientOnly'\n\n/**\n * A server component that fetches multiple queries on the server and hydrates them to the client.\n *\n * @experimental This component is experimental and may be changed or removed in the future.\n *\n * @description\n * QueriesHydration is designed for React Server Components (RSC).\n * It pre-fetches multiple queries on the server side and automatically hydrates\n * the data to the client, enabling seamless data synchronization between server and client.\n *\n * When errors occur during server-side fetching, the component gracefully falls back\n * to client-side rendering, ensuring your application remains resilient.\n *\n * @example\n * ```tsx\n * // app/page.tsx (Server Component)\n * import { Suspense } from 'react'\n * import { QueriesHydration } from '@suspensive/react-query'\n * import { queryOptions } from '@tanstack/react-query'\n *\n * const userQueryOptions = (userId: string) => queryOptions({\n *   queryKey: ['user', userId],\n *   queryFn: () => fetchUser(userId)\n * })\n *\n * const postsQueryOptions = () => queryOptions({\n *   queryKey: ['posts'],\n *   queryFn: () => fetchPosts()\n * })\n *\n * export default function Page({ userId }: { userId: string }) {\n *   return (\n *     <>\n *       <Suspense fallback={<div>Loading user...</div>}>\n *         <QueriesHydration queries={[userQueryOptions(userId)]}>\n *           <UserProfile />\n *         </QueriesHydration>\n *       </Suspense>\n *\n *       <Suspense fallback={<div>Loading posts...</div>}>\n *         <QueriesHydration queries={[postsQueryOptions()]}>\n *           <PostsList />\n *         </QueriesHydration>\n *       </Suspense>\n *     </>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * // With custom error fallback\n * <Suspense fallback={<div>Loading user...</div>}>\n *   <QueriesHydration\n *     queries={[userQueryOptions(userId)]}\n *     skipSsrOnError={{ fallback: <div>Fetching on client...</div> }}\n *   >\n *     <UserProfile />\n *   </QueriesHydration>\n * </Suspense>\n * ```\n *\n * @see {@link https://suspensive.org/docs/react-query/QueriesHydration Documentation}\n */\nexport async function QueriesHydration({\n  queries,\n  children,\n  queryClient = new QueryClient(),\n  skipSsrOnError = true,\n  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,YAAD;IAAY,UAAU,mBAAmB,OAAO,SAAY,eAAe;IAAW;IAAsB;;AAIlH,SACE,oBAAC,2CAAY;GAAO,OAAO,UAAU,YAAY;GAC9C;IACO;;;;AAId,MAAM,2BAA2B,IAAY,iBAAyB;CACpE,IAAI;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/QueryClientConsumer.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueryClientConsumer.cjs","names":[],"sources":["../src/QueryClientConsumer.tsx"],"sourcesContent":["'use client'\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":";;;;;;;;;;AAOA,SAAgB,oBAAoB,EAClC,UACA,WAIC;AACD,QAAO,mFAAG,mDAAwB,EAAW,SAAgB,CAAC,CAAC,EAAI"}

package/dist/QueryClientConsumer.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueryClientConsumer.d.cts","names":[],"sources":["../src/QueryClientConsumer.tsx"],"mappings":";;;;;;;;iBAOgB,mBAAA,CAAA;EACd,QAAA;EACA;AAAA;EAEA,QAAA,GAAW,WAAA,EAAa,WAAA,KAAgB,SAAA;EACxC,OAAA,GAAU,OAAA,CAAQ,WAAA;AAAA,IACnB,kBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/QueryClientConsumer.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueryClientConsumer.d.mts","names":[],"sources":["../src/QueryClientConsumer.tsx"],"mappings":";;;;;;;;iBAOgB,mBAAA,CAAA;EACd,QAAA;EACA;AAAA;EAEA,QAAA,GAAW,WAAA,EAAa,WAAA,KAAgB,SAAA;EACxC,OAAA,GAAU,OAAA,CAAQ,WAAA;AAAA,IACnB,kBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/QueryClientConsumer.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueryClientConsumer.mjs","names":[],"sources":["../src/QueryClientConsumer.tsx"],"sourcesContent":["'use client'\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":";;;;;;;;;AAOA,SAAgB,oBAAoB,EAClC,UACA,WAIC;AACD,QAAO,0CAAG,SAAS,eAAe,EAAW,SAAgB,CAAC,CAAC,EAAI"}

package/dist/SuspenseInfiniteQuery.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"SuspenseInfiniteQuery.cjs","names":[],"sources":["../src/SuspenseInfiniteQuery.tsx"],"sourcesContent":["'use client'\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":";;;;;;;;mBA0BE;;;;;;;;;;;;;;;;;AANF,MAAa,yBAKX,SAKI;KALJ,EACA;AAII,2FAAG,uIAA0C,CAAC,EAAI"}

package/dist/SuspenseInfiniteQuery.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SuspenseInfiniteQuery.d.cts","names":[],"sources":["../src/SuspenseInfiniteQuery.tsx"],"mappings":";;;;;;;;;AAoBA;;;;;;;;;;;;;cAAa,qBAAA,qDAGH,YAAA,oBACU,QAAA,GAAW,QAAA;EAC7B,QAAA;EAAA,GAAA;AAAA,GAGC,+BAAA,CAAgC,YAAA,EAAc,MAAA,EAAQ,KAAA,EAAO,SAAA;EAC9D,QAAA,GAAW,KAAA,EAAO,8BAAA,CAA+B,KAAA,EAAO,MAAA,MAAY,SAAA;AAAA,MACrE,kBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/SuspenseInfiniteQuery.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SuspenseInfiniteQuery.d.mts","names":[],"sources":["../src/SuspenseInfiniteQuery.tsx"],"mappings":";;;;;;;;;AAoBA;;;;;;;;;;;;;cAAa,qBAAA,qDAGH,YAAA,oBACU,QAAA,GAAW,QAAA;EAC7B,QAAA;EAAA,GAAA;AAAA,GAGC,+BAAA,CAAgC,YAAA,EAAc,MAAA,EAAQ,KAAA,EAAO,SAAA;EAC9D,QAAA,GAAW,KAAA,EAAO,8BAAA,CAA+B,KAAA,EAAO,MAAA,MAAY,SAAA;AAAA,MACrE,kBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/SuspenseInfiniteQuery.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"SuspenseInfiniteQuery.mjs","names":[],"sources":["../src/SuspenseInfiniteQuery.tsx"],"sourcesContent":["'use client'\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":";;;;;;;mBA0BE;;;;;;;;;;;;;;;;;AANF,MAAa,yBAKX,SAKI;KALJ,EACA;AAII,kDAAG,SAAS,mEAAiC,CAAC,EAAI"}

package/dist/SuspenseQueries.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"SuspenseQueries.cjs","names":[],"sources":["../src/SuspenseQueries.tsx"],"sourcesContent":["'use client'\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":";;;;;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,gBAAiC,EAC/C,UACA,WAIC;AACD,QAAO,mFAAG,uDAA4B,EAAE,SAAS,CAAC,CAAC,EAAI"}

package/dist/SuspenseQueries.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SuspenseQueries.d.cts","names":[],"sources":["../src/SuspenseQueries.tsx"],"mappings":";;;;;;;;AAmBA;;;;;;;;;;;;iBAAgB,eAAA,iBAAA,CAAA;EACd,QAAA;EACA;AAAA;EAEA,OAAA,eAAsB,sBAAA,CAAuB,CAAA;EAC7C,QAAA,GAAW,OAAA,EAAS,sBAAA,CAAuB,CAAA,MAAO,SAAA;AAAA,IACnD,kBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/SuspenseQueries.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SuspenseQueries.d.mts","names":[],"sources":["../src/SuspenseQueries.tsx"],"mappings":";;;;;;;;AAmBA;;;;;;;;;;;;iBAAgB,eAAA,iBAAA,CAAA;EACd,QAAA;EACA;AAAA;EAEA,OAAA,eAAsB,sBAAA,CAAuB,CAAA;EAC7C,QAAA,GAAW,OAAA,EAAS,sBAAA,CAAuB,CAAA,MAAO,SAAA;AAAA,IACnD,kBAAA,CAAA,GAAA,CAAA,OAAA"}