@tanstack/preact-query 5.102.2 → 5.102.4

package/build/legacy/useSuspenseQueries.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"useSuspenseQueries.d.cts","names":[],"sources":["../../src/useSuspenseQueries.ts"],"mappings":";;;KAaK;KAGA;KAEA,2BAA2B,KAE9B;EACE,mBAAmB;EACnB,cAAc;EACd,YAAY;IAEV,wBAAwB,cAAc,QAAQ,SAC9C;EAAY,mBAAmB;EAAc,cAAc;IACzD,wBAAwB,cAAc,UACtC;EAAY,YAAY;EAAO,cAAc;IAC3C,iCAAiC,QAAQ,SAEzC,iBAAiB,oBAAoB,cAAc,SACjD,wBAAwB,cAAc,QAAQ,SAC9C,iBAAiB,oBAAoB,UACnC,wBAAwB,cAAc,UACtC,iBAAiB,gBACf,wBAAwB,gBAExB;EACI,UACI,oBAAoB,oBAAoB,aACxC;EACJ,UAAU,oBAAoB;EAC9B,eAAe,wBAAwB;IAEzC,wBACE,cACA,QACA,OACA,aAEF;EACI,UACI,oBAAoB,oBAAoB,aACxC;EACJ,eAAe,wBAAwB;IAEzC,wBACE,cACA,QACA,cACA,aAGF;KAEf,0BAA0B,KAE7B;EAAY;EAAkB,cAAc;EAAQ,YAAY;IAC5D,uBAAuB,OAAO,UAC9B;EAAY,mBAAmB;EAAc,cAAc;IACzD,uBAAuB,cAAc,UACrC;EAAY,YAAY;EAAO,cAAc;IAC3C,uBAAuB,OAAO,UAE9B,sBAAsB,cAAc,SAClC,uBAAuB,OAAO,UAC9B,iBAAiB,oBAAoB,UACnC,uBAAuB,cAAc,UACrC,iBAAiB,gBACf,uBAAuB,gBAEvB;EACI,UACI,oBAAoB,qBACpB;EACJ,UAAU,oBAAoB;EAC9B,eAAe,wBAAwB;IAEzC,uCACkB,QAAQ,eAAe,uBACvB,SAAS,eAAe,UAE1C;EACI,UACI,oBAAoB,qBACpB;EACJ,eAAe,wBAAwB;IAEzC,uBACE,8BACgB,SAAS,eAAe,UAG1C;;;;KAKR,uBACV,UAAU,YACV,iBAAiB,iBACjB,eAAe,8BACb,yBAAyB,gBACzB,MAAM,2BACN,oBAEE,iBAAiB,YACX,UAAU,2BAA2B,SACzC,iBAAiB,eAAe,SAC9B,2BACM,YACA,UAAU,2BAA2B,YACrC,cAEN,uBAAuB,IACrB,IAGA,UAAU,MACN,8BACQ,oBACA,cACA,aACA,cAGV,MACE,wBAAwB,cAAc,QAAQ,OAAO,cAGvD,MAAM;;;;KAKR,uBACV,UAAU,YACV,iBAAiB,iBACjB,eAAe,8BACb,yBAAyB,gBACzB,MAAM,0BACN,oBAEE,iBAAiB,YACX,UAAU,0BAA0B,SACxC,iBAAiB,eAAe,SAC9B,2BACM,YACA,UAAU,0BAA0B,YACpC,iBAEH,WAAW,IAAI,0BAA0B,EAAE;iBAExC,mBACd,UAAU,YACV,kBAAkB,uBAAuB,IAEzC;EACE,sBACiB,uBAAuB,sBACpB,WAAW,IAAI,2BAA2B,EAAE;EAChE,WAAW,QAAQ,uBAAuB,OAAO;GAEnD,cAAc,cACb;iBAEa,mBACd,UAAU,YACV,kBAAkB,uBAAuB,IAEzC;EACE,sBAAsB,uBAAuB;EAC7C,WAAW,QAAQ,uBAAuB,OAAO;GAEnD,cAAc,cACb"}
+{"version":3,"file":"useSuspenseQueries.d.cts","names":[],"sources":["../../src/useSuspenseQueries.ts"],"mappings":";;;KAaK;KAGA;KAEA,2BAA2B,KAE9B;EACE,mBAAmB;EACnB,cAAc;EACd,YAAY;IAEV,wBAAwB,cAAc,QAAQ,SAC9C;EAAY,mBAAmB;EAAc,cAAc;IACzD,wBAAwB,cAAc,UACtC;EAAY,YAAY;EAAO,cAAc;IAC3C,iCAAiC,QAAQ,SAEzC,iBAAiB,oBAAoB,cAAc,SACjD,wBAAwB,cAAc,QAAQ,SAC9C,iBAAiB,oBAAoB,UACnC,wBAAwB,cAAc,UACtC,iBAAiB,gBACf,wBAAwB,gBAExB;EACI,UACI,oBAAoB,oBAAoB,aACxC;EACJ,UAAU,oBAAoB;EAC9B,eAAe,wBAAwB;IAEzC,wBACE,cACA,QACA,OACA,aAEF;EACI,UACI,oBAAoB,oBAAoB,aACxC;EACJ,eAAe,wBAAwB;IAEzC,wBACE,cACA,QACA,cACA,aAGF;KAEf,0BAA0B,KAE7B;EAAY;EAAkB,cAAc;EAAQ,YAAY;IAC5D,uBAAuB,OAAO,UAC9B;EAAY,mBAAmB;EAAc,cAAc;IACzD,uBAAuB,cAAc,UACrC;EAAY,YAAY;EAAO,cAAc;IAC3C,uBAAuB,OAAO,UAE9B,sBAAsB,cAAc,SAClC,uBAAuB,OAAO,UAC9B,iBAAiB,oBAAoB,UACnC,uBAAuB,cAAc,UACrC,iBAAiB,gBACf,uBAAuB,gBAEvB;EACI,UACI,oBAAoB,qBACpB;EACJ,UAAU,oBAAoB;EAC9B,eAAe,wBAAwB;IAEzC,uCACkB,QAAQ,eAAe,uBACvB,SAAS,eAAe,UAE1C;EACI,UACI,oBAAoB,qBACpB;EACJ,eAAe,wBAAwB;IAEzC,uBACE,8BACgB,SAAS,eAAe,UAG1C;;;;;;;;;;;;;KAcR,uBACV,UAAU,YACV,iBAAiB,iBACjB,eAAe,8BACb,yBAAyB,gBACzB,MAAM,2BACN,oBAEE,iBAAiB,YACX,UAAU,2BAA2B,SACzC,iBAAiB,eAAe,SAC9B,2BACM,YACA,UAAU,2BAA2B,YACrC,cAEN,uBAAuB,IACrB,IAGA,UAAU,MACN,8BACQ,oBACA,cACA,aACA,cAGV,MACE,wBAAwB,cAAc,QAAQ,OAAO,cAGvD,MAAM;;;;;;;;;;;;;KAcR,uBACV,UAAU,YACV,iBAAiB,iBACjB,eAAe,8BACb,yBAAyB,gBACzB,MAAM,0BACN,oBAEE,iBAAiB,YACX,UAAU,0BAA0B,SACxC,iBAAiB,eAAe,SAC9B,2BACM,YACA,UAAU,0BAA0B,YACpC,iBAEH,WAAW,IAAI,0BAA0B,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiDxC,mBACd,UAAU,YACV,kBAAkB,uBAAuB,IAEzC;;;;EAIE,sBACiB,uBAAuB,sBACpB,WAAW,IAAI,2BAA2B,EAAE;;;;;EAKhE,WAAW,QAAQ,uBAAuB,OAAO;GAEnD,cAAc,cACb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiDa,mBACd,UAAU,YACV,kBAAkB,uBAAuB,IAEzC;;;;EAIE,sBAAsB,uBAAuB;;;;;EAK7C,WAAW,QAAQ,uBAAuB,OAAO;GAEnD,cAAc,cACb"}

package/build/legacy/useSuspenseQueries.d.ts

@@ -40,19 +40,145 @@ type GetUseSuspenseQueryResult<T> = T extends {
   throwOnError?: ThrowOnError<any, infer TError, any, any>;
 } ? UseSuspenseQueryResult<TQueryFnData, unknown extends TError ? DefaultError : TError> : UseSuspenseQueryResult;
 /**
- * SuspenseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
+ * The `queries` array accepted by `useSuspenseQueries`. Recursively unwraps each tuple element so every
+ * entry's `queryFn`/`select` are inferred individually, up to 20 elements. An opaque array (e.g. `unknown[]`)
+ * is returned as-is; a non-tuple array of a known element type, or a tuple past 20 elements, falls back to a
+ * single homogeneous {@link UseSuspenseQueryOptions} type.
+ *
+ * @template T - The type of the `queries` array as written at the call site.
+ * @template TResults - The internal accumulator that this type builds during recursion. It is not meant
+ * to be set explicitly.
+ * @template TDepth - The internal recursion-depth counter, checked against the 20-element limit. It is not
+ * meant to be set explicitly.
  */
 type SuspenseQueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseSuspenseQueryOptions> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseSuspenseQueryOptions<Head>] : T extends [infer Head, ...infer Tails] ? SuspenseQueriesOptions<[...Tails], [...TResults, GetUseSuspenseQueryOptions<Head>], [...TDepth, 1]> : Array<unknown> extends T ? T : T extends Array<UseSuspenseQueryOptions<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>> : Array<UseSuspenseQueryOptions>;
 /**
- * SuspenseQueriesResults reducer recursively maps type param to results
+ * The result type returned by `useSuspenseQueries`, when no `combine` is provided. Mirrors
+ * {@link SuspenseQueriesOptions}: each tuple element's result type is inferred individually, up to 20 elements.
+ * A non-tuple array is mapped per-element instead, still inferring each entry individually; only past 20
+ * elements does this fall back to a single homogeneous {@link UseSuspenseQueryResult} type.
+ *
+ * @template T - The type of the `queries` array, as inferred by {@link SuspenseQueriesOptions}.
+ * @template TResults - The internal accumulator that this type builds during recursion. It is not meant
+ * to be set explicitly.
+ * @template TDepth - The internal recursion-depth counter, checked against the 20-element limit. It is not
+ * meant to be set explicitly.
  */
 type SuspenseQueriesResults<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseSuspenseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseSuspenseQueryResult<Head>] : T extends [infer Head, ...infer Tails] ? SuspenseQueriesResults<[...Tails], [...TResults, GetUseSuspenseQueryResult<Head>], [...TDepth, 1]> : { [K in keyof T]: GetUseSuspenseQueryResult<T[K]>; };
+/**
+ * The options for `useSuspenseQueries` are the same as for `useQueries`, except that each `query` can't have
+ * `throwOnError`, `enabled`, or `placeholderData`.
+ *
+ * @param options - The `queries` array to run in Suspense, and an optional `combine` function.
+ * @param queryClient - Use this to provide a custom `QueryClient`. Otherwise, the one from the nearest context
+ * will be used.
+ * @returns The same structure as `useQueries`, except that for each `query`, `data` is guaranteed to be
+ * defined, `isPlaceholderData` is missing, and `status` is either `success` or `error` (with the derived
+ * flags set accordingly).
+ *
+ * Caveat: the component will only re-mount after all queries have finished loading. Hence, if a query has gone
+ * stale in the time it took for all the queries to complete, it will be fetched again at re-mount. To avoid
+ * this, make sure to set a high enough `staleTime`. Cancellation does not work.
+ *
+ * @example
+ * ```tsx
+ * import { Suspense } from 'preact/compat'
+ * import { useSuspenseQueries } from '@tanstack/preact-query'
+ *
+ * function Posts({ ids }: { ids: Array<number> }) {
+ *   // Every result is guaranteed to be defined — no per-query `isPending` check needed.
+ *   const results = useSuspenseQueries({
+ *     queries: ids.map((id) => ({
+ *       queryKey: ['post', id],
+ *       queryFn: () => fetchPost(id),
+ *     })),
+ *   })
+ *
+ *   return (
+ *     <ul>
+ *       {results.map((result) => (
+ *         <li key={result.data.id}>{result.data.title}</li>
+ *       ))}
+ *     </ul>
+ *   )
+ * }
+ *
+ * function App() {
+ *   return (
+ *     <Suspense fallback={<h1>Loading posts...</h1>}>
+ *       <Posts ids={[1, 2, 3]} />
+ *     </Suspense>
+ *   )
+ * }
+ * ```
+ */
 declare function useSuspenseQueries<T extends Array<any>, TCombinedResult = SuspenseQueriesResults<T>>(options: {
+  /**
+   * An array with query option objects identical to `useSuspenseQuery`.
+   */
   queries: readonly [...SuspenseQueriesOptions<T>] | readonly [...{ [K in keyof T]: GetUseSuspenseQueryOptions<T[K]>; }];
+  /**
+   * Use this to combine the results of the queries into a single value. The result will be structurally
+   * shared to be as referentially stable as possible.
+   */
   combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult;
 }, queryClient?: QueryClient): TCombinedResult;
+/**
+ * The options for `useSuspenseQueries` are the same as for `useQueries`, except that each `query` can't have
+ * `throwOnError`, `enabled`, or `placeholderData`.
+ *
+ * @param options - The `queries` array to run in Suspense, and an optional `combine` function.
+ * @param queryClient - Use this to provide a custom `QueryClient`. Otherwise, the one from the nearest context
+ * will be used.
+ * @returns The same structure as `useQueries`, except that for each `query`, `data` is guaranteed to be
+ * defined, `isPlaceholderData` is missing, and `status` is either `success` or `error` (with the derived
+ * flags set accordingly).
+ *
+ * Caveat: the component will only re-mount after all queries have finished loading. Hence, if a query has gone
+ * stale in the time it took for all the queries to complete, it will be fetched again at re-mount. To avoid
+ * this, make sure to set a high enough `staleTime`. Cancellation does not work.
+ *
+ * @example
+ * ```tsx
+ * import { Suspense } from 'preact/compat'
+ * import { useSuspenseQueries } from '@tanstack/preact-query'
+ *
+ * function Posts({ ids }: { ids: Array<number> }) {
+ *   // Every result is guaranteed to be defined — no per-query `isPending` check needed.
+ *   const results = useSuspenseQueries({
+ *     queries: ids.map((id) => ({
+ *       queryKey: ['post', id],
+ *       queryFn: () => fetchPost(id),
+ *     })),
+ *   })
+ *
+ *   return (
+ *     <ul>
+ *       {results.map((result) => (
+ *         <li key={result.data.id}>{result.data.title}</li>
+ *       ))}
+ *     </ul>
+ *   )
+ * }
+ *
+ * function App() {
+ *   return (
+ *     <Suspense fallback={<h1>Loading posts...</h1>}>
+ *       <Posts ids={[1, 2, 3]} />
+ *     </Suspense>
+ *   )
+ * }
+ * ```
+ */
 declare function useSuspenseQueries<T extends Array<any>, TCombinedResult = SuspenseQueriesResults<T>>(options: {
+  /**
+   * An array with query option objects identical to `useSuspenseQuery`.
+   */
   queries: readonly [...SuspenseQueriesOptions<T>];
+  /**
+   * Use this to combine the results of the queries into a single value. The result will be structurally
+   * shared to be as referentially stable as possible.
+   */
   combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult;
 }, queryClient?: QueryClient): TCombinedResult;
 //#endregion

package/build/legacy/useSuspenseQueries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useSuspenseQueries.d.ts","names":[],"sources":["../../src/useSuspenseQueries.ts"],"mappings":";;;KAaK;KAGA;KAEA,2BAA2B,KAE9B;EACE,mBAAmB;EACnB,cAAc;EACd,YAAY;IAEV,wBAAwB,cAAc,QAAQ,SAC9C;EAAY,mBAAmB;EAAc,cAAc;IACzD,wBAAwB,cAAc,UACtC;EAAY,YAAY;EAAO,cAAc;IAC3C,iCAAiC,QAAQ,SAEzC,iBAAiB,oBAAoB,cAAc,SACjD,wBAAwB,cAAc,QAAQ,SAC9C,iBAAiB,oBAAoB,UACnC,wBAAwB,cAAc,UACtC,iBAAiB,gBACf,wBAAwB,gBAExB;EACI,UACI,oBAAoB,oBAAoB,aACxC;EACJ,UAAU,oBAAoB;EAC9B,eAAe,wBAAwB;IAEzC,wBACE,cACA,QACA,OACA,aAEF;EACI,UACI,oBAAoB,oBAAoB,aACxC;EACJ,eAAe,wBAAwB;IAEzC,wBACE,cACA,QACA,cACA,aAGF;KAEf,0BAA0B,KAE7B;EAAY;EAAkB,cAAc;EAAQ,YAAY;IAC5D,uBAAuB,OAAO,UAC9B;EAAY,mBAAmB;EAAc,cAAc;IACzD,uBAAuB,cAAc,UACrC;EAAY,YAAY;EAAO,cAAc;IAC3C,uBAAuB,OAAO,UAE9B,sBAAsB,cAAc,SAClC,uBAAuB,OAAO,UAC9B,iBAAiB,oBAAoB,UACnC,uBAAuB,cAAc,UACrC,iBAAiB,gBACf,uBAAuB,gBAEvB;EACI,UACI,oBAAoB,qBACpB;EACJ,UAAU,oBAAoB;EAC9B,eAAe,wBAAwB;IAEzC,uCACkB,QAAQ,eAAe,uBACvB,SAAS,eAAe,UAE1C;EACI,UACI,oBAAoB,qBACpB;EACJ,eAAe,wBAAwB;IAEzC,uBACE,8BACgB,SAAS,eAAe,UAG1C;;;;KAKR,uBACV,UAAU,YACV,iBAAiB,iBACjB,eAAe,8BACb,yBAAyB,gBACzB,MAAM,2BACN,oBAEE,iBAAiB,YACX,UAAU,2BAA2B,SACzC,iBAAiB,eAAe,SAC9B,2BACM,YACA,UAAU,2BAA2B,YACrC,cAEN,uBAAuB,IACrB,IAGA,UAAU,MACN,8BACQ,oBACA,cACA,aACA,cAGV,MACE,wBAAwB,cAAc,QAAQ,OAAO,cAGvD,MAAM;;;;KAKR,uBACV,UAAU,YACV,iBAAiB,iBACjB,eAAe,8BACb,yBAAyB,gBACzB,MAAM,0BACN,oBAEE,iBAAiB,YACX,UAAU,0BAA0B,SACxC,iBAAiB,eAAe,SAC9B,2BACM,YACA,UAAU,0BAA0B,YACpC,iBAEH,WAAW,IAAI,0BAA0B,EAAE;iBAExC,mBACd,UAAU,YACV,kBAAkB,uBAAuB,IAEzC;EACE,sBACiB,uBAAuB,sBACpB,WAAW,IAAI,2BAA2B,EAAE;EAChE,WAAW,QAAQ,uBAAuB,OAAO;GAEnD,cAAc,cACb;iBAEa,mBACd,UAAU,YACV,kBAAkB,uBAAuB,IAEzC;EACE,sBAAsB,uBAAuB;EAC7C,WAAW,QAAQ,uBAAuB,OAAO;GAEnD,cAAc,cACb"}
+{"version":3,"file":"useSuspenseQueries.d.ts","names":[],"sources":["../../src/useSuspenseQueries.ts"],"mappings":";;;KAaK;KAGA;KAEA,2BAA2B,KAE9B;EACE,mBAAmB;EACnB,cAAc;EACd,YAAY;IAEV,wBAAwB,cAAc,QAAQ,SAC9C;EAAY,mBAAmB;EAAc,cAAc;IACzD,wBAAwB,cAAc,UACtC;EAAY,YAAY;EAAO,cAAc;IAC3C,iCAAiC,QAAQ,SAEzC,iBAAiB,oBAAoB,cAAc,SACjD,wBAAwB,cAAc,QAAQ,SAC9C,iBAAiB,oBAAoB,UACnC,wBAAwB,cAAc,UACtC,iBAAiB,gBACf,wBAAwB,gBAExB;EACI,UACI,oBAAoB,oBAAoB,aACxC;EACJ,UAAU,oBAAoB;EAC9B,eAAe,wBAAwB;IAEzC,wBACE,cACA,QACA,OACA,aAEF;EACI,UACI,oBAAoB,oBAAoB,aACxC;EACJ,eAAe,wBAAwB;IAEzC,wBACE,cACA,QACA,cACA,aAGF;KAEf,0BAA0B,KAE7B;EAAY;EAAkB,cAAc;EAAQ,YAAY;IAC5D,uBAAuB,OAAO,UAC9B;EAAY,mBAAmB;EAAc,cAAc;IACzD,uBAAuB,cAAc,UACrC;EAAY,YAAY;EAAO,cAAc;IAC3C,uBAAuB,OAAO,UAE9B,sBAAsB,cAAc,SAClC,uBAAuB,OAAO,UAC9B,iBAAiB,oBAAoB,UACnC,uBAAuB,cAAc,UACrC,iBAAiB,gBACf,uBAAuB,gBAEvB;EACI,UACI,oBAAoB,qBACpB;EACJ,UAAU,oBAAoB;EAC9B,eAAe,wBAAwB;IAEzC,uCACkB,QAAQ,eAAe,uBACvB,SAAS,eAAe,UAE1C;EACI,UACI,oBAAoB,qBACpB;EACJ,eAAe,wBAAwB;IAEzC,uBACE,8BACgB,SAAS,eAAe,UAG1C;;;;;;;;;;;;;KAcR,uBACV,UAAU,YACV,iBAAiB,iBACjB,eAAe,8BACb,yBAAyB,gBACzB,MAAM,2BACN,oBAEE,iBAAiB,YACX,UAAU,2BAA2B,SACzC,iBAAiB,eAAe,SAC9B,2BACM,YACA,UAAU,2BAA2B,YACrC,cAEN,uBAAuB,IACrB,IAGA,UAAU,MACN,8BACQ,oBACA,cACA,aACA,cAGV,MACE,wBAAwB,cAAc,QAAQ,OAAO,cAGvD,MAAM;;;;;;;;;;;;;KAcR,uBACV,UAAU,YACV,iBAAiB,iBACjB,eAAe,8BACb,yBAAyB,gBACzB,MAAM,0BACN,oBAEE,iBAAiB,YACX,UAAU,0BAA0B,SACxC,iBAAiB,eAAe,SAC9B,2BACM,YACA,UAAU,0BAA0B,YACpC,iBAEH,WAAW,IAAI,0BAA0B,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiDxC,mBACd,UAAU,YACV,kBAAkB,uBAAuB,IAEzC;;;;EAIE,sBACiB,uBAAuB,sBACpB,WAAW,IAAI,2BAA2B,EAAE;;;;;EAKhE,WAAW,QAAQ,uBAAuB,OAAO;GAEnD,cAAc,cACb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiDa,mBACd,UAAU,YACV,kBAAkB,uBAAuB,IAEzC;;;;EAIE,sBAAsB,uBAAuB;;;;;EAK7C,WAAW,QAAQ,uBAAuB,OAAO;GAEnD,cAAc,cACb"}

package/build/legacy/useSuspenseQueries.js.map

@@ -1 +1 @@
-{"version":3,"file":"useSuspenseQueries.js","names":[],"sources":["../../src/useSuspenseQueries.ts"],"sourcesContent":["import { skipToken } from '@tanstack/query-core'\nimport type {\n  DefaultError,\n  QueryClient,\n  QueryFunction,\n  ThrowOnError,\n} from '@tanstack/query-core'\n\nimport { defaultThrowOnError } from './suspense'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'\nimport { useQueries } from './useQueries'\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForUseQueries = symbol\n\ntype GetUseSuspenseQueryOptions<T> =\n  // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n  T extends {\n    queryFnData: infer TQueryFnData\n    error?: infer TError\n    data: infer TData\n  }\n    ? UseSuspenseQueryOptions<TQueryFnData, TError, TData>\n    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n      ? UseSuspenseQueryOptions<TQueryFnData, TError>\n      : T extends { data: infer TData; error?: infer TError }\n        ? UseSuspenseQueryOptions<unknown, TError, TData>\n        : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n          T extends [infer TQueryFnData, infer TError, infer TData]\n          ? UseSuspenseQueryOptions<TQueryFnData, TError, TData>\n          : T extends [infer TQueryFnData, infer TError]\n            ? UseSuspenseQueryOptions<TQueryFnData, TError>\n            : T extends [infer TQueryFnData]\n              ? UseSuspenseQueryOptions<TQueryFnData>\n              : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n                T extends {\n                    queryFn?:\n                      | QueryFunction<infer TQueryFnData, infer TQueryKey>\n                      | SkipTokenForUseQueries\n                    select?: (data: any) => infer TData\n                    throwOnError?: ThrowOnError<any, infer TError, any, any>\n                  }\n                ? UseSuspenseQueryOptions<\n                    TQueryFnData,\n                    TError,\n                    TData,\n                    TQueryKey\n                  >\n                : T extends {\n                      queryFn?:\n                        | QueryFunction<infer TQueryFnData, infer TQueryKey>\n                        | SkipTokenForUseQueries\n                      throwOnError?: ThrowOnError<any, infer TError, any, any>\n                    }\n                  ? UseSuspenseQueryOptions<\n                      TQueryFnData,\n                      TError,\n                      TQueryFnData,\n                      TQueryKey\n                    >\n                  : // Fallback\n                    UseSuspenseQueryOptions\n\ntype GetUseSuspenseQueryResult<T> =\n  // Part 1: responsible for mapping explicit type parameter to function result, if object\n  T extends { queryFnData: any; error?: infer TError; data: infer TData }\n    ? UseSuspenseQueryResult<TData, TError>\n    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n      ? UseSuspenseQueryResult<TQueryFnData, TError>\n      : T extends { data: infer TData; error?: infer TError }\n        ? UseSuspenseQueryResult<TData, TError>\n        : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n          T extends [any, infer TError, infer TData]\n          ? UseSuspenseQueryResult<TData, TError>\n          : T extends [infer TQueryFnData, infer TError]\n            ? UseSuspenseQueryResult<TQueryFnData, TError>\n            : T extends [infer TQueryFnData]\n              ? UseSuspenseQueryResult<TQueryFnData>\n              : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n                T extends {\n                    queryFn?:\n                      | QueryFunction<infer TQueryFnData, any>\n                      | SkipTokenForUseQueries\n                    select?: (data: any) => infer TData\n                    throwOnError?: ThrowOnError<any, infer TError, any, any>\n                  }\n                ? UseSuspenseQueryResult<\n                    unknown extends TData ? TQueryFnData : TData,\n                    unknown extends TError ? DefaultError : TError\n                  >\n                : T extends {\n                      queryFn?:\n                        | QueryFunction<infer TQueryFnData, any>\n                        | SkipTokenForUseQueries\n                      throwOnError?: ThrowOnError<any, infer TError, any, any>\n                    }\n                  ? UseSuspenseQueryResult<\n                      TQueryFnData,\n                      unknown extends TError ? DefaultError : TError\n                    >\n                  : // Fallback\n                    UseSuspenseQueryResult\n\n/**\n * SuspenseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param\n */\nexport type SuspenseQueriesOptions<\n  T extends Array<any>,\n  TResults extends Array<any> = [],\n  TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n  ? Array<UseSuspenseQueryOptions>\n  : T extends []\n    ? []\n    : T extends [infer Head]\n      ? [...TResults, GetUseSuspenseQueryOptions<Head>]\n      : T extends [infer Head, ...infer Tails]\n        ? SuspenseQueriesOptions<\n            [...Tails],\n            [...TResults, GetUseSuspenseQueryOptions<Head>],\n            [...TDepth, 1]\n          >\n        : Array<unknown> extends T\n          ? T\n          : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogeneous type!\n            // use this to infer the param types in the case of Array.map() argument\n            T extends Array<\n                UseSuspenseQueryOptions<\n                  infer TQueryFnData,\n                  infer TError,\n                  infer TData,\n                  infer TQueryKey\n                >\n              >\n            ? Array<\n                UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>\n              >\n            : // Fallback\n              Array<UseSuspenseQueryOptions>\n\n/**\n * SuspenseQueriesResults reducer recursively maps type param to results\n */\nexport type SuspenseQueriesResults<\n  T extends Array<any>,\n  TResults extends Array<any> = [],\n  TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n  ? Array<UseSuspenseQueryResult>\n  : T extends []\n    ? []\n    : T extends [infer Head]\n      ? [...TResults, GetUseSuspenseQueryResult<Head>]\n      : T extends [infer Head, ...infer Tails]\n        ? SuspenseQueriesResults<\n            [...Tails],\n            [...TResults, GetUseSuspenseQueryResult<Head>],\n            [...TDepth, 1]\n          >\n        : { [K in keyof T]: GetUseSuspenseQueryResult<T[K]> }\n\nexport function useSuspenseQueries<\n  T extends Array<any>,\n  TCombinedResult = SuspenseQueriesResults<T>,\n>(\n  options: {\n    queries:\n      | readonly [...SuspenseQueriesOptions<T>]\n      | readonly [...{ [K in keyof T]: GetUseSuspenseQueryOptions<T[K]> }]\n    combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult\n  },\n  queryClient?: QueryClient,\n): TCombinedResult\n\nexport function useSuspenseQueries<\n  T extends Array<any>,\n  TCombinedResult = SuspenseQueriesResults<T>,\n>(\n  options: {\n    queries: readonly [...SuspenseQueriesOptions<T>]\n    combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult\n  },\n  queryClient?: QueryClient,\n): TCombinedResult\n\nexport function useSuspenseQueries(options: any, queryClient?: QueryClient) {\n  return useQueries(\n    {\n      ...options,\n      queries: options.queries.map((query: any) => {\n        if (process.env.NODE_ENV !== 'production') {\n          if (query.queryFn === skipToken) {\n            console.error('skipToken is not allowed for useSuspenseQueries')\n          }\n        }\n\n        return {\n          ...query,\n          suspense: true,\n          throwOnError: defaultThrowOnError,\n          enabled: true,\n          placeholderData: undefined,\n        }\n      }),\n    },\n    queryClient,\n  )\n}\n"],"mappings":";;;;AA4LA,SAAgB,mBAAmB,SAAc,aAA2B;CAC1E,OAAO,WACL;EACE,GAAG;EACH,SAAS,QAAQ,QAAQ,KAAK,UAAe;GAC3C,IAAI,QAAQ,IAAI,aAAa,cACvB;QAAA,MAAM,YAAY,WACpB,QAAQ,MAAM,iDAAiD;GAAA;GAInE,OAAO;IACL,GAAG;IACH,UAAU;IACV,cAAc;IACd,SAAS;IACT,iBAAiB,KAAA;GACnB;EACF,CAAC;CACH,GACA,WACF;AACF"}
+{"version":3,"file":"useSuspenseQueries.js","names":[],"sources":["../../src/useSuspenseQueries.ts"],"sourcesContent":["import { skipToken } from '@tanstack/query-core'\nimport type {\n  DefaultError,\n  QueryClient,\n  QueryFunction,\n  ThrowOnError,\n} from '@tanstack/query-core'\n\nimport { defaultThrowOnError } from './suspense'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'\nimport { useQueries } from './useQueries'\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForUseQueries = symbol\n\ntype GetUseSuspenseQueryOptions<T> =\n  // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n  T extends {\n    queryFnData: infer TQueryFnData\n    error?: infer TError\n    data: infer TData\n  }\n    ? UseSuspenseQueryOptions<TQueryFnData, TError, TData>\n    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n      ? UseSuspenseQueryOptions<TQueryFnData, TError>\n      : T extends { data: infer TData; error?: infer TError }\n        ? UseSuspenseQueryOptions<unknown, TError, TData>\n        : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n          T extends [infer TQueryFnData, infer TError, infer TData]\n          ? UseSuspenseQueryOptions<TQueryFnData, TError, TData>\n          : T extends [infer TQueryFnData, infer TError]\n            ? UseSuspenseQueryOptions<TQueryFnData, TError>\n            : T extends [infer TQueryFnData]\n              ? UseSuspenseQueryOptions<TQueryFnData>\n              : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n                T extends {\n                    queryFn?:\n                      | QueryFunction<infer TQueryFnData, infer TQueryKey>\n                      | SkipTokenForUseQueries\n                    select?: (data: any) => infer TData\n                    throwOnError?: ThrowOnError<any, infer TError, any, any>\n                  }\n                ? UseSuspenseQueryOptions<\n                    TQueryFnData,\n                    TError,\n                    TData,\n                    TQueryKey\n                  >\n                : T extends {\n                      queryFn?:\n                        | QueryFunction<infer TQueryFnData, infer TQueryKey>\n                        | SkipTokenForUseQueries\n                      throwOnError?: ThrowOnError<any, infer TError, any, any>\n                    }\n                  ? UseSuspenseQueryOptions<\n                      TQueryFnData,\n                      TError,\n                      TQueryFnData,\n                      TQueryKey\n                    >\n                  : // Fallback\n                    UseSuspenseQueryOptions\n\ntype GetUseSuspenseQueryResult<T> =\n  // Part 1: responsible for mapping explicit type parameter to function result, if object\n  T extends { queryFnData: any; error?: infer TError; data: infer TData }\n    ? UseSuspenseQueryResult<TData, TError>\n    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n      ? UseSuspenseQueryResult<TQueryFnData, TError>\n      : T extends { data: infer TData; error?: infer TError }\n        ? UseSuspenseQueryResult<TData, TError>\n        : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n          T extends [any, infer TError, infer TData]\n          ? UseSuspenseQueryResult<TData, TError>\n          : T extends [infer TQueryFnData, infer TError]\n            ? UseSuspenseQueryResult<TQueryFnData, TError>\n            : T extends [infer TQueryFnData]\n              ? UseSuspenseQueryResult<TQueryFnData>\n              : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n                T extends {\n                    queryFn?:\n                      | QueryFunction<infer TQueryFnData, any>\n                      | SkipTokenForUseQueries\n                    select?: (data: any) => infer TData\n                    throwOnError?: ThrowOnError<any, infer TError, any, any>\n                  }\n                ? UseSuspenseQueryResult<\n                    unknown extends TData ? TQueryFnData : TData,\n                    unknown extends TError ? DefaultError : TError\n                  >\n                : T extends {\n                      queryFn?:\n                        | QueryFunction<infer TQueryFnData, any>\n                        | SkipTokenForUseQueries\n                      throwOnError?: ThrowOnError<any, infer TError, any, any>\n                    }\n                  ? UseSuspenseQueryResult<\n                      TQueryFnData,\n                      unknown extends TError ? DefaultError : TError\n                    >\n                  : // Fallback\n                    UseSuspenseQueryResult\n\n/**\n * The `queries` array accepted by `useSuspenseQueries`. Recursively unwraps each tuple element so every\n * entry's `queryFn`/`select` are inferred individually, up to 20 elements. An opaque array (e.g. `unknown[]`)\n * is returned as-is; a non-tuple array of a known element type, or a tuple past 20 elements, falls back to a\n * single homogeneous {@link UseSuspenseQueryOptions} type.\n *\n * @template T - The type of the `queries` array as written at the call site.\n * @template TResults - The internal accumulator that this type builds during recursion. It is not meant\n * to be set explicitly.\n * @template TDepth - The internal recursion-depth counter, checked against the 20-element limit. It is not\n * meant to be set explicitly.\n */\nexport type SuspenseQueriesOptions<\n  T extends Array<any>,\n  TResults extends Array<any> = [],\n  TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n  ? Array<UseSuspenseQueryOptions>\n  : T extends []\n    ? []\n    : T extends [infer Head]\n      ? [...TResults, GetUseSuspenseQueryOptions<Head>]\n      : T extends [infer Head, ...infer Tails]\n        ? SuspenseQueriesOptions<\n            [...Tails],\n            [...TResults, GetUseSuspenseQueryOptions<Head>],\n            [...TDepth, 1]\n          >\n        : Array<unknown> extends T\n          ? T\n          : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogeneous type!\n            // use this to infer the param types in the case of Array.map() argument\n            T extends Array<\n                UseSuspenseQueryOptions<\n                  infer TQueryFnData,\n                  infer TError,\n                  infer TData,\n                  infer TQueryKey\n                >\n              >\n            ? Array<\n                UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>\n              >\n            : // Fallback\n              Array<UseSuspenseQueryOptions>\n\n/**\n * The result type returned by `useSuspenseQueries`, when no `combine` is provided. Mirrors\n * {@link SuspenseQueriesOptions}: each tuple element's result type is inferred individually, up to 20 elements.\n * A non-tuple array is mapped per-element instead, still inferring each entry individually; only past 20\n * elements does this fall back to a single homogeneous {@link UseSuspenseQueryResult} type.\n *\n * @template T - The type of the `queries` array, as inferred by {@link SuspenseQueriesOptions}.\n * @template TResults - The internal accumulator that this type builds during recursion. It is not meant\n * to be set explicitly.\n * @template TDepth - The internal recursion-depth counter, checked against the 20-element limit. It is not\n * meant to be set explicitly.\n */\nexport type SuspenseQueriesResults<\n  T extends Array<any>,\n  TResults extends Array<any> = [],\n  TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n  ? Array<UseSuspenseQueryResult>\n  : T extends []\n    ? []\n    : T extends [infer Head]\n      ? [...TResults, GetUseSuspenseQueryResult<Head>]\n      : T extends [infer Head, ...infer Tails]\n        ? SuspenseQueriesResults<\n            [...Tails],\n            [...TResults, GetUseSuspenseQueryResult<Head>],\n            [...TDepth, 1]\n          >\n        : { [K in keyof T]: GetUseSuspenseQueryResult<T[K]> }\n\n/**\n * The options for `useSuspenseQueries` are the same as for `useQueries`, except that each `query` can't have\n * `throwOnError`, `enabled`, or `placeholderData`.\n *\n * @param options - The `queries` array to run in Suspense, and an optional `combine` function.\n * @param queryClient - Use this to provide a custom `QueryClient`. Otherwise, the one from the nearest context\n * will be used.\n * @returns The same structure as `useQueries`, except that for each `query`, `data` is guaranteed to be\n * defined, `isPlaceholderData` is missing, and `status` is either `success` or `error` (with the derived\n * flags set accordingly).\n *\n * Caveat: the component will only re-mount after all queries have finished loading. Hence, if a query has gone\n * stale in the time it took for all the queries to complete, it will be fetched again at re-mount. To avoid\n * this, make sure to set a high enough `staleTime`. Cancellation does not work.\n *\n * @example\n * ```tsx\n * import { Suspense } from 'preact/compat'\n * import { useSuspenseQueries } from '@tanstack/preact-query'\n *\n * function Posts({ ids }: { ids: Array<number> }) {\n *   // Every result is guaranteed to be defined — no per-query `isPending` check needed.\n *   const results = useSuspenseQueries({\n *     queries: ids.map((id) => ({\n *       queryKey: ['post', id],\n *       queryFn: () => fetchPost(id),\n *     })),\n *   })\n *\n *   return (\n *     <ul>\n *       {results.map((result) => (\n *         <li key={result.data.id}>{result.data.title}</li>\n *       ))}\n *     </ul>\n *   )\n * }\n *\n * function App() {\n *   return (\n *     <Suspense fallback={<h1>Loading posts...</h1>}>\n *       <Posts ids={[1, 2, 3]} />\n *     </Suspense>\n *   )\n * }\n * ```\n */\nexport function useSuspenseQueries<\n  T extends Array<any>,\n  TCombinedResult = SuspenseQueriesResults<T>,\n>(\n  options: {\n    /**\n     * An array with query option objects identical to `useSuspenseQuery`.\n     */\n    queries:\n      | readonly [...SuspenseQueriesOptions<T>]\n      | readonly [...{ [K in keyof T]: GetUseSuspenseQueryOptions<T[K]> }]\n    /**\n     * Use this to combine the results of the queries into a single value. The result will be structurally\n     * shared to be as referentially stable as possible.\n     */\n    combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult\n  },\n  queryClient?: QueryClient,\n): TCombinedResult\n\n/**\n * The options for `useSuspenseQueries` are the same as for `useQueries`, except that each `query` can't have\n * `throwOnError`, `enabled`, or `placeholderData`.\n *\n * @param options - The `queries` array to run in Suspense, and an optional `combine` function.\n * @param queryClient - Use this to provide a custom `QueryClient`. Otherwise, the one from the nearest context\n * will be used.\n * @returns The same structure as `useQueries`, except that for each `query`, `data` is guaranteed to be\n * defined, `isPlaceholderData` is missing, and `status` is either `success` or `error` (with the derived\n * flags set accordingly).\n *\n * Caveat: the component will only re-mount after all queries have finished loading. Hence, if a query has gone\n * stale in the time it took for all the queries to complete, it will be fetched again at re-mount. To avoid\n * this, make sure to set a high enough `staleTime`. Cancellation does not work.\n *\n * @example\n * ```tsx\n * import { Suspense } from 'preact/compat'\n * import { useSuspenseQueries } from '@tanstack/preact-query'\n *\n * function Posts({ ids }: { ids: Array<number> }) {\n *   // Every result is guaranteed to be defined — no per-query `isPending` check needed.\n *   const results = useSuspenseQueries({\n *     queries: ids.map((id) => ({\n *       queryKey: ['post', id],\n *       queryFn: () => fetchPost(id),\n *     })),\n *   })\n *\n *   return (\n *     <ul>\n *       {results.map((result) => (\n *         <li key={result.data.id}>{result.data.title}</li>\n *       ))}\n *     </ul>\n *   )\n * }\n *\n * function App() {\n *   return (\n *     <Suspense fallback={<h1>Loading posts...</h1>}>\n *       <Posts ids={[1, 2, 3]} />\n *     </Suspense>\n *   )\n * }\n * ```\n */\nexport function useSuspenseQueries<\n  T extends Array<any>,\n  TCombinedResult = SuspenseQueriesResults<T>,\n>(\n  options: {\n    /**\n     * An array with query option objects identical to `useSuspenseQuery`.\n     */\n    queries: readonly [...SuspenseQueriesOptions<T>]\n    /**\n     * Use this to combine the results of the queries into a single value. The result will be structurally\n     * shared to be as referentially stable as possible.\n     */\n    combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult\n  },\n  queryClient?: QueryClient,\n): TCombinedResult\n\nexport function useSuspenseQueries(options: any, queryClient?: QueryClient) {\n  return useQueries(\n    {\n      ...options,\n      queries: options.queries.map((query: any) => {\n        if (process.env.NODE_ENV !== 'production') {\n          if (query.queryFn === skipToken) {\n            console.error('skipToken is not allowed for useSuspenseQueries')\n          }\n        }\n\n        return {\n          ...query,\n          suspense: true,\n          throwOnError: defaultThrowOnError,\n          enabled: true,\n          placeholderData: undefined,\n        }\n      }),\n    },\n    queryClient,\n  )\n}\n"],"mappings":";;;;AA0TA,SAAgB,mBAAmB,SAAc,aAA2B;CAC1E,OAAO,WACL;EACE,GAAG;EACH,SAAS,QAAQ,QAAQ,KAAK,UAAe;GAC3C,IAAI,QAAQ,IAAI,aAAa,cACvB;QAAA,MAAM,YAAY,WACpB,QAAQ,MAAM,iDAAiD;GAAA;GAInE,OAAO;IACL,GAAG;IACH,UAAU;IACV,cAAc;IACd,SAAS;IACT,iBAAiB,KAAA;GACnB;EACF,CAAC;CACH,GACA,WACF;AACF"}

package/build/legacy/useSuspenseQuery.cjs

@@ -3,6 +3,49 @@ const require_suspense = require("./suspense.cjs");
 const require_useBaseQuery = require("./useBaseQuery.cjs");
 let _tanstack_query_core = require("@tanstack/query-core");
 //#region src/useSuspenseQuery.ts
+/**
+* The options for `useSuspenseQuery` are the same as for `useQuery`, except for `throwOnError`, `enabled`, and
+* `placeholderData`.
+*
+* Caveat: cancellation does not work.
+*
+* @param options - The {@link UseSuspenseQueryOptions} to use — the same options as `useQuery`, minus the ones listed above.
+* @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will
+* be used.
+* @returns The same object as `useQuery`, except that `data` is guaranteed to be defined, `isPlaceholderData`
+* is missing, and `status` is either `success` or `error` (with the derived flags set accordingly).
+*
+* @example
+* ```tsx
+* import { Suspense } from 'preact/compat'
+* import { useSuspenseQuery } from '@tanstack/preact-query'
+*
+* function Posts() {
+*   // `data` is guaranteed to be defined here — no `isPending` check needed.
+*   const { data, isFetching } = useSuspenseQuery({
+*     queryKey: ['posts'],
+*     queryFn: fetchPosts,
+*   })
+*
+*   return (
+*     <div>
+*       <h1>Posts {isFetching ? <Spinner /> : null}</h1>
+*       {data.map((post) => (
+*         <p key={post.id}>{post.title}</p>
+*       ))}
+*     </div>
+*   )
+* }
+*
+* function App() {
+*   return (
+*     <Suspense fallback={<h1>Loading posts...</h1>}>
+*       <Posts />
+*     </Suspense>
+*   )
+* }
+* ```
+*/
 function useSuspenseQuery(options, queryClient) {
 	if (process.env.NODE_ENV !== "production") {
 		if (options.queryFn === _tanstack_query_core.skipToken) console.error("skipToken is not allowed for useSuspenseQuery");

package/build/legacy/useSuspenseQuery.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useSuspenseQuery.cjs","names":["skipToken","useBaseQuery","defaultThrowOnError","QueryObserver"],"sources":["../../src/useSuspenseQuery.ts"],"sourcesContent":["import { QueryObserver, skipToken } from '@tanstack/query-core'\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\n\nimport { defaultThrowOnError } from './suspense'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'\nimport { useBaseQuery } from './useBaseQuery'\n\nexport function useSuspenseQuery<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n  queryClient?: QueryClient,\n): UseSuspenseQueryResult<TData, TError> {\n  if (process.env.NODE_ENV !== 'production') {\n    if ((options.queryFn as any) === skipToken) {\n      console.error('skipToken is not allowed for useSuspenseQuery')\n    }\n  }\n\n  return useBaseQuery(\n    {\n      ...options,\n      enabled: true,\n      suspense: true,\n      throwOnError: defaultThrowOnError,\n      placeholderData: undefined,\n    },\n    QueryObserver,\n    queryClient,\n  ) as UseSuspenseQueryResult<TData, TError>\n}\n"],"mappings":";;;;;AAOA,SAAgB,iBAMd,SACA,aACuC;CACvC,IAAI,QAAQ,IAAI,aAAa,cACtB;MAAA,QAAQ,YAAoBA,qBAAAA,WAC/B,QAAQ,MAAM,+CAA+C;CAAA;CAIjE,OAAOC,qBAAAA,aACL;EACE,GAAG;EACH,SAAS;EACT,UAAU;EACV,cAAcC,iBAAAA;EACd,iBAAiB,KAAA;CACnB,GACAC,qBAAAA,eACA,WACF;AACF"}
+{"version":3,"file":"useSuspenseQuery.cjs","names":["skipToken","useBaseQuery","defaultThrowOnError","QueryObserver"],"sources":["../../src/useSuspenseQuery.ts"],"sourcesContent":["import { QueryObserver, skipToken } from '@tanstack/query-core'\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\n\nimport { defaultThrowOnError } from './suspense'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'\nimport { useBaseQuery } from './useBaseQuery'\n\n/**\n * The options for `useSuspenseQuery` are the same as for `useQuery`, except for `throwOnError`, `enabled`, and\n * `placeholderData`.\n *\n * Caveat: cancellation does not work.\n *\n * @param options - The {@link UseSuspenseQueryOptions} to use — the same options as `useQuery`, minus the ones listed above.\n * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will\n * be used.\n * @returns The same object as `useQuery`, except that `data` is guaranteed to be defined, `isPlaceholderData`\n * is missing, and `status` is either `success` or `error` (with the derived flags set accordingly).\n *\n * @example\n * ```tsx\n * import { Suspense } from 'preact/compat'\n * import { useSuspenseQuery } from '@tanstack/preact-query'\n *\n * function Posts() {\n *   // `data` is guaranteed to be defined here — no `isPending` check needed.\n *   const { data, isFetching } = useSuspenseQuery({\n *     queryKey: ['posts'],\n *     queryFn: fetchPosts,\n *   })\n *\n *   return (\n *     <div>\n *       <h1>Posts {isFetching ? <Spinner /> : null}</h1>\n *       {data.map((post) => (\n *         <p key={post.id}>{post.title}</p>\n *       ))}\n *     </div>\n *   )\n * }\n *\n * function App() {\n *   return (\n *     <Suspense fallback={<h1>Loading posts...</h1>}>\n *       <Posts />\n *     </Suspense>\n *   )\n * }\n * ```\n */\nexport function useSuspenseQuery<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n  queryClient?: QueryClient,\n): UseSuspenseQueryResult<TData, TError> {\n  if (process.env.NODE_ENV !== 'production') {\n    if ((options.queryFn as any) === skipToken) {\n      console.error('skipToken is not allowed for useSuspenseQuery')\n    }\n  }\n\n  return useBaseQuery(\n    {\n      ...options,\n      enabled: true,\n      suspense: true,\n      throwOnError: defaultThrowOnError,\n      placeholderData: undefined,\n    },\n    QueryObserver,\n    queryClient,\n  ) as UseSuspenseQueryResult<TData, TError>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,SAAgB,iBAMd,SACA,aACuC;CACvC,IAAI,QAAQ,IAAI,aAAa,cACtB;MAAA,QAAQ,YAAoBA,qBAAAA,WAC/B,QAAQ,MAAM,+CAA+C;CAAA;CAIjE,OAAOC,qBAAAA,aACL;EACE,GAAG;EACH,SAAS;EACT,UAAU;EACV,cAAcC,iBAAAA;EACd,iBAAiB,KAAA;CACnB,GACAC,qBAAAA,eACA,WACF;AACF"}

package/build/legacy/useSuspenseQuery.d.cts

@@ -1,6 +1,49 @@
 import { UseSuspenseQueryOptions, UseSuspenseQueryResult } from "./types.cjs";
 import { DefaultError, QueryClient, QueryKey } from "@tanstack/query-core";
 //#region src/useSuspenseQuery.d.ts
+/**
+ * The options for `useSuspenseQuery` are the same as for `useQuery`, except for `throwOnError`, `enabled`, and
+ * `placeholderData`.
+ *
+ * Caveat: cancellation does not work.
+ *
+ * @param options - The {@link UseSuspenseQueryOptions} to use — the same options as `useQuery`, minus the ones listed above.
+ * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will
+ * be used.
+ * @returns The same object as `useQuery`, except that `data` is guaranteed to be defined, `isPlaceholderData`
+ * is missing, and `status` is either `success` or `error` (with the derived flags set accordingly).
+ *
+ * @example
+ * ```tsx
+ * import { Suspense } from 'preact/compat'
+ * import { useSuspenseQuery } from '@tanstack/preact-query'
+ *
+ * function Posts() {
+ *   // `data` is guaranteed to be defined here — no `isPending` check needed.
+ *   const { data, isFetching } = useSuspenseQuery({
+ *     queryKey: ['posts'],
+ *     queryFn: fetchPosts,
+ *   })
+ *
+ *   return (
+ *     <div>
+ *       <h1>Posts {isFetching ? <Spinner /> : null}</h1>
+ *       {data.map((post) => (
+ *         <p key={post.id}>{post.title}</p>
+ *       ))}
+ *     </div>
+ *   )
+ * }
+ *
+ * function App() {
+ *   return (
+ *     <Suspense fallback={<h1>Loading posts...</h1>}>
+ *       <Posts />
+ *     </Suspense>
+ *   )
+ * }
+ * ```
+ */
 declare function useSuspenseQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseSuspenseQueryResult<TData, TError>;
 //#endregion
 export { useSuspenseQuery };

package/build/legacy/useSuspenseQuery.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"useSuspenseQuery.d.cts","names":[],"sources":["../../src/useSuspenseQuery.ts"],"mappings":";;;iBAOgB,iBACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,wBAAwB,cAAc,QAAQ,OAAO,YAC9D,cAAc,cACb,uBAAuB,OAAO"}
+{"version":3,"file":"useSuspenseQuery.d.cts","names":[],"sources":["../../src/useSuspenseQuery.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkDgB,iBACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,wBAAwB,cAAc,QAAQ,OAAO,YAC9D,cAAc,cACb,uBAAuB,OAAO"}

package/build/legacy/useSuspenseQuery.d.ts

@@ -1,6 +1,49 @@
 import { UseSuspenseQueryOptions, UseSuspenseQueryResult } from "./types.js";
 import { DefaultError, QueryClient, QueryKey } from "@tanstack/query-core";
 //#region src/useSuspenseQuery.d.ts
+/**
+ * The options for `useSuspenseQuery` are the same as for `useQuery`, except for `throwOnError`, `enabled`, and
+ * `placeholderData`.
+ *
+ * Caveat: cancellation does not work.
+ *
+ * @param options - The {@link UseSuspenseQueryOptions} to use — the same options as `useQuery`, minus the ones listed above.
+ * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will
+ * be used.
+ * @returns The same object as `useQuery`, except that `data` is guaranteed to be defined, `isPlaceholderData`
+ * is missing, and `status` is either `success` or `error` (with the derived flags set accordingly).
+ *
+ * @example
+ * ```tsx
+ * import { Suspense } from 'preact/compat'
+ * import { useSuspenseQuery } from '@tanstack/preact-query'
+ *
+ * function Posts() {
+ *   // `data` is guaranteed to be defined here — no `isPending` check needed.
+ *   const { data, isFetching } = useSuspenseQuery({
+ *     queryKey: ['posts'],
+ *     queryFn: fetchPosts,
+ *   })
+ *
+ *   return (
+ *     <div>
+ *       <h1>Posts {isFetching ? <Spinner /> : null}</h1>
+ *       {data.map((post) => (
+ *         <p key={post.id}>{post.title}</p>
+ *       ))}
+ *     </div>
+ *   )
+ * }
+ *
+ * function App() {
+ *   return (
+ *     <Suspense fallback={<h1>Loading posts...</h1>}>
+ *       <Posts />
+ *     </Suspense>
+ *   )
+ * }
+ * ```
+ */
 declare function useSuspenseQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseSuspenseQueryResult<TData, TError>;
 //#endregion
 export { useSuspenseQuery };

package/build/legacy/useSuspenseQuery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useSuspenseQuery.d.ts","names":[],"sources":["../../src/useSuspenseQuery.ts"],"mappings":";;;iBAOgB,iBACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,wBAAwB,cAAc,QAAQ,OAAO,YAC9D,cAAc,cACb,uBAAuB,OAAO"}
+{"version":3,"file":"useSuspenseQuery.d.ts","names":[],"sources":["../../src/useSuspenseQuery.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkDgB,iBACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,wBAAwB,cAAc,QAAQ,OAAO,YAC9D,cAAc,cACb,uBAAuB,OAAO"}

package/build/legacy/useSuspenseQuery.js

@@ -2,6 +2,49 @@ import { defaultThrowOnError } from "./suspense.js";
 import { useBaseQuery } from "./useBaseQuery.js";
 import { QueryObserver, skipToken } from "@tanstack/query-core";
 //#region src/useSuspenseQuery.ts
+/**
+* The options for `useSuspenseQuery` are the same as for `useQuery`, except for `throwOnError`, `enabled`, and
+* `placeholderData`.
+*
+* Caveat: cancellation does not work.
+*
+* @param options - The {@link UseSuspenseQueryOptions} to use — the same options as `useQuery`, minus the ones listed above.
+* @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will
+* be used.
+* @returns The same object as `useQuery`, except that `data` is guaranteed to be defined, `isPlaceholderData`
+* is missing, and `status` is either `success` or `error` (with the derived flags set accordingly).
+*
+* @example
+* ```tsx
+* import { Suspense } from 'preact/compat'
+* import { useSuspenseQuery } from '@tanstack/preact-query'
+*
+* function Posts() {
+*   // `data` is guaranteed to be defined here — no `isPending` check needed.
+*   const { data, isFetching } = useSuspenseQuery({
+*     queryKey: ['posts'],
+*     queryFn: fetchPosts,
+*   })
+*
+*   return (
+*     <div>
+*       <h1>Posts {isFetching ? <Spinner /> : null}</h1>
+*       {data.map((post) => (
+*         <p key={post.id}>{post.title}</p>
+*       ))}
+*     </div>
+*   )
+* }
+*
+* function App() {
+*   return (
+*     <Suspense fallback={<h1>Loading posts...</h1>}>
+*       <Posts />
+*     </Suspense>
+*   )
+* }
+* ```
+*/
 function useSuspenseQuery(options, queryClient) {
 	if (process.env.NODE_ENV !== "production") {
 		if (options.queryFn === skipToken) console.error("skipToken is not allowed for useSuspenseQuery");

package/build/legacy/useSuspenseQuery.js.map

@@ -1 +1 @@
-{"version":3,"file":"useSuspenseQuery.js","names":[],"sources":["../../src/useSuspenseQuery.ts"],"sourcesContent":["import { QueryObserver, skipToken } from '@tanstack/query-core'\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\n\nimport { defaultThrowOnError } from './suspense'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'\nimport { useBaseQuery } from './useBaseQuery'\n\nexport function useSuspenseQuery<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n  queryClient?: QueryClient,\n): UseSuspenseQueryResult<TData, TError> {\n  if (process.env.NODE_ENV !== 'production') {\n    if ((options.queryFn as any) === skipToken) {\n      console.error('skipToken is not allowed for useSuspenseQuery')\n    }\n  }\n\n  return useBaseQuery(\n    {\n      ...options,\n      enabled: true,\n      suspense: true,\n      throwOnError: defaultThrowOnError,\n      placeholderData: undefined,\n    },\n    QueryObserver,\n    queryClient,\n  ) as UseSuspenseQueryResult<TData, TError>\n}\n"],"mappings":";;;;AAOA,SAAgB,iBAMd,SACA,aACuC;CACvC,IAAI,QAAQ,IAAI,aAAa,cACtB;MAAA,QAAQ,YAAoB,WAC/B,QAAQ,MAAM,+CAA+C;CAAA;CAIjE,OAAO,aACL;EACE,GAAG;EACH,SAAS;EACT,UAAU;EACV,cAAc;EACd,iBAAiB,KAAA;CACnB,GACA,eACA,WACF;AACF"}
+{"version":3,"file":"useSuspenseQuery.js","names":[],"sources":["../../src/useSuspenseQuery.ts"],"sourcesContent":["import { QueryObserver, skipToken } from '@tanstack/query-core'\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\n\nimport { defaultThrowOnError } from './suspense'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'\nimport { useBaseQuery } from './useBaseQuery'\n\n/**\n * The options for `useSuspenseQuery` are the same as for `useQuery`, except for `throwOnError`, `enabled`, and\n * `placeholderData`.\n *\n * Caveat: cancellation does not work.\n *\n * @param options - The {@link UseSuspenseQueryOptions} to use — the same options as `useQuery`, minus the ones listed above.\n * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will\n * be used.\n * @returns The same object as `useQuery`, except that `data` is guaranteed to be defined, `isPlaceholderData`\n * is missing, and `status` is either `success` or `error` (with the derived flags set accordingly).\n *\n * @example\n * ```tsx\n * import { Suspense } from 'preact/compat'\n * import { useSuspenseQuery } from '@tanstack/preact-query'\n *\n * function Posts() {\n *   // `data` is guaranteed to be defined here — no `isPending` check needed.\n *   const { data, isFetching } = useSuspenseQuery({\n *     queryKey: ['posts'],\n *     queryFn: fetchPosts,\n *   })\n *\n *   return (\n *     <div>\n *       <h1>Posts {isFetching ? <Spinner /> : null}</h1>\n *       {data.map((post) => (\n *         <p key={post.id}>{post.title}</p>\n *       ))}\n *     </div>\n *   )\n * }\n *\n * function App() {\n *   return (\n *     <Suspense fallback={<h1>Loading posts...</h1>}>\n *       <Posts />\n *     </Suspense>\n *   )\n * }\n * ```\n */\nexport function useSuspenseQuery<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n  queryClient?: QueryClient,\n): UseSuspenseQueryResult<TData, TError> {\n  if (process.env.NODE_ENV !== 'production') {\n    if ((options.queryFn as any) === skipToken) {\n      console.error('skipToken is not allowed for useSuspenseQuery')\n    }\n  }\n\n  return useBaseQuery(\n    {\n      ...options,\n      enabled: true,\n      suspense: true,\n      throwOnError: defaultThrowOnError,\n      placeholderData: undefined,\n    },\n    QueryObserver,\n    queryClient,\n  ) as UseSuspenseQueryResult<TData, TError>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,SAAgB,iBAMd,SACA,aACuC;CACvC,IAAI,QAAQ,IAAI,aAAa,cACtB;MAAA,QAAQ,YAAoB,WAC/B,QAAQ,MAAM,+CAA+C;CAAA;CAIjE,OAAO,aACL;EACE,GAAG;EACH,SAAS;EACT,UAAU;EACV,cAAc;EACd,iBAAiB,KAAA;CACnB,GACA,eACA,WACF;AACF"}

package/build/legacy/utils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"utils.cjs","names":["useState","useRef"],"sources":["../../src/utils.ts"],"sourcesContent":["import { useEffect, useLayoutEffect, useRef, useState } from 'preact/hooks'\n\n/**\n * This is taken from https://github.com/preactjs/preact/blob/main/compat/src/hooks.js#L8-L54\n * which is taken from https://github.com/facebook/react/blob/main/packages/use-sync-external-store/src/useSyncExternalStoreShimClient.js#L84\n * on a high level this cuts out the warnings, ... and attempts a smaller implementation.\n * This way we don't have to import preact/compat with side effects\n */\ntype InternalStore = {\n  _value: any\n  _getSnapshot: () => any\n}\ntype StoreRef = {\n  _instance: InternalStore\n}\nexport function useSyncExternalStore(\n  subscribe: (onStoreChange: () => void) => () => void,\n  getSnapshot: () => any,\n) {\n  const value = getSnapshot()\n\n  const [{ _instance }, forceUpdate] = useState<StoreRef>({\n    _instance: { _value: value, _getSnapshot: getSnapshot },\n  })\n\n  useLayoutEffect(() => {\n    _instance._value = value\n    _instance._getSnapshot = getSnapshot\n\n    if (didSnapshotChange(_instance)) {\n      forceUpdate({ _instance })\n    }\n  }, [subscribe, value, getSnapshot])\n\n  useEffect(() => {\n    if (didSnapshotChange(_instance)) {\n      forceUpdate({ _instance })\n    }\n\n    return subscribe(() => {\n      if (didSnapshotChange(_instance)) {\n        forceUpdate({ _instance })\n      }\n    })\n  }, [subscribe])\n\n  return value\n}\n\nfunction didSnapshotChange(inst: {\n  _getSnapshot: () => any\n  _value: any\n}): boolean {\n  const latestGetSnapshot = inst._getSnapshot\n  const prevValue = inst._value\n  try {\n    const nextValue = latestGetSnapshot()\n    return !Object.is(prevValue, nextValue)\n    // eslint-disable-next-line no-unused-vars\n  } catch (_error) {\n    return true\n  }\n}\n\nexport function useSyncExternalStoreWithSelector<TSnapshot, TSelected>(\n  subscribe: (onStoreChange: () => void) => () => void,\n  getSnapshot: () => TSnapshot,\n  selector: (snapshot: TSnapshot) => TSelected,\n  isEqual: (a: TSelected, b: TSelected) => boolean,\n): TSelected {\n  const selectedSnapshotRef = useRef<TSelected | undefined>()\n\n  const getSelectedSnapshot = () => {\n    const snapshot = getSnapshot()\n    const selected = selector(snapshot)\n\n    if (\n      selectedSnapshotRef.current === undefined ||\n      !isEqual(selectedSnapshotRef.current, selected)\n    ) {\n      selectedSnapshotRef.current = selected\n    }\n\n    return selectedSnapshotRef.current\n  }\n\n  return useSyncExternalStore(subscribe, getSelectedSnapshot)\n}\n"],"mappings":";;;AAeA,SAAgB,qBACd,WACA,aACA;CACA,MAAM,QAAQ,YAAY;CAE1B,MAAM,CAAC,EAAE,aAAa,gBAAA,GAAeA,aAAAA,SAAAA,CAAmB,EACtD,WAAW;EAAE,QAAQ;EAAO,cAAc;CAAY,EACxD,CAAC;CAED,CAAA,GAAA,aAAA,gBAAA,OAAsB;EACpB,UAAU,SAAS;EACnB,UAAU,eAAe;EAEzB,IAAI,kBAAkB,SAAS,GAC7B,YAAY,EAAE,UAAU,CAAC;CAE7B,GAAG;EAAC;EAAW;EAAO;CAAW,CAAC;CAElC,CAAA,GAAA,aAAA,UAAA,OAAgB;EACd,IAAI,kBAAkB,SAAS,GAC7B,YAAY,EAAE,UAAU,CAAC;EAG3B,OAAO,gBAAgB;GACrB,IAAI,kBAAkB,SAAS,GAC7B,YAAY,EAAE,UAAU,CAAC;EAE7B,CAAC;CACH,GAAG,CAAC,SAAS,CAAC;CAEd,OAAO;AACT;AAEA,SAAS,kBAAkB,MAGf;CACV,MAAM,oBAAoB,KAAK;CAC/B,MAAM,YAAY,KAAK;CACvB,IAAI;EACF,MAAM,YAAY,kBAAkB;EACpC,OAAO,CAAC,OAAO,GAAG,WAAW,SAAS;CAExC,SAAS,QAAQ;EACf,OAAO;CACT;AACF;AAEA,SAAgB,iCACd,WACA,aACA,UACA,SACW;CACX,MAAM,uBAAA,GAAsBC,aAAAA,OAAAA,CAA8B;CAE1D,MAAM,4BAA4B;EAEhC,MAAM,WAAW,SADA,YACgB,CAAC;EAElC,IACE,oBAAoB,YAAY,KAAA,KAChC,CAAC,QAAQ,oBAAoB,SAAS,QAAQ,GAE9C,oBAAoB,UAAU;EAGhC,OAAO,oBAAoB;CAC7B;CAEA,OAAO,qBAAqB,WAAW,mBAAmB;AAC5D"}
+{"version":3,"file":"utils.cjs","names":["useState","useRef"],"sources":["../../src/utils.ts"],"sourcesContent":["import { useEffect, useLayoutEffect, useRef, useState } from 'preact/hooks'\n\n/**\n * This is taken from https://github.com/preactjs/preact/blob/main/compat/src/hooks.js#L8-L54\n * which is taken from https://github.com/facebook/react/blob/main/packages/use-sync-external-store/src/useSyncExternalStoreShimClient.js#L84\n * on a high level this cuts out the warnings, ... and attempts a smaller implementation.\n * This way we don't have to import preact/compat with side effects\n */\ntype InternalStore = {\n  _value: any\n  _getSnapshot: () => any\n}\ntype StoreRef = {\n  _instance: InternalStore\n}\nexport function useSyncExternalStore(\n  subscribe: (onStoreChange: () => void) => () => void,\n  getSnapshot: () => any,\n) {\n  const value = getSnapshot()\n\n  const [{ _instance }, forceUpdate] = useState<StoreRef>({\n    _instance: { _value: value, _getSnapshot: getSnapshot },\n  })\n\n  useLayoutEffect(() => {\n    _instance._value = value\n    _instance._getSnapshot = getSnapshot\n\n    if (didSnapshotChange(_instance)) {\n      forceUpdate({ _instance })\n    }\n  }, [subscribe, value, getSnapshot])\n\n  useEffect(() => {\n    if (didSnapshotChange(_instance)) {\n      forceUpdate({ _instance })\n    }\n\n    return subscribe(() => {\n      if (didSnapshotChange(_instance)) {\n        forceUpdate({ _instance })\n      }\n    })\n  }, [subscribe])\n\n  return value\n}\n\nfunction didSnapshotChange(inst: {\n  _getSnapshot: () => any\n  _value: any\n}): boolean {\n  const latestGetSnapshot = inst._getSnapshot\n  const prevValue = inst._value\n  try {\n    const nextValue = latestGetSnapshot()\n    return !Object.is(prevValue, nextValue)\n  } catch (_error) {\n    return true\n  }\n}\n\nexport function useSyncExternalStoreWithSelector<TSnapshot, TSelected>(\n  subscribe: (onStoreChange: () => void) => () => void,\n  getSnapshot: () => TSnapshot,\n  selector: (snapshot: TSnapshot) => TSelected,\n  isEqual: (a: TSelected, b: TSelected) => boolean,\n): TSelected {\n  const selectedSnapshotRef = useRef<TSelected | undefined>()\n\n  const getSelectedSnapshot = () => {\n    const snapshot = getSnapshot()\n    const selected = selector(snapshot)\n\n    if (\n      selectedSnapshotRef.current === undefined ||\n      !isEqual(selectedSnapshotRef.current, selected)\n    ) {\n      selectedSnapshotRef.current = selected\n    }\n\n    return selectedSnapshotRef.current\n  }\n\n  return useSyncExternalStore(subscribe, getSelectedSnapshot)\n}\n"],"mappings":";;;AAeA,SAAgB,qBACd,WACA,aACA;CACA,MAAM,QAAQ,YAAY;CAE1B,MAAM,CAAC,EAAE,aAAa,gBAAA,GAAeA,aAAAA,SAAAA,CAAmB,EACtD,WAAW;EAAE,QAAQ;EAAO,cAAc;CAAY,EACxD,CAAC;CAED,CAAA,GAAA,aAAA,gBAAA,OAAsB;EACpB,UAAU,SAAS;EACnB,UAAU,eAAe;EAEzB,IAAI,kBAAkB,SAAS,GAC7B,YAAY,EAAE,UAAU,CAAC;CAE7B,GAAG;EAAC;EAAW;EAAO;CAAW,CAAC;CAElC,CAAA,GAAA,aAAA,UAAA,OAAgB;EACd,IAAI,kBAAkB,SAAS,GAC7B,YAAY,EAAE,UAAU,CAAC;EAG3B,OAAO,gBAAgB;GACrB,IAAI,kBAAkB,SAAS,GAC7B,YAAY,EAAE,UAAU,CAAC;EAE7B,CAAC;CACH,GAAG,CAAC,SAAS,CAAC;CAEd,OAAO;AACT;AAEA,SAAS,kBAAkB,MAGf;CACV,MAAM,oBAAoB,KAAK;CAC/B,MAAM,YAAY,KAAK;CACvB,IAAI;EACF,MAAM,YAAY,kBAAkB;EACpC,OAAO,CAAC,OAAO,GAAG,WAAW,SAAS;CACxC,SAAS,QAAQ;EACf,OAAO;CACT;AACF;AAEA,SAAgB,iCACd,WACA,aACA,UACA,SACW;CACX,MAAM,uBAAA,GAAsBC,aAAAA,OAAAA,CAA8B;CAE1D,MAAM,4BAA4B;EAEhC,MAAM,WAAW,SADA,YACgB,CAAC;EAElC,IACE,oBAAoB,YAAY,KAAA,KAChC,CAAC,QAAQ,oBAAoB,SAAS,QAAQ,GAE9C,oBAAoB,UAAU;EAGhC,OAAO,oBAAoB;CAC7B;CAEA,OAAO,qBAAqB,WAAW,mBAAmB;AAC5D"}

package/build/legacy/utils.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.cts","names":[],"sources":["../../src/utils.ts"],"mappings":";iBAegB,qBACd,YAAY,0CACZ;iBA+Cc,iCAAiC,WAAW,WAC1D,YAAY,0CACZ,mBAAmB,WACnB,WAAW,UAAU,cAAc,WACnC,UAAU,GAAG,WAAW,GAAG,wBAC1B"}
+{"version":3,"file":"utils.d.cts","names":[],"sources":["../../src/utils.ts"],"mappings":";iBAegB,qBACd,YAAY,0CACZ;iBA8Cc,iCAAiC,WAAW,WAC1D,YAAY,0CACZ,mBAAmB,WACnB,WAAW,UAAU,cAAc,WACnC,UAAU,GAAG,WAAW,GAAG,wBAC1B"}

package/build/legacy/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","names":[],"sources":["../../src/utils.ts"],"mappings":";iBAegB,qBACd,YAAY,0CACZ;iBA+Cc,iCAAiC,WAAW,WAC1D,YAAY,0CACZ,mBAAmB,WACnB,WAAW,UAAU,cAAc,WACnC,UAAU,GAAG,WAAW,GAAG,wBAC1B"}
+{"version":3,"file":"utils.d.ts","names":[],"sources":["../../src/utils.ts"],"mappings":";iBAegB,qBACd,YAAY,0CACZ;iBA8Cc,iCAAiC,WAAW,WAC1D,YAAY,0CACZ,mBAAmB,WACnB,WAAW,UAAU,cAAc,WACnC,UAAU,GAAG,WAAW,GAAG,wBAC1B"}

package/build/legacy/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","names":[],"sources":["../../src/utils.ts"],"sourcesContent":["import { useEffect, useLayoutEffect, useRef, useState } from 'preact/hooks'\n\n/**\n * This is taken from https://github.com/preactjs/preact/blob/main/compat/src/hooks.js#L8-L54\n * which is taken from https://github.com/facebook/react/blob/main/packages/use-sync-external-store/src/useSyncExternalStoreShimClient.js#L84\n * on a high level this cuts out the warnings, ... and attempts a smaller implementation.\n * This way we don't have to import preact/compat with side effects\n */\ntype InternalStore = {\n  _value: any\n  _getSnapshot: () => any\n}\ntype StoreRef = {\n  _instance: InternalStore\n}\nexport function useSyncExternalStore(\n  subscribe: (onStoreChange: () => void) => () => void,\n  getSnapshot: () => any,\n) {\n  const value = getSnapshot()\n\n  const [{ _instance }, forceUpdate] = useState<StoreRef>({\n    _instance: { _value: value, _getSnapshot: getSnapshot },\n  })\n\n  useLayoutEffect(() => {\n    _instance._value = value\n    _instance._getSnapshot = getSnapshot\n\n    if (didSnapshotChange(_instance)) {\n      forceUpdate({ _instance })\n    }\n  }, [subscribe, value, getSnapshot])\n\n  useEffect(() => {\n    if (didSnapshotChange(_instance)) {\n      forceUpdate({ _instance })\n    }\n\n    return subscribe(() => {\n      if (didSnapshotChange(_instance)) {\n        forceUpdate({ _instance })\n      }\n    })\n  }, [subscribe])\n\n  return value\n}\n\nfunction didSnapshotChange(inst: {\n  _getSnapshot: () => any\n  _value: any\n}): boolean {\n  const latestGetSnapshot = inst._getSnapshot\n  const prevValue = inst._value\n  try {\n    const nextValue = latestGetSnapshot()\n    return !Object.is(prevValue, nextValue)\n    // eslint-disable-next-line no-unused-vars\n  } catch (_error) {\n    return true\n  }\n}\n\nexport function useSyncExternalStoreWithSelector<TSnapshot, TSelected>(\n  subscribe: (onStoreChange: () => void) => () => void,\n  getSnapshot: () => TSnapshot,\n  selector: (snapshot: TSnapshot) => TSelected,\n  isEqual: (a: TSelected, b: TSelected) => boolean,\n): TSelected {\n  const selectedSnapshotRef = useRef<TSelected | undefined>()\n\n  const getSelectedSnapshot = () => {\n    const snapshot = getSnapshot()\n    const selected = selector(snapshot)\n\n    if (\n      selectedSnapshotRef.current === undefined ||\n      !isEqual(selectedSnapshotRef.current, selected)\n    ) {\n      selectedSnapshotRef.current = selected\n    }\n\n    return selectedSnapshotRef.current\n  }\n\n  return useSyncExternalStore(subscribe, getSelectedSnapshot)\n}\n"],"mappings":";;AAeA,SAAgB,qBACd,WACA,aACA;CACA,MAAM,QAAQ,YAAY;CAE1B,MAAM,CAAC,EAAE,aAAa,eAAe,SAAmB,EACtD,WAAW;EAAE,QAAQ;EAAO,cAAc;CAAY,EACxD,CAAC;CAED,sBAAsB;EACpB,UAAU,SAAS;EACnB,UAAU,eAAe;EAEzB,IAAI,kBAAkB,SAAS,GAC7B,YAAY,EAAE,UAAU,CAAC;CAE7B,GAAG;EAAC;EAAW;EAAO;CAAW,CAAC;CAElC,gBAAgB;EACd,IAAI,kBAAkB,SAAS,GAC7B,YAAY,EAAE,UAAU,CAAC;EAG3B,OAAO,gBAAgB;GACrB,IAAI,kBAAkB,SAAS,GAC7B,YAAY,EAAE,UAAU,CAAC;EAE7B,CAAC;CACH,GAAG,CAAC,SAAS,CAAC;CAEd,OAAO;AACT;AAEA,SAAS,kBAAkB,MAGf;CACV,MAAM,oBAAoB,KAAK;CAC/B,MAAM,YAAY,KAAK;CACvB,IAAI;EACF,MAAM,YAAY,kBAAkB;EACpC,OAAO,CAAC,OAAO,GAAG,WAAW,SAAS;CAExC,SAAS,QAAQ;EACf,OAAO;CACT;AACF;AAEA,SAAgB,iCACd,WACA,aACA,UACA,SACW;CACX,MAAM,sBAAsB,OAA8B;CAE1D,MAAM,4BAA4B;EAEhC,MAAM,WAAW,SADA,YACgB,CAAC;EAElC,IACE,oBAAoB,YAAY,KAAA,KAChC,CAAC,QAAQ,oBAAoB,SAAS,QAAQ,GAE9C,oBAAoB,UAAU;EAGhC,OAAO,oBAAoB;CAC7B;CAEA,OAAO,qBAAqB,WAAW,mBAAmB;AAC5D"}
+{"version":3,"file":"utils.js","names":[],"sources":["../../src/utils.ts"],"sourcesContent":["import { useEffect, useLayoutEffect, useRef, useState } from 'preact/hooks'\n\n/**\n * This is taken from https://github.com/preactjs/preact/blob/main/compat/src/hooks.js#L8-L54\n * which is taken from https://github.com/facebook/react/blob/main/packages/use-sync-external-store/src/useSyncExternalStoreShimClient.js#L84\n * on a high level this cuts out the warnings, ... and attempts a smaller implementation.\n * This way we don't have to import preact/compat with side effects\n */\ntype InternalStore = {\n  _value: any\n  _getSnapshot: () => any\n}\ntype StoreRef = {\n  _instance: InternalStore\n}\nexport function useSyncExternalStore(\n  subscribe: (onStoreChange: () => void) => () => void,\n  getSnapshot: () => any,\n) {\n  const value = getSnapshot()\n\n  const [{ _instance }, forceUpdate] = useState<StoreRef>({\n    _instance: { _value: value, _getSnapshot: getSnapshot },\n  })\n\n  useLayoutEffect(() => {\n    _instance._value = value\n    _instance._getSnapshot = getSnapshot\n\n    if (didSnapshotChange(_instance)) {\n      forceUpdate({ _instance })\n    }\n  }, [subscribe, value, getSnapshot])\n\n  useEffect(() => {\n    if (didSnapshotChange(_instance)) {\n      forceUpdate({ _instance })\n    }\n\n    return subscribe(() => {\n      if (didSnapshotChange(_instance)) {\n        forceUpdate({ _instance })\n      }\n    })\n  }, [subscribe])\n\n  return value\n}\n\nfunction didSnapshotChange(inst: {\n  _getSnapshot: () => any\n  _value: any\n}): boolean {\n  const latestGetSnapshot = inst._getSnapshot\n  const prevValue = inst._value\n  try {\n    const nextValue = latestGetSnapshot()\n    return !Object.is(prevValue, nextValue)\n  } catch (_error) {\n    return true\n  }\n}\n\nexport function useSyncExternalStoreWithSelector<TSnapshot, TSelected>(\n  subscribe: (onStoreChange: () => void) => () => void,\n  getSnapshot: () => TSnapshot,\n  selector: (snapshot: TSnapshot) => TSelected,\n  isEqual: (a: TSelected, b: TSelected) => boolean,\n): TSelected {\n  const selectedSnapshotRef = useRef<TSelected | undefined>()\n\n  const getSelectedSnapshot = () => {\n    const snapshot = getSnapshot()\n    const selected = selector(snapshot)\n\n    if (\n      selectedSnapshotRef.current === undefined ||\n      !isEqual(selectedSnapshotRef.current, selected)\n    ) {\n      selectedSnapshotRef.current = selected\n    }\n\n    return selectedSnapshotRef.current\n  }\n\n  return useSyncExternalStore(subscribe, getSelectedSnapshot)\n}\n"],"mappings":";;AAeA,SAAgB,qBACd,WACA,aACA;CACA,MAAM,QAAQ,YAAY;CAE1B,MAAM,CAAC,EAAE,aAAa,eAAe,SAAmB,EACtD,WAAW;EAAE,QAAQ;EAAO,cAAc;CAAY,EACxD,CAAC;CAED,sBAAsB;EACpB,UAAU,SAAS;EACnB,UAAU,eAAe;EAEzB,IAAI,kBAAkB,SAAS,GAC7B,YAAY,EAAE,UAAU,CAAC;CAE7B,GAAG;EAAC;EAAW;EAAO;CAAW,CAAC;CAElC,gBAAgB;EACd,IAAI,kBAAkB,SAAS,GAC7B,YAAY,EAAE,UAAU,CAAC;EAG3B,OAAO,gBAAgB;GACrB,IAAI,kBAAkB,SAAS,GAC7B,YAAY,EAAE,UAAU,CAAC;EAE7B,CAAC;CACH,GAAG,CAAC,SAAS,CAAC;CAEd,OAAO;AACT;AAEA,SAAS,kBAAkB,MAGf;CACV,MAAM,oBAAoB,KAAK;CAC/B,MAAM,YAAY,KAAK;CACvB,IAAI;EACF,MAAM,YAAY,kBAAkB;EACpC,OAAO,CAAC,OAAO,GAAG,WAAW,SAAS;CACxC,SAAS,QAAQ;EACf,OAAO;CACT;AACF;AAEA,SAAgB,iCACd,WACA,aACA,UACA,SACW;CACX,MAAM,sBAAsB,OAA8B;CAE1D,MAAM,4BAA4B;EAEhC,MAAM,WAAW,SADA,YACgB,CAAC;EAElC,IACE,oBAAoB,YAAY,KAAA,KAChC,CAAC,QAAQ,oBAAoB,SAAS,QAAQ,GAE9C,oBAAoB,UAAU;EAGhC,OAAO,oBAAoB;CAC7B;CAEA,OAAO,qBAAqB,WAAW,mBAAmB;AAC5D"}

package/build/modern/HydrationBoundary.cjs

@@ -5,6 +5,49 @@ let preact = require("preact");
 let preact_hooks = require("preact/hooks");
 let preact_jsx_runtime = require("preact/jsx-runtime");
 //#region src/HydrationBoundary.tsx
+/**
+* `HydrationBoundary` adds a previously dehydrated state into the `queryClient` that would be returned by
+* `useQueryClient()`. If the client already contains data, the new queries will be intelligently merged based on
+* update timestamp.
+*
+* Note: Only `queries` can be dehydrated with an `HydrationBoundary`.
+*
+* @returns The provided `children`, rendered unconditionally. New queries in `state` are hydrated into the
+* cache during render; for queries already in the cache, only newer dehydrated data is hydrated, in an effect
+* after commit.
+*
+* @example
+* ```tsx
+* import { HydrationBoundary } from '@tanstack/preact-query'
+*
+* function App() {
+*   return <HydrationBoundary state={dehydratedState}>...</HydrationBoundary>
+* }
+* ```
+*
+* @example
+* Server-side prefetch handed off to the client via `dehydrate`:
+* ```tsx
+* import { HydrationBoundary, dehydrate, noop } from '@tanstack/preact-query'
+*
+* async function ServerComponent() {
+*   const queryClient = getQueryClient()
+*
+*   await queryClient
+*     .query({
+*       queryKey: ['posts'],
+*       queryFn: fetchPosts,
+*     })
+*     .catch(noop)
+*
+*   return (
+*     <HydrationBoundary state={dehydrate(queryClient)}>
+*       <Posts />
+*     </HydrationBoundary>
+*   )
+* }
+* ```
+*/
 const HydrationBoundary = ({ children, options = {}, state, queryClient }) => {
 	const client = require_QueryClientProvider.useQueryClient(queryClient);
 	const optionsRef = (0, preact_hooks.useRef)(options);

package/build/modern/HydrationBoundary.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"HydrationBoundary.cjs","names":["useQueryClient","useRef","useMemo","Fragment"],"sources":["../../src/HydrationBoundary.tsx"],"sourcesContent":["import { hydrate } from '@tanstack/query-core'\nimport type {\n  DehydratedState,\n  HydrateOptions,\n  OmitKeyof,\n  QueryClient,\n} from '@tanstack/query-core'\nimport { Fragment } from 'preact'\nimport type { ComponentChildren } from 'preact'\nimport { useEffect, useMemo, useRef } from 'preact/hooks'\n\nimport { useQueryClient } from './QueryClientProvider'\n\nexport interface HydrationBoundaryProps {\n  state: DehydratedState | null | undefined\n  options?: OmitKeyof<HydrateOptions, 'defaultOptions'> & {\n    defaultOptions?: OmitKeyof<\n      Exclude<HydrateOptions['defaultOptions'], undefined>,\n      'mutations'\n    >\n  }\n  children?: ComponentChildren\n  queryClient?: QueryClient\n}\n\nexport const HydrationBoundary = ({\n  children,\n  options = {},\n  state,\n  queryClient,\n}: HydrationBoundaryProps) => {\n  const client = useQueryClient(queryClient)\n\n  const optionsRef = useRef(options)\n  useEffect(() => {\n    optionsRef.current = options\n  })\n\n  // This useMemo is for performance reasons only, everything inside it must\n  // be safe to run in every render and code here should be read as \"in render\".\n  //\n  // This code needs to happen during the render phase, because after initial\n  // SSR, hydration needs to happen _before_ children render. Also, if hydrating\n  // during a transition, we want to hydrate as much as is safe in render so\n  // we can prerender as much as possible.\n  //\n  // For any queries that already exist in the cache, we want to hold back on\n  // hydrating until _after_ the render phase. The reason for this is that during\n  // transitions, we don't want the existing queries and observers to update to\n  // the new data on the current page, only _after_ the transition is committed.\n  // If the transition is aborted, we will have hydrated any _new_ queries, but\n  // we throw away the fresh data for any existing ones to avoid unexpectedly\n  // updating the UI.\n  const hydrationQueue: DehydratedState['queries'] | undefined = useMemo(() => {\n    if (state) {\n      if (typeof state !== 'object') {\n        return\n      }\n\n      const queryCache = client.getQueryCache()\n      // State is supplied from the outside and we might as well fail\n      // gracefully if it has the wrong shape, so while we type `queries`\n      // as required, we still provide a fallback.\n      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n      const queries = state.queries || []\n\n      const newQueries: DehydratedState['queries'] = []\n      const existingQueries: DehydratedState['queries'] = []\n      for (const dehydratedQuery of queries) {\n        const existingQuery = queryCache.get(dehydratedQuery.queryHash)\n\n        if (!existingQuery) {\n          newQueries.push(dehydratedQuery)\n        } else {\n          const hydrationIsNewer =\n            dehydratedQuery.state.dataUpdatedAt >\n              existingQuery.state.dataUpdatedAt ||\n            (dehydratedQuery.promise &&\n              existingQuery.state.status !== 'pending' &&\n              existingQuery.state.fetchStatus !== 'fetching' &&\n              dehydratedQuery.dehydratedAt !== undefined &&\n              dehydratedQuery.dehydratedAt > existingQuery.state.dataUpdatedAt)\n\n          if (hydrationIsNewer) {\n            existingQueries.push(dehydratedQuery)\n          }\n        }\n      }\n\n      if (newQueries.length > 0) {\n        // It's actually fine to call this with queries/state that already exists\n        // in the cache, or is older. hydrate() is idempotent for queries.\n        hydrate(client, { queries: newQueries }, optionsRef.current)\n      }\n      if (existingQueries.length > 0) {\n        return existingQueries\n      }\n    }\n    return undefined\n  }, [client, state])\n\n  useEffect(() => {\n    if (hydrationQueue) {\n      hydrate(client, { queries: hydrationQueue }, optionsRef.current)\n    }\n  }, [client, hydrationQueue])\n\n  return <Fragment>{children}</Fragment>\n}\n"],"mappings":";;;;;;;AAyBA,MAAa,qBAAqB,EAChC,UACA,UAAU,CAAC,GACX,OACA,kBAC4B;CAC5B,MAAM,SAASA,4BAAAA,eAAe,WAAW;CAEzC,MAAM,cAAA,GAAaC,aAAAA,OAAAA,CAAO,OAAO;CACjC,CAAA,GAAA,aAAA,UAAA,OAAgB;EACd,WAAW,UAAU;CACvB,CAAC;CAiBD,MAAM,kBAAA,GAAyDC,aAAAA,QAAAA,OAAc;EAC3E,IAAI,OAAO;GACT,IAAI,OAAO,UAAU,UACnB;GAGF,MAAM,aAAa,OAAO,cAAc;GAKxC,MAAM,UAAU,MAAM,WAAW,CAAC;GAElC,MAAM,aAAyC,CAAC;GAChD,MAAM,kBAA8C,CAAC;GACrD,KAAK,MAAM,mBAAmB,SAAS;IACrC,MAAM,gBAAgB,WAAW,IAAI,gBAAgB,SAAS;IAE9D,IAAI,CAAC,eACH,WAAW,KAAK,eAAe;SAW/B,IARE,gBAAgB,MAAM,gBACpB,cAAc,MAAM,iBACrB,gBAAgB,WACf,cAAc,MAAM,WAAW,aAC/B,cAAc,MAAM,gBAAgB,cACpC,gBAAgB,iBAAiB,KAAA,KACjC,gBAAgB,eAAe,cAAc,MAAM,eAGrD,gBAAgB,KAAK,eAAe;GAG1C;GAEA,IAAI,WAAW,SAAS,GAGtB,CAAA,GAAA,qBAAA,QAAA,CAAQ,QAAQ,EAAE,SAAS,WAAW,GAAG,WAAW,OAAO;GAE7D,IAAI,gBAAgB,SAAS,GAC3B,OAAO;EAEX;CAEF,GAAG,CAAC,QAAQ,KAAK,CAAC;CAElB,CAAA,GAAA,aAAA,UAAA,OAAgB;EACd,IAAI,gBACF,CAAA,GAAA,qBAAA,QAAA,CAAQ,QAAQ,EAAE,SAAS,eAAe,GAAG,WAAW,OAAO;CAEnE,GAAG,CAAC,QAAQ,cAAc,CAAC;CAE3B,OAAO,iBAAA,GAAA,mBAAA,IAAA,CAACC,OAAAA,UAAD,EAAW,SAAmB,CAAA;AACvC"}
+{"version":3,"file":"HydrationBoundary.cjs","names":["useQueryClient","useRef","useMemo","Fragment"],"sources":["../../src/HydrationBoundary.tsx"],"sourcesContent":["import { hydrate } from '@tanstack/query-core'\nimport type {\n  DehydratedState,\n  HydrateOptions,\n  OmitKeyof,\n  QueryClient,\n} from '@tanstack/query-core'\nimport { Fragment } from 'preact'\nimport type { ComponentChildren } from 'preact'\nimport { useEffect, useMemo, useRef } from 'preact/hooks'\n\nimport { useQueryClient } from './QueryClientProvider'\n\n/**\n * The props accepted by `HydrationBoundary`.\n */\nexport interface HydrationBoundaryProps {\n  /**\n   * The state to hydrate.\n   */\n  state: DehydratedState | null | undefined\n  /**\n   * Optional. Note: unlike `hydrate`, `mutations` cannot be set here.\n   */\n  options?: OmitKeyof<HydrateOptions, 'defaultOptions'> & {\n    defaultOptions?: OmitKeyof<\n      Exclude<HydrateOptions['defaultOptions'], undefined>,\n      'mutations'\n    >\n  }\n  /**\n   * The components to render — always rendered unconditionally, not gated on hydration. New queries are\n   * hydrated into the cache during render; for queries that already exist in the cache, only newer dehydrated\n   * data is hydrated, and that happens in an effect after commit, so `children` may render briefly before it\n   * lands.\n   */\n  children?: ComponentChildren\n  /**\n   * Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will be used.\n   */\n  queryClient?: QueryClient\n}\n\n/**\n * `HydrationBoundary` adds a previously dehydrated state into the `queryClient` that would be returned by\n * `useQueryClient()`. If the client already contains data, the new queries will be intelligently merged based on\n * update timestamp.\n *\n * Note: Only `queries` can be dehydrated with an `HydrationBoundary`.\n *\n * @returns The provided `children`, rendered unconditionally. New queries in `state` are hydrated into the\n * cache during render; for queries already in the cache, only newer dehydrated data is hydrated, in an effect\n * after commit.\n *\n * @example\n * ```tsx\n * import { HydrationBoundary } from '@tanstack/preact-query'\n *\n * function App() {\n *   return <HydrationBoundary state={dehydratedState}>...</HydrationBoundary>\n * }\n * ```\n *\n * @example\n * Server-side prefetch handed off to the client via `dehydrate`:\n * ```tsx\n * import { HydrationBoundary, dehydrate, noop } from '@tanstack/preact-query'\n *\n * async function ServerComponent() {\n *   const queryClient = getQueryClient()\n *\n *   await queryClient\n *     .query({\n *       queryKey: ['posts'],\n *       queryFn: fetchPosts,\n *     })\n *     .catch(noop)\n *\n *   return (\n *     <HydrationBoundary state={dehydrate(queryClient)}>\n *       <Posts />\n *     </HydrationBoundary>\n *   )\n * }\n * ```\n */\nexport const HydrationBoundary = ({\n  children,\n  options = {},\n  state,\n  queryClient,\n}: HydrationBoundaryProps) => {\n  const client = useQueryClient(queryClient)\n\n  const optionsRef = useRef(options)\n  useEffect(() => {\n    optionsRef.current = options\n  })\n\n  // This useMemo is for performance reasons only, everything inside it must\n  // be safe to run in every render and code here should be read as \"in render\".\n  //\n  // This code needs to happen during the render phase, because after initial\n  // SSR, hydration needs to happen _before_ children render. Also, if hydrating\n  // during a transition, we want to hydrate as much as is safe in render so\n  // we can prerender as much as possible.\n  //\n  // For any queries that already exist in the cache, we want to hold back on\n  // hydrating until _after_ the render phase. The reason for this is that during\n  // transitions, we don't want the existing queries and observers to update to\n  // the new data on the current page, only _after_ the transition is committed.\n  // If the transition is aborted, we will have hydrated any _new_ queries, but\n  // we throw away the fresh data for any existing ones to avoid unexpectedly\n  // updating the UI.\n  const hydrationQueue: DehydratedState['queries'] | undefined = useMemo(() => {\n    if (state) {\n      if (typeof state !== 'object') {\n        return\n      }\n\n      const queryCache = client.getQueryCache()\n      // State is supplied from the outside and we might as well fail\n      // gracefully if it has the wrong shape, so while we type `queries`\n      // as required, we still provide a fallback.\n      const queries = state.queries || []\n\n      const newQueries: DehydratedState['queries'] = []\n      const existingQueries: DehydratedState['queries'] = []\n      for (const dehydratedQuery of queries) {\n        const existingQuery = queryCache.get(dehydratedQuery.queryHash)\n\n        if (!existingQuery) {\n          newQueries.push(dehydratedQuery)\n        } else {\n          const hydrationIsNewer =\n            dehydratedQuery.state.dataUpdatedAt >\n              existingQuery.state.dataUpdatedAt ||\n            (dehydratedQuery.promise &&\n              existingQuery.state.status !== 'pending' &&\n              existingQuery.state.fetchStatus !== 'fetching' &&\n              dehydratedQuery.dehydratedAt !== undefined &&\n              dehydratedQuery.dehydratedAt > existingQuery.state.dataUpdatedAt)\n\n          if (hydrationIsNewer) {\n            existingQueries.push(dehydratedQuery)\n          }\n        }\n      }\n\n      if (newQueries.length > 0) {\n        // It's actually fine to call this with queries/state that already exists\n        // in the cache, or is older. hydrate() is idempotent for queries.\n        hydrate(client, { queries: newQueries }, optionsRef.current)\n      }\n      if (existingQueries.length > 0) {\n        return existingQueries\n      }\n    }\n    return undefined\n  }, [client, state])\n\n  useEffect(() => {\n    if (hydrationQueue) {\n      hydrate(client, { queries: hydrationQueue }, optionsRef.current)\n    }\n  }, [client, hydrationQueue])\n\n  return <Fragment>{children}</Fragment>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsFA,MAAa,qBAAqB,EAChC,UACA,UAAU,CAAC,GACX,OACA,kBAC4B;CAC5B,MAAM,SAASA,4BAAAA,eAAe,WAAW;CAEzC,MAAM,cAAA,GAAaC,aAAAA,OAAAA,CAAO,OAAO;CACjC,CAAA,GAAA,aAAA,UAAA,OAAgB;EACd,WAAW,UAAU;CACvB,CAAC;CAiBD,MAAM,kBAAA,GAAyDC,aAAAA,QAAAA,OAAc;EAC3E,IAAI,OAAO;GACT,IAAI,OAAO,UAAU,UACnB;GAGF,MAAM,aAAa,OAAO,cAAc;GAIxC,MAAM,UAAU,MAAM,WAAW,CAAC;GAElC,MAAM,aAAyC,CAAC;GAChD,MAAM,kBAA8C,CAAC;GACrD,KAAK,MAAM,mBAAmB,SAAS;IACrC,MAAM,gBAAgB,WAAW,IAAI,gBAAgB,SAAS;IAE9D,IAAI,CAAC,eACH,WAAW,KAAK,eAAe;SAW/B,IARE,gBAAgB,MAAM,gBACpB,cAAc,MAAM,iBACrB,gBAAgB,WACf,cAAc,MAAM,WAAW,aAC/B,cAAc,MAAM,gBAAgB,cACpC,gBAAgB,iBAAiB,KAAA,KACjC,gBAAgB,eAAe,cAAc,MAAM,eAGrD,gBAAgB,KAAK,eAAe;GAG1C;GAEA,IAAI,WAAW,SAAS,GAGtB,CAAA,GAAA,qBAAA,QAAA,CAAQ,QAAQ,EAAE,SAAS,WAAW,GAAG,WAAW,OAAO;GAE7D,IAAI,gBAAgB,SAAS,GAC3B,OAAO;EAEX;CAEF,GAAG,CAAC,QAAQ,KAAK,CAAC;CAElB,CAAA,GAAA,aAAA,UAAA,OAAgB;EACd,IAAI,gBACF,CAAA,GAAA,qBAAA,QAAA,CAAQ,QAAQ,EAAE,SAAS,eAAe,GAAG,WAAW,OAAO;CAEnE,GAAG,CAAC,QAAQ,cAAc,CAAC;CAE3B,OAAO,iBAAA,GAAA,mBAAA,IAAA,CAACC,OAAAA,UAAD,EAAW,SAAmB,CAAA;AACvC"}