@suspensive/react-query-4 3.19.1 → 3.19.3

package/dist/QueriesHydration.d.cts

@@ -1,2 +1,105 @@
-import { t as QueriesHydration } from "./QueriesHydration-B89HKn9y.cjs";
-export { QueriesHydration };
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { HydrateProps, OmitKeyof, QueryClient, QueryOptions, UseInfiniteQueryOptions, WithRequired } from "@tanstack/react-query";
+import { ReactNode } from "react";
+
+//#region src/QueriesHydration.d.ts
+/**
+ * A server component that fetches multiple queries on the server and hydrates them to the client.
+ *
+ * @experimental This component is experimental and may be changed or removed in the future.
+ *
+ * @description
+ * 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.
+ *
+ * When errors occur during server-side fetching, the component gracefully falls back
+ * to client-side rendering, ensuring your application remains resilient.
+ *
+ * @example
+ * ```tsx
+ * // app/page.tsx (Server Component)
+ * import { Suspense } from 'react'
+ * import { QueriesHydration } from '@suspensive/react-query'
+ * import { queryOptions } from '@tanstack/react-query'
+ *
+ * const userQueryOptions = (userId: string) => queryOptions({
+ *   queryKey: ['user', userId],
+ *   queryFn: () => fetchUser(userId)
+ * })
+ *
+ * const postsQueryOptions = () => queryOptions({
+ *   queryKey: ['posts'],
+ *   queryFn: () => fetchPosts()
+ * })
+ *
+ * export default function Page({ userId }: { userId: string }) {
+ *   return (
+ *     <>
+ *       <Suspense fallback={<div>Loading user...</div>}>
+ *         <QueriesHydration queries={[userQueryOptions(userId)]}>
+ *           <UserProfile />
+ *         </QueriesHydration>
+ *       </Suspense>
+ *
+ *       <Suspense fallback={<div>Loading posts...</div>}>
+ *         <QueriesHydration queries={[postsQueryOptions()]}>
+ *           <PostsList />
+ *         </QueriesHydration>
+ *       </Suspense>
+ *     </>
+ *   )
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With custom error fallback
+ * <Suspense fallback={<div>Loading user...</div>}>
+ *   <QueriesHydration
+ *     queries={[userQueryOptions(userId)]}
+ *     skipSsrOnError={{ fallback: <div>Fetching on client...</div> }}
+ *   >
+ *     <UserProfile />
+ *   </QueriesHydration>
+ * </Suspense>
+ * ```
+ *
+ * @see {@link https://suspensive.org/docs/react-query/QueriesHydration Documentation}
+ */
+declare function QueriesHydration({
+  queries,
+  children,
+  queryClient,
+  skipSsrOnError,
+  timeout,
+  ...props
+}: {
+  /**
+   * The QueryClient instance to use for fetching queries.
+   */
+  queryClient?: QueryClient;
+  /**
+   * An array of query options or infinite query options to be fetched on the server. Each query must include a `queryKey`.
+   * You can mix regular queries and infinite queries in the same array.
+   */
+  queries: (WithRequired<QueryOptions<any, any, any, any>, 'queryKey'> | WithRequired<UseInfiniteQueryOptions<any, any, any, any, any>, 'queryKey'>)[];
+  /**
+   * Controls error handling behavior:
+   * - `true` (default): Skips SSR and falls back to client-side rendering when server fetch fails
+   * - `false`: Proceeds with SSR without hydration (retry fetching on client component server rendering)
+   * - `{ fallback: ReactNode }`: Skips SSR with custom fallback UI during client-side rendering
+   */
+  skipSsrOnError?: boolean | {
+    fallback: ReactNode;
+  };
+  /**
+   * The timeout in milliseconds for the query.
+   * If the query takes longer than the timeout, it will be considered as an error.
+   * When not set, no timeout is applied.
+   */
+  timeout?: number;
+} & OmitKeyof<HydrateProps, 'state'>): Promise<react_jsx_runtime0.JSX.Element>;
+//#endregion
+export { QueriesHydration };
+//# sourceMappingURL=QueriesHydration.d.cts.map

package/dist/QueriesHydration.d.cts.map

@@ -0,0 +1 @@
+{"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

@@ -1,2 +1,105 @@
-import { t as QueriesHydration } from "./QueriesHydration-BeMkJU3l.mjs";
-export { QueriesHydration };
+import { HydrateProps, OmitKeyof, QueryClient, QueryOptions, UseInfiniteQueryOptions, WithRequired } from "@tanstack/react-query";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { ReactNode } from "react";
+
+//#region src/QueriesHydration.d.ts
+/**
+ * A server component that fetches multiple queries on the server and hydrates them to the client.
+ *
+ * @experimental This component is experimental and may be changed or removed in the future.
+ *
+ * @description
+ * 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.
+ *
+ * When errors occur during server-side fetching, the component gracefully falls back
+ * to client-side rendering, ensuring your application remains resilient.
+ *
+ * @example
+ * ```tsx
+ * // app/page.tsx (Server Component)
+ * import { Suspense } from 'react'
+ * import { QueriesHydration } from '@suspensive/react-query'
+ * import { queryOptions } from '@tanstack/react-query'
+ *
+ * const userQueryOptions = (userId: string) => queryOptions({
+ *   queryKey: ['user', userId],
+ *   queryFn: () => fetchUser(userId)
+ * })
+ *
+ * const postsQueryOptions = () => queryOptions({
+ *   queryKey: ['posts'],
+ *   queryFn: () => fetchPosts()
+ * })
+ *
+ * export default function Page({ userId }: { userId: string }) {
+ *   return (
+ *     <>
+ *       <Suspense fallback={<div>Loading user...</div>}>
+ *         <QueriesHydration queries={[userQueryOptions(userId)]}>
+ *           <UserProfile />
+ *         </QueriesHydration>
+ *       </Suspense>
+ *
+ *       <Suspense fallback={<div>Loading posts...</div>}>
+ *         <QueriesHydration queries={[postsQueryOptions()]}>
+ *           <PostsList />
+ *         </QueriesHydration>
+ *       </Suspense>
+ *     </>
+ *   )
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With custom error fallback
+ * <Suspense fallback={<div>Loading user...</div>}>
+ *   <QueriesHydration
+ *     queries={[userQueryOptions(userId)]}
+ *     skipSsrOnError={{ fallback: <div>Fetching on client...</div> }}
+ *   >
+ *     <UserProfile />
+ *   </QueriesHydration>
+ * </Suspense>
+ * ```
+ *
+ * @see {@link https://suspensive.org/docs/react-query/QueriesHydration Documentation}
+ */
+declare function QueriesHydration({
+  queries,
+  children,
+  queryClient,
+  skipSsrOnError,
+  timeout,
+  ...props
+}: {
+  /**
+   * The QueryClient instance to use for fetching queries.
+   */
+  queryClient?: QueryClient;
+  /**
+   * An array of query options or infinite query options to be fetched on the server. Each query must include a `queryKey`.
+   * You can mix regular queries and infinite queries in the same array.
+   */
+  queries: (WithRequired<QueryOptions<any, any, any, any>, 'queryKey'> | WithRequired<UseInfiniteQueryOptions<any, any, any, any, any>, 'queryKey'>)[];
+  /**
+   * Controls error handling behavior:
+   * - `true` (default): Skips SSR and falls back to client-side rendering when server fetch fails
+   * - `false`: Proceeds with SSR without hydration (retry fetching on client component server rendering)
+   * - `{ fallback: ReactNode }`: Skips SSR with custom fallback UI during client-side rendering
+   */
+  skipSsrOnError?: boolean | {
+    fallback: ReactNode;
+  };
+  /**
+   * The timeout in milliseconds for the query.
+   * If the query takes longer than the timeout, it will be considered as an error.
+   * When not set, no timeout is applied.
+   */
+  timeout?: number;
+} & OmitKeyof<HydrateProps, 'state'>): Promise<react_jsx_runtime0.JSX.Element>;
+//#endregion
+export { QueriesHydration };
+//# sourceMappingURL=QueriesHydration.d.mts.map

package/dist/QueriesHydration.d.mts.map

@@ -0,0 +1 @@
+{"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

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

package/dist/QueryClientConsumer.cjs

@@ -1,5 +1,17 @@
 'use client';
 
-const require_QueryClientConsumer = require('./QueryClientConsumer-mF0OUwkq.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let _tanstack_react_query = require("@tanstack/react-query");
+let react_jsx_runtime = require("react/jsx-runtime");
 
-exports.QueryClientConsumer = require_QueryClientConsumer.QueryClientConsumer;
+//#region src/QueryClientConsumer.tsx
+/**
+* @experimental This is experimental feature.
+*/
+function QueryClientConsumer({ children, context }) {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: children((0, _tanstack_react_query.useQueryClient)({ context })) });
+}
+
+//#endregion
+exports.QueryClientConsumer = QueryClientConsumer;
+//# sourceMappingURL=QueryClientConsumer.cjs.map

package/dist/QueryClientConsumer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryClientConsumer.cjs","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,mFAAG,mDAAwB,EAAW,SAAgB,CAAC,CAAC,EAAI"}

package/dist/QueryClientConsumer.d.cts

@@ -1,2 +1,18 @@
-import { t as QueryClientConsumer } from "./QueryClientConsumer-D3h25GmM.cjs";
-export { QueryClientConsumer };
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { QueryClient } from "@tanstack/react-query";
+import { Context, ReactNode } from "react";
+
+//#region src/QueryClientConsumer.d.ts
+/**
+ * @experimental This is experimental feature.
+ */
+declare function QueryClientConsumer({
+  children,
+  context
+}: {
+  children: (queryClient: QueryClient) => ReactNode;
+  context?: Context<QueryClient | undefined>;
+}): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { QueryClientConsumer };
+//# sourceMappingURL=QueryClientConsumer.d.cts.map

package/dist/QueryClientConsumer.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryClientConsumer.d.cts","names":[],"sources":["../src/QueryClientConsumer.tsx"],"mappings":";;;;;;;;iBAQgB,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

@@ -1,2 +1,18 @@
-import { t as QueryClientConsumer } from "./QueryClientConsumer-DNkucS1e.mjs";
-export { QueryClientConsumer };
+import { QueryClient } from "@tanstack/react-query";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { Context, ReactNode } from "react";
+
+//#region src/QueryClientConsumer.d.ts
+/**
+ * @experimental This is experimental feature.
+ */
+declare function QueryClientConsumer({
+  children,
+  context
+}: {
+  children: (queryClient: QueryClient) => ReactNode;
+  context?: Context<QueryClient | undefined>;
+}): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { QueryClientConsumer };
+//# sourceMappingURL=QueryClientConsumer.d.mts.map

package/dist/QueryClientConsumer.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryClientConsumer.d.mts","names":[],"sources":["../src/QueryClientConsumer.tsx"],"mappings":";;;;;;;;iBAQgB,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

@@ -1,5 +1,16 @@
 'use client';
 
-import { t as QueryClientConsumer } from "./QueryClientConsumer-e7PyaFF3.mjs";
+import { useQueryClient } from "@tanstack/react-query";
+import { Fragment, jsx } from "react/jsx-runtime";
 
-export { QueryClientConsumer };
+//#region src/QueryClientConsumer.tsx
+/**
+* @experimental This is experimental feature.
+*/
+function QueryClientConsumer({ children, context }) {
+	return /* @__PURE__ */ jsx(Fragment, { children: children(useQueryClient({ context })) });
+}
+
+//#endregion
+export { QueryClientConsumer };
+//# sourceMappingURL=QueryClientConsumer.mjs.map

package/dist/QueryClientConsumer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryClientConsumer.mjs","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,EAAI"}

package/dist/SuspenseInfiniteQuery.cjs

@@ -1,5 +1,33 @@
 'use client';
 
-const require_SuspenseInfiniteQuery = require('./SuspenseInfiniteQuery-Dq97Dear.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_objectWithoutProperties = require('./objectWithoutProperties-CfjOeCpP.cjs');
+let _tanstack_react_query = require("@tanstack/react-query");
+let react_jsx_runtime = require("react/jsx-runtime");
 
-exports.SuspenseInfiniteQuery = require_SuspenseInfiniteQuery.SuspenseInfiniteQuery;
+//#region src/SuspenseInfiniteQuery.tsx
+const _excluded = ["children"];
+/**
+* We provide these components to clearly express what causes suspense at the same depth.
+* `<SuspenseInfiniteQuery/>` serves to make `useSuspenseInfiniteQuery` easier to use in jsx.
+* @see {@link https://suspensive.org/docs/react-query/SuspenseInfiniteQuery Suspensive Docs}
+* @example
+* ```tsx
+* import { SuspenseInfiniteQuery } from '@suspensive/react-query'
+*
+* // You can use infiniteQueryOptions as props.
+* <SuspenseInfiniteQuery {...infiniteQueryOptions()}>
+*   {({ data, fetchNextPage }) => {
+*     return <></>
+*   }}
+* </SuspenseInfiniteQuery>
+* ```
+*/
+const SuspenseInfiniteQuery = (_ref) => {
+	let { children } = _ref;
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: children((0, _tanstack_react_query.useSuspenseInfiniteQuery)(require_objectWithoutProperties._objectWithoutProperties(_ref, _excluded))) });
+};
+
+//#endregion
+exports.SuspenseInfiniteQuery = SuspenseInfiniteQuery;
+//# sourceMappingURL=SuspenseInfiniteQuery.cjs.map

package/dist/SuspenseInfiniteQuery.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SuspenseInfiniteQuery.cjs","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,2FAAG,uIAA0C,CAAC,EAAI"}

package/dist/SuspenseInfiniteQuery.d.cts

@@ -1,2 +1,31 @@
-import { t as SuspenseInfiniteQuery } from "./SuspenseInfiniteQuery-Bt7GeiHi.cjs";
-export { SuspenseInfiniteQuery };
+import { UseSuspenseInfiniteQueryOptions } from "./useSuspenseInfiniteQuery.cjs";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { QueryKey, UseSuspenseInfiniteQueryResult } from "@tanstack/react-query";
+import { ReactNode } from "react";
+
+//#region src/SuspenseInfiniteQuery.d.ts
+/**
+ * We provide these components to clearly express what causes suspense at the same depth.
+ * `<SuspenseInfiniteQuery/>` serves to make `useSuspenseInfiniteQuery` easier to use in jsx.
+ * @see {@link https://suspensive.org/docs/react-query/SuspenseInfiniteQuery Suspensive Docs}
+ * @example
+ * ```tsx
+ * import { SuspenseInfiniteQuery } from '@suspensive/react-query'
+ *
+ * // You can use infiniteQueryOptions as props.
+ * <SuspenseInfiniteQuery {...infiniteQueryOptions()}>
+ *   {({ data, fetchNextPage }) => {
+ *     return <></>
+ *   }}
+ * </SuspenseInfiniteQuery>
+ * ```
+ */
+declare const SuspenseInfiniteQuery: <TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>({
+  children,
+  ...options
+}: UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+  children: (query: UseSuspenseInfiniteQueryResult<TData, TError>) => ReactNode;
+}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+export { SuspenseInfiniteQuery };
+//# sourceMappingURL=SuspenseInfiniteQuery.d.cts.map

package/dist/SuspenseInfiniteQuery.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SuspenseInfiniteQuery.d.cts","names":[],"sources":["../src/SuspenseInfiniteQuery.tsx"],"mappings":";;;;;;;;;AAqBA;;;;;;;;;;;;;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

@@ -1,3 +1,31 @@
-import "./useSuspenseInfiniteQuery-Bh0nh8Kc.mjs";
-import { t as SuspenseInfiniteQuery } from "./SuspenseInfiniteQuery-CSd2Hyym.mjs";
-export { SuspenseInfiniteQuery };
+import { UseSuspenseInfiniteQueryOptions } from "./useSuspenseInfiniteQuery.mjs";
+import { QueryKey, UseSuspenseInfiniteQueryResult } from "@tanstack/react-query";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { ReactNode } from "react";
+
+//#region src/SuspenseInfiniteQuery.d.ts
+/**
+ * We provide these components to clearly express what causes suspense at the same depth.
+ * `<SuspenseInfiniteQuery/>` serves to make `useSuspenseInfiniteQuery` easier to use in jsx.
+ * @see {@link https://suspensive.org/docs/react-query/SuspenseInfiniteQuery Suspensive Docs}
+ * @example
+ * ```tsx
+ * import { SuspenseInfiniteQuery } from '@suspensive/react-query'
+ *
+ * // You can use infiniteQueryOptions as props.
+ * <SuspenseInfiniteQuery {...infiniteQueryOptions()}>
+ *   {({ data, fetchNextPage }) => {
+ *     return <></>
+ *   }}
+ * </SuspenseInfiniteQuery>
+ * ```
+ */
+declare const SuspenseInfiniteQuery: <TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>({
+  children,
+  ...options
+}: UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+  children: (query: UseSuspenseInfiniteQueryResult<TData, TError>) => ReactNode;
+}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+export { SuspenseInfiniteQuery };
+//# sourceMappingURL=SuspenseInfiniteQuery.d.mts.map

package/dist/SuspenseInfiniteQuery.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SuspenseInfiniteQuery.d.mts","names":[],"sources":["../src/SuspenseInfiniteQuery.tsx"],"mappings":";;;;;;;;;AAqBA;;;;;;;;;;;;;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

@@ -1,5 +1,32 @@
 'use client';
 
-import { t as SuspenseInfiniteQuery } from "./SuspenseInfiniteQuery-DwW5I_M2.mjs";
+import { t as _objectWithoutProperties } from "./objectWithoutProperties-CZk5Qmfh.mjs";
+import { useSuspenseInfiniteQuery } from "@tanstack/react-query";
+import { Fragment, jsx } from "react/jsx-runtime";
 
-export { SuspenseInfiniteQuery };
+//#region src/SuspenseInfiniteQuery.tsx
+const _excluded = ["children"];
+/**
+* We provide these components to clearly express what causes suspense at the same depth.
+* `<SuspenseInfiniteQuery/>` serves to make `useSuspenseInfiniteQuery` easier to use in jsx.
+* @see {@link https://suspensive.org/docs/react-query/SuspenseInfiniteQuery Suspensive Docs}
+* @example
+* ```tsx
+* import { SuspenseInfiniteQuery } from '@suspensive/react-query'
+*
+* // You can use infiniteQueryOptions as props.
+* <SuspenseInfiniteQuery {...infiniteQueryOptions()}>
+*   {({ data, fetchNextPage }) => {
+*     return <></>
+*   }}
+* </SuspenseInfiniteQuery>
+* ```
+*/
+const SuspenseInfiniteQuery = (_ref) => {
+	let { children } = _ref;
+	return /* @__PURE__ */ jsx(Fragment, { children: children(useSuspenseInfiniteQuery(_objectWithoutProperties(_ref, _excluded))) });
+};
+
+//#endregion
+export { SuspenseInfiniteQuery };
+//# sourceMappingURL=SuspenseInfiniteQuery.mjs.map

package/dist/SuspenseInfiniteQuery.mjs.map

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

package/dist/SuspenseQueries.cjs

@@ -1,5 +1,29 @@
 'use client';
 
-const require_SuspenseQueries = require('./SuspenseQueries-Brk6gtMw.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let _tanstack_react_query = require("@tanstack/react-query");
+let react_jsx_runtime = require("react/jsx-runtime");
 
-exports.SuspenseQueries = require_SuspenseQueries.SuspenseQueries;
+//#region src/SuspenseQueries.tsx
+/**
+* We provide these components to clearly express what causes suspense at the same depth.
+* `<SuspenseQueries/>` serves to make `useSuspenseQueries` easier to use in jsx.
+* @see {@link https://suspensive.org/docs/react-query/SuspenseQueries Suspensive Docs}
+* @example
+* ```tsx
+* import { SuspenseQueries } from '@suspensive/react-query'
+*
+* <SuspenseQueries queries={[firstQueryOptions(), secondQueryOptions()]}>
+*   {([{ data: firstQueryData }, { data: secondQueryData }]) => {
+*     return <></>
+*   }}
+* </SuspenseQueries>
+* ```
+*/
+function SuspenseQueries({ children, queries }) {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: children((0, _tanstack_react_query.useSuspenseQueries)({ queries })) });
+}
+
+//#endregion
+exports.SuspenseQueries = SuspenseQueries;
+//# sourceMappingURL=SuspenseQueries.cjs.map

package/dist/SuspenseQueries.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SuspenseQueries.cjs","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,mFAAG,uDAA4B,EAAE,SAAS,CAAC,CAAC,EAAI"}

package/dist/SuspenseQueries.d.cts

@@ -1,2 +1,30 @@
-import { t as SuspenseQueries } from "./SuspenseQueries-B-UR1dnn.cjs";
-export { SuspenseQueries };
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { SuspenseQueriesOptions, SuspenseQueriesResults } from "@tanstack/react-query";
+import { ReactNode } from "react";
+
+//#region src/SuspenseQueries.d.ts
+/**
+ * We provide these components to clearly express what causes suspense at the same depth.
+ * `<SuspenseQueries/>` serves to make `useSuspenseQueries` easier to use in jsx.
+ * @see {@link https://suspensive.org/docs/react-query/SuspenseQueries Suspensive Docs}
+ * @example
+ * ```tsx
+ * import { SuspenseQueries } from '@suspensive/react-query'
+ *
+ * <SuspenseQueries queries={[firstQueryOptions(), secondQueryOptions()]}>
+ *   {([{ data: firstQueryData }, { data: secondQueryData }]) => {
+ *     return <></>
+ *   }}
+ * </SuspenseQueries>
+ * ```
+ */
+declare function SuspenseQueries<T extends any[]>({
+  children,
+  queries
+}: {
+  queries: readonly [...SuspenseQueriesOptions<T>];
+  children: (queries: SuspenseQueriesResults<T>) => ReactNode;
+}): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { SuspenseQueries };
+//# sourceMappingURL=SuspenseQueries.d.cts.map

package/dist/SuspenseQueries.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SuspenseQueries.d.cts","names":[],"sources":["../src/SuspenseQueries.tsx"],"mappings":";;;;;;;;AAoBA;;;;;;;;;;;;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

@@ -1,2 +1,30 @@
-import { t as SuspenseQueries } from "./SuspenseQueries-CF_WoDIW.mjs";
-export { SuspenseQueries };
+import { SuspenseQueriesOptions, SuspenseQueriesResults } from "@tanstack/react-query";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { ReactNode } from "react";
+
+//#region src/SuspenseQueries.d.ts
+/**
+ * We provide these components to clearly express what causes suspense at the same depth.
+ * `<SuspenseQueries/>` serves to make `useSuspenseQueries` easier to use in jsx.
+ * @see {@link https://suspensive.org/docs/react-query/SuspenseQueries Suspensive Docs}
+ * @example
+ * ```tsx
+ * import { SuspenseQueries } from '@suspensive/react-query'
+ *
+ * <SuspenseQueries queries={[firstQueryOptions(), secondQueryOptions()]}>
+ *   {([{ data: firstQueryData }, { data: secondQueryData }]) => {
+ *     return <></>
+ *   }}
+ * </SuspenseQueries>
+ * ```
+ */
+declare function SuspenseQueries<T extends any[]>({
+  children,
+  queries
+}: {
+  queries: readonly [...SuspenseQueriesOptions<T>];
+  children: (queries: SuspenseQueriesResults<T>) => ReactNode;
+}): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { SuspenseQueries };
+//# sourceMappingURL=SuspenseQueries.d.mts.map

package/dist/SuspenseQueries.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SuspenseQueries.d.mts","names":[],"sources":["../src/SuspenseQueries.tsx"],"mappings":";;;;;;;;AAoBA;;;;;;;;;;;;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.mjs

@@ -1,5 +1,28 @@
 'use client';
 
-import { t as SuspenseQueries } from "./SuspenseQueries-C0mF_XD_.mjs";
+import { useSuspenseQueries } from "@tanstack/react-query";
+import { Fragment, jsx } from "react/jsx-runtime";
 
-export { SuspenseQueries };
+//#region src/SuspenseQueries.tsx
+/**
+* We provide these components to clearly express what causes suspense at the same depth.
+* `<SuspenseQueries/>` serves to make `useSuspenseQueries` easier to use in jsx.
+* @see {@link https://suspensive.org/docs/react-query/SuspenseQueries Suspensive Docs}
+* @example
+* ```tsx
+* import { SuspenseQueries } from '@suspensive/react-query'
+*
+* <SuspenseQueries queries={[firstQueryOptions(), secondQueryOptions()]}>
+*   {([{ data: firstQueryData }, { data: secondQueryData }]) => {
+*     return <></>
+*   }}
+* </SuspenseQueries>
+* ```
+*/
+function SuspenseQueries({ children, queries }) {
+	return /* @__PURE__ */ jsx(Fragment, { children: children(useSuspenseQueries({ queries })) });
+}
+
+//#endregion
+export { SuspenseQueries };
+//# sourceMappingURL=SuspenseQueries.mjs.map

package/dist/SuspenseQueries.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SuspenseQueries.mjs","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,EAAI"}