@tanstack/preact-query 5.103.2 → 5.104.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (249) hide show
  1. package/README.md +2 -2
  2. package/build/legacy/HydrationBoundary.d.cts +2 -3
  3. package/build/legacy/HydrationBoundary.d.cts.map +1 -1
  4. package/build/legacy/HydrationBoundary.d.ts +2 -3
  5. package/build/legacy/HydrationBoundary.d.ts.map +1 -1
  6. package/build/legacy/IsRestoringProvider.d.cts +2 -3
  7. package/build/legacy/IsRestoringProvider.d.cts.map +1 -1
  8. package/build/legacy/IsRestoringProvider.d.ts +2 -3
  9. package/build/legacy/IsRestoringProvider.d.ts.map +1 -1
  10. package/build/legacy/QueryClientProvider.d.cts +4 -5
  11. package/build/legacy/QueryClientProvider.d.cts.map +1 -1
  12. package/build/legacy/QueryClientProvider.d.ts +4 -5
  13. package/build/legacy/QueryClientProvider.d.ts.map +1 -1
  14. package/build/legacy/QueryErrorResetBoundary.d.cts +8 -9
  15. package/build/legacy/QueryErrorResetBoundary.d.cts.map +1 -1
  16. package/build/legacy/QueryErrorResetBoundary.d.ts +8 -9
  17. package/build/legacy/QueryErrorResetBoundary.d.ts.map +1 -1
  18. package/build/legacy/errorBoundaryUtils.d.cts +3 -4
  19. package/build/legacy/errorBoundaryUtils.d.cts.map +1 -1
  20. package/build/legacy/errorBoundaryUtils.d.ts +3 -4
  21. package/build/legacy/errorBoundaryUtils.d.ts.map +1 -1
  22. package/build/legacy/infiniteQueryOptions.cjs.map +1 -1
  23. package/build/legacy/infiniteQueryOptions.d.cts +7 -8
  24. package/build/legacy/infiniteQueryOptions.d.cts.map +1 -1
  25. package/build/legacy/infiniteQueryOptions.d.ts +7 -8
  26. package/build/legacy/infiniteQueryOptions.d.ts.map +1 -1
  27. package/build/legacy/infiniteQueryOptions.js.map +1 -1
  28. package/build/legacy/mutationOptions.d.cts +2 -3
  29. package/build/legacy/mutationOptions.d.cts.map +1 -1
  30. package/build/legacy/mutationOptions.d.ts +2 -3
  31. package/build/legacy/mutationOptions.d.ts.map +1 -1
  32. package/build/legacy/queryOptions.cjs.map +1 -1
  33. package/build/legacy/queryOptions.d.cts +9 -9
  34. package/build/legacy/queryOptions.d.cts.map +1 -1
  35. package/build/legacy/queryOptions.d.ts +9 -9
  36. package/build/legacy/queryOptions.d.ts.map +1 -1
  37. package/build/legacy/queryOptions.js.map +1 -1
  38. package/build/legacy/suspense.cjs.map +1 -1
  39. package/build/legacy/suspense.d.cts +4 -5
  40. package/build/legacy/suspense.d.cts.map +1 -1
  41. package/build/legacy/suspense.d.ts +4 -5
  42. package/build/legacy/suspense.d.ts.map +1 -1
  43. package/build/legacy/suspense.js.map +1 -1
  44. package/build/legacy/types.cjs.map +1 -1
  45. package/build/legacy/types.d.cts +30 -30
  46. package/build/legacy/types.d.cts.map +1 -1
  47. package/build/legacy/types.d.ts +30 -30
  48. package/build/legacy/types.d.ts.map +1 -1
  49. package/build/legacy/types.js.map +1 -1
  50. package/build/legacy/useBaseQuery.cjs.map +1 -1
  51. package/build/legacy/useBaseQuery.d.cts +1 -2
  52. package/build/legacy/useBaseQuery.d.cts.map +1 -1
  53. package/build/legacy/useBaseQuery.d.ts +1 -2
  54. package/build/legacy/useBaseQuery.d.ts.map +1 -1
  55. package/build/legacy/useBaseQuery.js.map +1 -1
  56. package/build/legacy/useInfiniteQuery.d.cts +3 -4
  57. package/build/legacy/useInfiniteQuery.d.cts.map +1 -1
  58. package/build/legacy/useInfiniteQuery.d.ts +3 -4
  59. package/build/legacy/useInfiniteQuery.d.ts.map +1 -1
  60. package/build/legacy/useIsFetching.d.cts +1 -2
  61. package/build/legacy/useIsFetching.d.cts.map +1 -1
  62. package/build/legacy/useIsFetching.d.ts +1 -2
  63. package/build/legacy/useIsFetching.d.ts.map +1 -1
  64. package/build/legacy/useMutation.d.cts +1 -2
  65. package/build/legacy/useMutation.d.cts.map +1 -1
  66. package/build/legacy/useMutation.d.ts +1 -2
  67. package/build/legacy/useMutation.d.ts.map +1 -1
  68. package/build/legacy/useMutationState.d.cts +2 -3
  69. package/build/legacy/useMutationState.d.cts.map +1 -1
  70. package/build/legacy/useMutationState.d.ts +2 -3
  71. package/build/legacy/useMutationState.d.ts.map +1 -1
  72. package/build/legacy/usePrefetchInfiniteQuery.d.cts +1 -2
  73. package/build/legacy/usePrefetchInfiniteQuery.d.cts.map +1 -1
  74. package/build/legacy/usePrefetchInfiniteQuery.d.ts +1 -2
  75. package/build/legacy/usePrefetchInfiniteQuery.d.ts.map +1 -1
  76. package/build/legacy/usePrefetchQuery.d.cts +1 -2
  77. package/build/legacy/usePrefetchQuery.d.cts.map +1 -1
  78. package/build/legacy/usePrefetchQuery.d.ts +1 -2
  79. package/build/legacy/usePrefetchQuery.d.ts.map +1 -1
  80. package/build/legacy/useQueries.cjs.map +1 -1
  81. package/build/legacy/useQueries.d.cts +9 -6
  82. package/build/legacy/useQueries.d.cts.map +1 -1
  83. package/build/legacy/useQueries.d.ts +9 -6
  84. package/build/legacy/useQueries.d.ts.map +1 -1
  85. package/build/legacy/useQueries.js.map +1 -1
  86. package/build/legacy/useQuery.cjs.map +1 -1
  87. package/build/legacy/useQuery.d.cts +10 -6
  88. package/build/legacy/useQuery.d.cts.map +1 -1
  89. package/build/legacy/useQuery.d.ts +10 -6
  90. package/build/legacy/useQuery.d.ts.map +1 -1
  91. package/build/legacy/useQuery.js.map +1 -1
  92. package/build/legacy/useSuspenseInfiniteQuery.d.cts +1 -2
  93. package/build/legacy/useSuspenseInfiniteQuery.d.cts.map +1 -1
  94. package/build/legacy/useSuspenseInfiniteQuery.d.ts +1 -2
  95. package/build/legacy/useSuspenseInfiniteQuery.d.ts.map +1 -1
  96. package/build/legacy/useSuspenseQueries.cjs.map +1 -1
  97. package/build/legacy/useSuspenseQueries.d.cts +11 -8
  98. package/build/legacy/useSuspenseQueries.d.cts.map +1 -1
  99. package/build/legacy/useSuspenseQueries.d.ts +11 -8
  100. package/build/legacy/useSuspenseQueries.d.ts.map +1 -1
  101. package/build/legacy/useSuspenseQueries.js.map +1 -1
  102. package/build/legacy/useSuspenseQuery.d.cts +1 -2
  103. package/build/legacy/useSuspenseQuery.d.cts.map +1 -1
  104. package/build/legacy/useSuspenseQuery.d.ts +1 -2
  105. package/build/legacy/useSuspenseQuery.d.ts.map +1 -1
  106. package/build/legacy/utils.d.cts +2 -3
  107. package/build/legacy/utils.d.cts.map +1 -1
  108. package/build/legacy/utils.d.ts +2 -3
  109. package/build/legacy/utils.d.ts.map +1 -1
  110. package/build/modern/HydrationBoundary.d.cts +2 -3
  111. package/build/modern/HydrationBoundary.d.cts.map +1 -1
  112. package/build/modern/HydrationBoundary.d.ts +2 -3
  113. package/build/modern/HydrationBoundary.d.ts.map +1 -1
  114. package/build/modern/IsRestoringProvider.d.cts +2 -3
  115. package/build/modern/IsRestoringProvider.d.cts.map +1 -1
  116. package/build/modern/IsRestoringProvider.d.ts +2 -3
  117. package/build/modern/IsRestoringProvider.d.ts.map +1 -1
  118. package/build/modern/QueryClientProvider.d.cts +4 -5
  119. package/build/modern/QueryClientProvider.d.cts.map +1 -1
  120. package/build/modern/QueryClientProvider.d.ts +4 -5
  121. package/build/modern/QueryClientProvider.d.ts.map +1 -1
  122. package/build/modern/QueryErrorResetBoundary.d.cts +8 -9
  123. package/build/modern/QueryErrorResetBoundary.d.cts.map +1 -1
  124. package/build/modern/QueryErrorResetBoundary.d.ts +8 -9
  125. package/build/modern/QueryErrorResetBoundary.d.ts.map +1 -1
  126. package/build/modern/errorBoundaryUtils.d.cts +3 -4
  127. package/build/modern/errorBoundaryUtils.d.cts.map +1 -1
  128. package/build/modern/errorBoundaryUtils.d.ts +3 -4
  129. package/build/modern/errorBoundaryUtils.d.ts.map +1 -1
  130. package/build/modern/infiniteQueryOptions.cjs.map +1 -1
  131. package/build/modern/infiniteQueryOptions.d.cts +7 -8
  132. package/build/modern/infiniteQueryOptions.d.cts.map +1 -1
  133. package/build/modern/infiniteQueryOptions.d.ts +7 -8
  134. package/build/modern/infiniteQueryOptions.d.ts.map +1 -1
  135. package/build/modern/infiniteQueryOptions.js.map +1 -1
  136. package/build/modern/mutationOptions.d.cts +2 -3
  137. package/build/modern/mutationOptions.d.cts.map +1 -1
  138. package/build/modern/mutationOptions.d.ts +2 -3
  139. package/build/modern/mutationOptions.d.ts.map +1 -1
  140. package/build/modern/queryOptions.cjs.map +1 -1
  141. package/build/modern/queryOptions.d.cts +9 -9
  142. package/build/modern/queryOptions.d.cts.map +1 -1
  143. package/build/modern/queryOptions.d.ts +9 -9
  144. package/build/modern/queryOptions.d.ts.map +1 -1
  145. package/build/modern/queryOptions.js.map +1 -1
  146. package/build/modern/suspense.cjs.map +1 -1
  147. package/build/modern/suspense.d.cts +4 -5
  148. package/build/modern/suspense.d.cts.map +1 -1
  149. package/build/modern/suspense.d.ts +4 -5
  150. package/build/modern/suspense.d.ts.map +1 -1
  151. package/build/modern/suspense.js.map +1 -1
  152. package/build/modern/types.cjs.map +1 -1
  153. package/build/modern/types.d.cts +30 -30
  154. package/build/modern/types.d.cts.map +1 -1
  155. package/build/modern/types.d.ts +30 -30
  156. package/build/modern/types.d.ts.map +1 -1
  157. package/build/modern/types.js.map +1 -1
  158. package/build/modern/useBaseQuery.cjs.map +1 -1
  159. package/build/modern/useBaseQuery.d.cts +1 -2
  160. package/build/modern/useBaseQuery.d.cts.map +1 -1
  161. package/build/modern/useBaseQuery.d.ts +1 -2
  162. package/build/modern/useBaseQuery.d.ts.map +1 -1
  163. package/build/modern/useBaseQuery.js.map +1 -1
  164. package/build/modern/useInfiniteQuery.d.cts +3 -4
  165. package/build/modern/useInfiniteQuery.d.cts.map +1 -1
  166. package/build/modern/useInfiniteQuery.d.ts +3 -4
  167. package/build/modern/useInfiniteQuery.d.ts.map +1 -1
  168. package/build/modern/useIsFetching.d.cts +1 -2
  169. package/build/modern/useIsFetching.d.cts.map +1 -1
  170. package/build/modern/useIsFetching.d.ts +1 -2
  171. package/build/modern/useIsFetching.d.ts.map +1 -1
  172. package/build/modern/useMutation.d.cts +1 -2
  173. package/build/modern/useMutation.d.cts.map +1 -1
  174. package/build/modern/useMutation.d.ts +1 -2
  175. package/build/modern/useMutation.d.ts.map +1 -1
  176. package/build/modern/useMutationState.d.cts +2 -3
  177. package/build/modern/useMutationState.d.cts.map +1 -1
  178. package/build/modern/useMutationState.d.ts +2 -3
  179. package/build/modern/useMutationState.d.ts.map +1 -1
  180. package/build/modern/usePrefetchInfiniteQuery.d.cts +1 -2
  181. package/build/modern/usePrefetchInfiniteQuery.d.cts.map +1 -1
  182. package/build/modern/usePrefetchInfiniteQuery.d.ts +1 -2
  183. package/build/modern/usePrefetchInfiniteQuery.d.ts.map +1 -1
  184. package/build/modern/usePrefetchQuery.d.cts +1 -2
  185. package/build/modern/usePrefetchQuery.d.cts.map +1 -1
  186. package/build/modern/usePrefetchQuery.d.ts +1 -2
  187. package/build/modern/usePrefetchQuery.d.ts.map +1 -1
  188. package/build/modern/useQueries.cjs.map +1 -1
  189. package/build/modern/useQueries.d.cts +9 -6
  190. package/build/modern/useQueries.d.cts.map +1 -1
  191. package/build/modern/useQueries.d.ts +9 -6
  192. package/build/modern/useQueries.d.ts.map +1 -1
  193. package/build/modern/useQueries.js.map +1 -1
  194. package/build/modern/useQuery.cjs.map +1 -1
  195. package/build/modern/useQuery.d.cts +10 -6
  196. package/build/modern/useQuery.d.cts.map +1 -1
  197. package/build/modern/useQuery.d.ts +10 -6
  198. package/build/modern/useQuery.d.ts.map +1 -1
  199. package/build/modern/useQuery.js.map +1 -1
  200. package/build/modern/useSuspenseInfiniteQuery.d.cts +1 -2
  201. package/build/modern/useSuspenseInfiniteQuery.d.cts.map +1 -1
  202. package/build/modern/useSuspenseInfiniteQuery.d.ts +1 -2
  203. package/build/modern/useSuspenseInfiniteQuery.d.ts.map +1 -1
  204. package/build/modern/useSuspenseQueries.cjs.map +1 -1
  205. package/build/modern/useSuspenseQueries.d.cts +11 -8
  206. package/build/modern/useSuspenseQueries.d.cts.map +1 -1
  207. package/build/modern/useSuspenseQueries.d.ts +11 -8
  208. package/build/modern/useSuspenseQueries.d.ts.map +1 -1
  209. package/build/modern/useSuspenseQueries.js.map +1 -1
  210. package/build/modern/useSuspenseQuery.d.cts +1 -2
  211. package/build/modern/useSuspenseQuery.d.cts.map +1 -1
  212. package/build/modern/useSuspenseQuery.d.ts +1 -2
  213. package/build/modern/useSuspenseQuery.d.ts.map +1 -1
  214. package/build/modern/utils.d.cts +2 -3
  215. package/build/modern/utils.d.cts.map +1 -1
  216. package/build/modern/utils.d.ts +2 -3
  217. package/build/modern/utils.d.ts.map +1 -1
  218. package/package.json +9 -10
  219. package/src/infiniteQueryOptions.ts +1 -1
  220. package/src/queryOptions.ts +4 -4
  221. package/src/suspense.ts +1 -2
  222. package/src/types.ts +5 -4
  223. package/src/useBaseQuery.ts +3 -6
  224. package/src/useQueries.ts +6 -2
  225. package/src/useQuery.ts +7 -2
  226. package/src/useSuspenseQueries.ts +7 -3
  227. package/build/query-codemods/eslint.config.js +0 -25
  228. package/build/query-codemods/package.json +0 -38
  229. package/build/query-codemods/root.eslint.config.js +0 -113
  230. package/build/query-codemods/tsconfig.json +0 -8
  231. package/build/query-codemods/vite.config.ts +0 -30
  232. /package/build/codemods/{src/utils → utils}/index.cjs +0 -0
  233. /package/build/codemods/{src/utils → utils}/transformers/query-cache-transformer.cjs +0 -0
  234. /package/build/codemods/{src/utils → utils}/transformers/query-client-transformer.cjs +0 -0
  235. /package/build/codemods/{src/utils → utils}/transformers/use-query-like-transformer.cjs +0 -0
  236. /package/build/codemods/{src/v4 → v4}/key-transformation.cjs +0 -0
  237. /package/build/codemods/{src/v4 → v4}/replace-import-specifier.cjs +0 -0
  238. /package/build/codemods/{src/v4 → v4}/utils/replacers/key-replacer.cjs +0 -0
  239. /package/build/codemods/{src/v5 → v5}/is-loading/is-loading.cjs +0 -0
  240. /package/build/codemods/{src/v5 → v5}/keep-previous-data/README.md +0 -0
  241. /package/build/codemods/{src/v5 → v5}/keep-previous-data/keep-previous-data.cjs +0 -0
  242. /package/build/codemods/{src/v5 → v5}/keep-previous-data/utils/already-has-placeholder-data-property.cjs +0 -0
  243. /package/build/codemods/{src/v5 → v5}/remove-overloads/remove-overloads.cjs +0 -0
  244. /package/build/codemods/{src/v5 → v5}/remove-overloads/transformers/filter-aware-usage-transformer.cjs +0 -0
  245. /package/build/codemods/{src/v5 → v5}/remove-overloads/transformers/query-fn-aware-usage-transformer.cjs +0 -0
  246. /package/build/codemods/{src/v5 → v5}/remove-overloads/utils/index.cjs +0 -0
  247. /package/build/codemods/{src/v5 → v5}/remove-overloads/utils/unknown-usage-error.cjs +0 -0
  248. /package/build/codemods/{src/v5 → v5}/rename-hydrate/rename-hydrate.cjs +0 -0
  249. /package/build/codemods/{src/v5 → v5}/rename-properties/rename-properties.cjs +0 -0
package/build/legacy/useSuspenseQueries.d.ts CHANGED
@@ -41,9 +41,13 @@ type GetUseSuspenseQueryResult<T> = T extends {
41
41
  } ? UseSuspenseQueryResult<TQueryFnData, unknown extends TError ? DefaultError : TError> : UseSuspenseQueryResult;
42
42
  /**
43
43
  * The `queries` array accepted by `useSuspenseQueries`. Recursively unwraps each tuple element so every
44
- * entry's `queryFn`/`select` are inferred individually, up to 20 elements. An opaque array (e.g. `unknown[]`)
45
- * is returned as-is; a non-tuple array of a known element type, or a tuple past 20 elements, falls back to a
46
- * single homogeneous {@link UseSuspenseQueryOptions} type.
44
+ * entry's `queryFn`/`select` are inferred individually, up to 20 elements — past that, a tuple falls back to
45
+ * a single homogeneous {@link UseSuspenseQueryOptions} type.
46
+ *
47
+ * An opaque array (e.g. `unknown[]`) is returned as-is; a non-tuple array whose element type structurally
48
+ * matches a query options object is mapped per-element instead, still inferring each entry individually; any
49
+ * other non-tuple array — one whose element type doesn't match the expected options shape — falls back to
50
+ * that same homogeneous options type too.
47
51
  *
48
52
  * @template T - The type of the `queries` array as written at the call site.
49
53
  * @template TResults - The internal accumulator that this type builds during recursion. It is not meant
@@ -51,7 +55,7 @@ type GetUseSuspenseQueryResult<T> = T extends {
51
55
  * @template TDepth - The internal recursion-depth counter, checked against the 20-element limit. It is not
52
56
  * meant to be set explicitly.
53
57
  */
54
- 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>;
58
+ export 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>;
55
59
  /**
56
60
  * The result type returned by `useSuspenseQueries`, when no `combine` is provided. Mirrors
57
61
  * {@link SuspenseQueriesOptions}: each tuple element's result type is inferred individually, up to 20 elements.
@@ -64,7 +68,7 @@ type SuspenseQueriesOptions<T extends Array<any>, TResults extends Array<any> =
64
68
  * @template TDepth - The internal recursion-depth counter, checked against the 20-element limit. It is not
65
69
  * meant to be set explicitly.
66
70
  */
67
- 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]>; };
71
+ export 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]>; };
68
72
  /**
69
73
  * The options for `useSuspenseQueries` are the same as for `useQueries`, except that the top-level `subscribed`
70
74
  * option isn't supported, and each `query` can't have `throwOnError`, `enabled`, or `placeholderData`.
@@ -291,7 +295,7 @@ type SuspenseQueriesResults<T extends Array<any>, TResults extends Array<any> =
291
295
  * }
292
296
  * ```
293
297
  */
294
- declare function useSuspenseQueries<T extends Array<any>, TCombinedResult = SuspenseQueriesResults<T>>(options: {
298
+ export declare function useSuspenseQueries<T extends Array<any>, TCombinedResult = SuspenseQueriesResults<T>>(options: {
295
299
  /**
296
300
  * An array with query option objects identical to `useSuspenseQuery`.
297
301
  */
@@ -462,7 +466,7 @@ declare function useSuspenseQueries<T extends Array<any>, TCombinedResult = Susp
462
466
  * }
463
467
  * ```
464
468
  */
465
- declare function useSuspenseQueries<T extends Array<any>, TCombinedResult = SuspenseQueriesResults<T>>(options: {
469
+ export declare function useSuspenseQueries<T extends Array<any>, TCombinedResult = SuspenseQueriesResults<T>>(options: {
466
470
  /**
467
471
  * An array with query option objects identical to `useSuspenseQuery`.
468
472
  */
@@ -474,5 +478,4 @@ declare function useSuspenseQueries<T extends Array<any>, TCombinedResult = Susp
474
478
  combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult;
475
479
  }, queryClient?: QueryClient): TCombinedResult;
476
480
  //#endregion
477
- export { SuspenseQueriesOptions, SuspenseQueriesResults, useSuspenseQueries };
478
481
  //# sourceMappingURL=useSuspenseQueries.d.ts.map
package/build/legacy/useSuspenseQueries.d.ts.map CHANGED
@@ -1 +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;;;;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoOxC,mBACd,UAAU,YACV,kBAAkB,uBAAuB,IAEzC;;;;EAIE,sBACiB,uBAAuB,sBACpB,WAAW,IAAI,2BAA2B,EAAE;;;;;EAKhE,WAAW,QAAQ,uBAAuB,OAAO;GAEnD,cAAc,cACb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkKa,mBACd,UAAU,YACV,kBAAkB,uBAAuB,IAEzC;;;;EAIE,sBAAsB,uBAAuB;;;;;EAK7C,WAAW,QAAQ,uBAAuB,OAAO;GAEnD,cAAc,cACb"}
1
+ {"version":3,"file":"useSuspenseQueries.d.ts","names":[],"sources":["../../src/useSuspenseQueries.ts"],"mappings":"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"}
package/build/legacy/useSuspenseQueries.js.map CHANGED
@@ -1 +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 * 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 the top-level `subscribed`\n * option isn't supported, and each `query` can't have `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 * The query error is thrown if a fetch fails and no cached data exists yet, so an error boundary is\n * required around `<Suspense>`. A failed background refetch instead continues to render the cached data.\n * Use {@link QueryErrorResetBoundary} to let the user retry after such an error:\n * ```tsx\n * import { Suspense } from 'preact/compat'\n * import { useErrorBoundary } from 'preact/hooks'\n * import {\n * QueryErrorResetBoundary,\n * useSuspenseQueries,\n * } from '@tanstack/preact-query'\n * import type { ComponentChildren } from 'preact'\n *\n * function Posts({ ids }: { ids: Array<number> }) {\n * // Every result is guaranteed to be defined — no per-query `isPending` check needed.\n * const postQueries = useSuspenseQueries({\n * queries: ids.map((id) => ({\n * queryKey: ['post', id],\n * queryFn: () => fetchPost(id),\n * })),\n * })\n *\n * return (\n * <ul>\n * {postQueries.map((query) => (\n * <li key={query.data.id}>{query.data.title}</li>\n * ))}\n * </ul>\n * )\n * }\n *\n * function App() {\n * return (\n * <QueryErrorResetBoundary>\n * {({ reset }) => (\n * <ErrorBoundary\n * onReset={reset}\n * fallbackRender={({ resetErrorBoundary }) => (\n * <div>\n * There was an error!\n * <button onClick={() => resetErrorBoundary()}>Try again</button>\n * </div>\n * )}\n * >\n * <Suspense fallback={<h1>Loading posts...</h1>}>\n * <Posts ids={[1, 2, 3]} />\n * </Suspense>\n * </ErrorBoundary>\n * )}\n * </QueryErrorResetBoundary>\n * )\n * }\n *\n * function ErrorBoundary({\n * children,\n * onReset,\n * fallbackRender,\n * }: {\n * children: ComponentChildren\n * onReset: () => void\n * fallbackRender: (props: {\n * error: Error\n * resetErrorBoundary: () => void\n * }) => ComponentChildren\n * }) {\n * const [error, resetErrorBoundary] = useErrorBoundary(() => onReset())\n *\n * if (error) return fallbackRender({ error, resetErrorBoundary })\n *\n * return children\n * }\n * ```\n *\n * @example\n * Several different queries — use `useSuspenseQueries` instead of multiple `useSuspenseQuery` calls, so\n * they fetch in parallel rather than suspending one after another:\n * ```tsx\n * import { Suspense } from 'preact/compat'\n * import { useErrorBoundary } from 'preact/hooks'\n * import {\n * QueryErrorResetBoundary,\n * useSuspenseQueries,\n * } from '@tanstack/preact-query'\n * import type { ComponentChildren } from 'preact'\n *\n * function Dashboard() {\n * const [usersQuery, teamsQuery, projectsQuery] = useSuspenseQueries({\n * queries: [\n * { queryKey: ['users'], queryFn: fetchUsers },\n * { queryKey: ['teams'], queryFn: fetchTeams },\n * { queryKey: ['projects'], queryFn: fetchProjects },\n * ],\n * })\n *\n * return (\n * <div>\n * <UserList users={usersQuery.data} />\n * <TeamList teams={teamsQuery.data} />\n * <ProjectList projects={projectsQuery.data} />\n * </div>\n * )\n * }\n *\n * function App() {\n * return (\n * <QueryErrorResetBoundary>\n * {({ reset }) => (\n * <ErrorBoundary\n * onReset={reset}\n * fallbackRender={({ resetErrorBoundary }) => (\n * <div>\n * There was an error!\n * <button onClick={() => resetErrorBoundary()}>Try again</button>\n * </div>\n * )}\n * >\n * <Suspense fallback={<h1>Loading dashboard...</h1>}>\n * <Dashboard />\n * </Suspense>\n * </ErrorBoundary>\n * )}\n * </QueryErrorResetBoundary>\n * )\n * }\n *\n * function ErrorBoundary({\n * children,\n * onReset,\n * fallbackRender,\n * }: {\n * children: ComponentChildren\n * onReset: () => void\n * fallbackRender: (props: {\n * error: Error\n * resetErrorBoundary: () => void\n * }) => ComponentChildren\n * }) {\n * const [error, resetErrorBoundary] = useErrorBoundary(() => onReset())\n *\n * if (error) return fallbackRender({ error, resetErrorBoundary })\n *\n * return children\n * }\n * ```\n *\n * @example\n * `combine`s the results into a single boolean, so `Refresh` only re-renders when that boolean changes,\n * not on every individual query update. This overload is the only one that accepts `combine`:\n * ```tsx\n * import { Suspense } from 'preact/compat'\n * import { useErrorBoundary } from 'preact/hooks'\n * import {\n * QueryErrorResetBoundary,\n * useSuspenseQueries,\n * } from '@tanstack/preact-query'\n * import type { ComponentChildren } from 'preact'\n *\n * function Refresh() {\n * const anyFetching = useSuspenseQueries({\n * queries: [\n * { queryKey: ['users'], queryFn: fetchUsers },\n * { queryKey: ['teams'], queryFn: fetchTeams },\n * ],\n * combine: (results) => results.some((result) => result.isFetching),\n * })\n *\n * return anyFetching ? <span>Refreshing…</span> : null\n * }\n *\n * function App() {\n * return (\n * <QueryErrorResetBoundary>\n * {({ reset }) => (\n * <ErrorBoundary\n * onReset={reset}\n * fallbackRender={({ resetErrorBoundary }) => (\n * <div>\n * There was an error!\n * <button onClick={() => resetErrorBoundary()}>Try again</button>\n * </div>\n * )}\n * >\n * <Suspense fallback={<h1>Loading dashboard...</h1>}>\n * <Refresh />\n * </Suspense>\n * </ErrorBoundary>\n * )}\n * </QueryErrorResetBoundary>\n * )\n * }\n *\n * function ErrorBoundary({\n * children,\n * onReset,\n * fallbackRender,\n * }: {\n * children: ComponentChildren\n * onReset: () => void\n * fallbackRender: (props: {\n * error: Error\n * resetErrorBoundary: () => void\n * }) => ComponentChildren\n * }) {\n * const [error, resetErrorBoundary] = useErrorBoundary(() => onReset())\n *\n * if (error) return fallbackRender({ error, resetErrorBoundary })\n *\n * return children\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 the top-level `subscribed`\n * option isn't supported, and each `query` can't have `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 * The query error is thrown if a fetch fails and no cached data exists yet, so an error boundary is\n * required around `<Suspense>`. A failed background refetch instead continues to render the cached data.\n * Use {@link QueryErrorResetBoundary} to let the user retry after such an error:\n * ```tsx\n * import { Suspense } from 'preact/compat'\n * import { useErrorBoundary } from 'preact/hooks'\n * import {\n * QueryErrorResetBoundary,\n * useSuspenseQueries,\n * } from '@tanstack/preact-query'\n * import type { ComponentChildren } from 'preact'\n *\n * function Posts({ ids }: { ids: Array<number> }) {\n * // Every result is guaranteed to be defined — no per-query `isPending` check needed.\n * const postQueries = useSuspenseQueries({\n * queries: ids.map((id) => ({\n * queryKey: ['post', id],\n * queryFn: () => fetchPost(id),\n * })),\n * })\n *\n * return (\n * <ul>\n * {postQueries.map((query) => (\n * <li key={query.data.id}>{query.data.title}</li>\n * ))}\n * </ul>\n * )\n * }\n *\n * function App() {\n * return (\n * <QueryErrorResetBoundary>\n * {({ reset }) => (\n * <ErrorBoundary\n * onReset={reset}\n * fallbackRender={({ resetErrorBoundary }) => (\n * <div>\n * There was an error!\n * <button onClick={() => resetErrorBoundary()}>Try again</button>\n * </div>\n * )}\n * >\n * <Suspense fallback={<h1>Loading posts...</h1>}>\n * <Posts ids={[1, 2, 3]} />\n * </Suspense>\n * </ErrorBoundary>\n * )}\n * </QueryErrorResetBoundary>\n * )\n * }\n *\n * function ErrorBoundary({\n * children,\n * onReset,\n * fallbackRender,\n * }: {\n * children: ComponentChildren\n * onReset: () => void\n * fallbackRender: (props: {\n * error: Error\n * resetErrorBoundary: () => void\n * }) => ComponentChildren\n * }) {\n * const [error, resetErrorBoundary] = useErrorBoundary(() => onReset())\n *\n * if (error) return fallbackRender({ error, resetErrorBoundary })\n *\n * return children\n * }\n * ```\n *\n * @example\n * Several different queries — use `useSuspenseQueries` instead of multiple `useSuspenseQuery` calls, so\n * they fetch in parallel rather than suspending one after another:\n * ```tsx\n * import { Suspense } from 'preact/compat'\n * import { useErrorBoundary } from 'preact/hooks'\n * import {\n * QueryErrorResetBoundary,\n * useSuspenseQueries,\n * } from '@tanstack/preact-query'\n * import type { ComponentChildren } from 'preact'\n *\n * function Dashboard() {\n * const [usersQuery, teamsQuery, projectsQuery] = useSuspenseQueries({\n * queries: [\n * { queryKey: ['users'], queryFn: fetchUsers },\n * { queryKey: ['teams'], queryFn: fetchTeams },\n * { queryKey: ['projects'], queryFn: fetchProjects },\n * ],\n * })\n *\n * return (\n * <div>\n * <UserList users={usersQuery.data} />\n * <TeamList teams={teamsQuery.data} />\n * <ProjectList projects={projectsQuery.data} />\n * </div>\n * )\n * }\n *\n * function App() {\n * return (\n * <QueryErrorResetBoundary>\n * {({ reset }) => (\n * <ErrorBoundary\n * onReset={reset}\n * fallbackRender={({ resetErrorBoundary }) => (\n * <div>\n * There was an error!\n * <button onClick={() => resetErrorBoundary()}>Try again</button>\n * </div>\n * )}\n * >\n * <Suspense fallback={<h1>Loading dashboard...</h1>}>\n * <Dashboard />\n * </Suspense>\n * </ErrorBoundary>\n * )}\n * </QueryErrorResetBoundary>\n * )\n * }\n *\n * function ErrorBoundary({\n * children,\n * onReset,\n * fallbackRender,\n * }: {\n * children: ComponentChildren\n * onReset: () => void\n * fallbackRender: (props: {\n * error: Error\n * resetErrorBoundary: () => void\n * }) => ComponentChildren\n * }) {\n * const [error, resetErrorBoundary] = useErrorBoundary(() => onReset())\n *\n * if (error) return fallbackRender({ error, resetErrorBoundary })\n *\n * return children\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":";;;;AA8lBA,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"}
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 * 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 — past that, a tuple falls back to\n * a single homogeneous {@link UseSuspenseQueryOptions} type.\n *\n * An opaque array (e.g. `unknown[]`) is returned as-is; a non-tuple array whose element type structurally\n * matches a query options object is mapped per-element instead, still inferring each entry individually; any\n * other non-tuple array — one whose element type doesn't match the expected options shape — falls back to\n * that same homogeneous options type too.\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 the top-level `subscribed`\n * option isn't supported, and each `query` can't have `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 * The query error is thrown if a fetch fails and no cached data exists yet, so an error boundary is\n * required around `<Suspense>`. A failed background refetch instead continues to render the cached data.\n * Use {@link QueryErrorResetBoundary} to let the user retry after such an error:\n * ```tsx\n * import { Suspense } from 'preact/compat'\n * import { useErrorBoundary } from 'preact/hooks'\n * import {\n * QueryErrorResetBoundary,\n * useSuspenseQueries,\n * } from '@tanstack/preact-query'\n * import type { ComponentChildren } from 'preact'\n *\n * function Posts({ ids }: { ids: Array<number> }) {\n * // Every result is guaranteed to be defined — no per-query `isPending` check needed.\n * const postQueries = useSuspenseQueries({\n * queries: ids.map((id) => ({\n * queryKey: ['post', id],\n * queryFn: () => fetchPost(id),\n * })),\n * })\n *\n * return (\n * <ul>\n * {postQueries.map((query) => (\n * <li key={query.data.id}>{query.data.title}</li>\n * ))}\n * </ul>\n * )\n * }\n *\n * function App() {\n * return (\n * <QueryErrorResetBoundary>\n * {({ reset }) => (\n * <ErrorBoundary\n * onReset={reset}\n * fallbackRender={({ resetErrorBoundary }) => (\n * <div>\n * There was an error!\n * <button onClick={() => resetErrorBoundary()}>Try again</button>\n * </div>\n * )}\n * >\n * <Suspense fallback={<h1>Loading posts...</h1>}>\n * <Posts ids={[1, 2, 3]} />\n * </Suspense>\n * </ErrorBoundary>\n * )}\n * </QueryErrorResetBoundary>\n * )\n * }\n *\n * function ErrorBoundary({\n * children,\n * onReset,\n * fallbackRender,\n * }: {\n * children: ComponentChildren\n * onReset: () => void\n * fallbackRender: (props: {\n * error: Error\n * resetErrorBoundary: () => void\n * }) => ComponentChildren\n * }) {\n * const [error, resetErrorBoundary] = useErrorBoundary(() => onReset())\n *\n * if (error) return fallbackRender({ error, resetErrorBoundary })\n *\n * return children\n * }\n * ```\n *\n * @example\n * Several different queries — use `useSuspenseQueries` instead of multiple `useSuspenseQuery` calls, so\n * they fetch in parallel rather than suspending one after another:\n * ```tsx\n * import { Suspense } from 'preact/compat'\n * import { useErrorBoundary } from 'preact/hooks'\n * import {\n * QueryErrorResetBoundary,\n * useSuspenseQueries,\n * } from '@tanstack/preact-query'\n * import type { ComponentChildren } from 'preact'\n *\n * function Dashboard() {\n * const [usersQuery, teamsQuery, projectsQuery] = useSuspenseQueries({\n * queries: [\n * { queryKey: ['users'], queryFn: fetchUsers },\n * { queryKey: ['teams'], queryFn: fetchTeams },\n * { queryKey: ['projects'], queryFn: fetchProjects },\n * ],\n * })\n *\n * return (\n * <div>\n * <UserList users={usersQuery.data} />\n * <TeamList teams={teamsQuery.data} />\n * <ProjectList projects={projectsQuery.data} />\n * </div>\n * )\n * }\n *\n * function App() {\n * return (\n * <QueryErrorResetBoundary>\n * {({ reset }) => (\n * <ErrorBoundary\n * onReset={reset}\n * fallbackRender={({ resetErrorBoundary }) => (\n * <div>\n * There was an error!\n * <button onClick={() => resetErrorBoundary()}>Try again</button>\n * </div>\n * )}\n * >\n * <Suspense fallback={<h1>Loading dashboard...</h1>}>\n * <Dashboard />\n * </Suspense>\n * </ErrorBoundary>\n * )}\n * </QueryErrorResetBoundary>\n * )\n * }\n *\n * function ErrorBoundary({\n * children,\n * onReset,\n * fallbackRender,\n * }: {\n * children: ComponentChildren\n * onReset: () => void\n * fallbackRender: (props: {\n * error: Error\n * resetErrorBoundary: () => void\n * }) => ComponentChildren\n * }) {\n * const [error, resetErrorBoundary] = useErrorBoundary(() => onReset())\n *\n * if (error) return fallbackRender({ error, resetErrorBoundary })\n *\n * return children\n * }\n * ```\n *\n * @example\n * `combine`s the results into a single boolean, so `Refresh` only re-renders when that boolean changes,\n * not on every individual query update. This overload is the only one that accepts `combine`:\n * ```tsx\n * import { Suspense } from 'preact/compat'\n * import { useErrorBoundary } from 'preact/hooks'\n * import {\n * QueryErrorResetBoundary,\n * useSuspenseQueries,\n * } from '@tanstack/preact-query'\n * import type { ComponentChildren } from 'preact'\n *\n * function Refresh() {\n * const anyFetching = useSuspenseQueries({\n * queries: [\n * { queryKey: ['users'], queryFn: fetchUsers },\n * { queryKey: ['teams'], queryFn: fetchTeams },\n * ],\n * combine: (results) => results.some((result) => result.isFetching),\n * })\n *\n * return anyFetching ? <span>Refreshing…</span> : null\n * }\n *\n * function App() {\n * return (\n * <QueryErrorResetBoundary>\n * {({ reset }) => (\n * <ErrorBoundary\n * onReset={reset}\n * fallbackRender={({ resetErrorBoundary }) => (\n * <div>\n * There was an error!\n * <button onClick={() => resetErrorBoundary()}>Try again</button>\n * </div>\n * )}\n * >\n * <Suspense fallback={<h1>Loading dashboard...</h1>}>\n * <Refresh />\n * </Suspense>\n * </ErrorBoundary>\n * )}\n * </QueryErrorResetBoundary>\n * )\n * }\n *\n * function ErrorBoundary({\n * children,\n * onReset,\n * fallbackRender,\n * }: {\n * children: ComponentChildren\n * onReset: () => void\n * fallbackRender: (props: {\n * error: Error\n * resetErrorBoundary: () => void\n * }) => ComponentChildren\n * }) {\n * const [error, resetErrorBoundary] = useErrorBoundary(() => onReset())\n *\n * if (error) return fallbackRender({ error, resetErrorBoundary })\n *\n * return children\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 the top-level `subscribed`\n * option isn't supported, and each `query` can't have `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 * The query error is thrown if a fetch fails and no cached data exists yet, so an error boundary is\n * required around `<Suspense>`. A failed background refetch instead continues to render the cached data.\n * Use {@link QueryErrorResetBoundary} to let the user retry after such an error:\n * ```tsx\n * import { Suspense } from 'preact/compat'\n * import { useErrorBoundary } from 'preact/hooks'\n * import {\n * QueryErrorResetBoundary,\n * useSuspenseQueries,\n * } from '@tanstack/preact-query'\n * import type { ComponentChildren } from 'preact'\n *\n * function Posts({ ids }: { ids: Array<number> }) {\n * // Every result is guaranteed to be defined — no per-query `isPending` check needed.\n * const postQueries = useSuspenseQueries({\n * queries: ids.map((id) => ({\n * queryKey: ['post', id],\n * queryFn: () => fetchPost(id),\n * })),\n * })\n *\n * return (\n * <ul>\n * {postQueries.map((query) => (\n * <li key={query.data.id}>{query.data.title}</li>\n * ))}\n * </ul>\n * )\n * }\n *\n * function App() {\n * return (\n * <QueryErrorResetBoundary>\n * {({ reset }) => (\n * <ErrorBoundary\n * onReset={reset}\n * fallbackRender={({ resetErrorBoundary }) => (\n * <div>\n * There was an error!\n * <button onClick={() => resetErrorBoundary()}>Try again</button>\n * </div>\n * )}\n * >\n * <Suspense fallback={<h1>Loading posts...</h1>}>\n * <Posts ids={[1, 2, 3]} />\n * </Suspense>\n * </ErrorBoundary>\n * )}\n * </QueryErrorResetBoundary>\n * )\n * }\n *\n * function ErrorBoundary({\n * children,\n * onReset,\n * fallbackRender,\n * }: {\n * children: ComponentChildren\n * onReset: () => void\n * fallbackRender: (props: {\n * error: Error\n * resetErrorBoundary: () => void\n * }) => ComponentChildren\n * }) {\n * const [error, resetErrorBoundary] = useErrorBoundary(() => onReset())\n *\n * if (error) return fallbackRender({ error, resetErrorBoundary })\n *\n * return children\n * }\n * ```\n *\n * @example\n * Several different queries — use `useSuspenseQueries` instead of multiple `useSuspenseQuery` calls, so\n * they fetch in parallel rather than suspending one after another:\n * ```tsx\n * import { Suspense } from 'preact/compat'\n * import { useErrorBoundary } from 'preact/hooks'\n * import {\n * QueryErrorResetBoundary,\n * useSuspenseQueries,\n * } from '@tanstack/preact-query'\n * import type { ComponentChildren } from 'preact'\n *\n * function Dashboard() {\n * const [usersQuery, teamsQuery, projectsQuery] = useSuspenseQueries({\n * queries: [\n * { queryKey: ['users'], queryFn: fetchUsers },\n * { queryKey: ['teams'], queryFn: fetchTeams },\n * { queryKey: ['projects'], queryFn: fetchProjects },\n * ],\n * })\n *\n * return (\n * <div>\n * <UserList users={usersQuery.data} />\n * <TeamList teams={teamsQuery.data} />\n * <ProjectList projects={projectsQuery.data} />\n * </div>\n * )\n * }\n *\n * function App() {\n * return (\n * <QueryErrorResetBoundary>\n * {({ reset }) => (\n * <ErrorBoundary\n * onReset={reset}\n * fallbackRender={({ resetErrorBoundary }) => (\n * <div>\n * There was an error!\n * <button onClick={() => resetErrorBoundary()}>Try again</button>\n * </div>\n * )}\n * >\n * <Suspense fallback={<h1>Loading dashboard...</h1>}>\n * <Dashboard />\n * </Suspense>\n * </ErrorBoundary>\n * )}\n * </QueryErrorResetBoundary>\n * )\n * }\n *\n * function ErrorBoundary({\n * children,\n * onReset,\n * fallbackRender,\n * }: {\n * children: ComponentChildren\n * onReset: () => void\n * fallbackRender: (props: {\n * error: Error\n * resetErrorBoundary: () => void\n * }) => ComponentChildren\n * }) {\n * const [error, resetErrorBoundary] = useErrorBoundary(() => onReset())\n *\n * if (error) return fallbackRender({ error, resetErrorBoundary })\n *\n * return children\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":";;;;AAkmBA,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.d.cts CHANGED
@@ -88,7 +88,6 @@ import { DefaultError, QueryClient, QueryKey } from "@tanstack/query-core";
88
88
  * }
89
89
  * ```
90
90
  */
91
- declare function useSuspenseQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseSuspenseQueryResult<TData, TError>;
91
+ export declare function useSuspenseQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseSuspenseQueryResult<TData, TError>;
92
92
  //#endregion
93
- export { useSuspenseQuery };
94
93
  //# sourceMappingURL=useSuspenseQuery.d.cts.map
package/build/legacy/useSuspenseQuery.d.cts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"useSuspenseQuery.d.cts","names":[],"sources":["../../src/useSuspenseQuery.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8FgB,iBACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,wBAAwB,cAAc,QAAQ,OAAO,YAC9D,cAAc,cACb,uBAAuB,OAAO"}
1
+ {"version":3,"file":"useSuspenseQuery.d.cts","names":[],"sources":["../../src/useSuspenseQuery.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8FgB,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 CHANGED
@@ -88,7 +88,6 @@ import { DefaultError, QueryClient, QueryKey } from "@tanstack/query-core";
88
88
  * }
89
89
  * ```
90
90
  */
91
- declare function useSuspenseQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseSuspenseQueryResult<TData, TError>;
91
+ export declare function useSuspenseQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseSuspenseQueryResult<TData, TError>;
92
92
  //#endregion
93
- export { useSuspenseQuery };
94
93
  //# sourceMappingURL=useSuspenseQuery.d.ts.map
package/build/legacy/useSuspenseQuery.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"useSuspenseQuery.d.ts","names":[],"sources":["../../src/useSuspenseQuery.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8FgB,iBACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,wBAAwB,cAAc,QAAQ,OAAO,YAC9D,cAAc,cACb,uBAAuB,OAAO"}
1
+ {"version":3,"file":"useSuspenseQuery.d.ts","names":[],"sources":["../../src/useSuspenseQuery.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8FgB,iBACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,wBAAwB,cAAc,QAAQ,OAAO,YAC9D,cAAc,cACb,uBAAuB,OAAO"}
package/build/legacy/utils.d.cts CHANGED
@@ -1,6 +1,5 @@
1
1
  //#region src/utils.d.ts
2
- declare function useSyncExternalStore(subscribe: (onStoreChange: () => void) => () => void, getSnapshot: () => any): any;
3
- declare function useSyncExternalStoreWithSelector<TSnapshot, TSelected>(subscribe: (onStoreChange: () => void) => () => void, getSnapshot: () => TSnapshot, selector: (snapshot: TSnapshot) => TSelected, isEqual: (a: TSelected, b: TSelected) => boolean): TSelected;
2
+ export declare function useSyncExternalStore(subscribe: (onStoreChange: () => void) => () => void, getSnapshot: () => any): any;
3
+ export declare function useSyncExternalStoreWithSelector<TSnapshot, TSelected>(subscribe: (onStoreChange: () => void) => () => void, getSnapshot: () => TSnapshot, selector: (snapshot: TSnapshot) => TSelected, isEqual: (a: TSelected, b: TSelected) => boolean): TSelected;
4
4
  //#endregion
5
- export { useSyncExternalStore, useSyncExternalStoreWithSelector };
6
5
  //# sourceMappingURL=utils.d.cts.map
package/build/legacy/utils.d.cts.map CHANGED
@@ -1 +1 @@
1
- {"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"}
1
+ {"version":3,"file":"utils.d.cts","names":[],"sources":["../../src/utils.ts"],"mappings":";wBAegB,qBACd,YAAY,0CACZ;wBA8Cc,iCAAiC,WAAW,WAC1D,YAAY,0CACZ,mBAAmB,WACnB,WAAW,UAAU,cAAc,WACnC,UAAU,GAAG,WAAW,GAAG,wBAC1B"}
package/build/legacy/utils.d.ts CHANGED
@@ -1,6 +1,5 @@
1
1
  //#region src/utils.d.ts
2
- declare function useSyncExternalStore(subscribe: (onStoreChange: () => void) => () => void, getSnapshot: () => any): any;
3
- declare function useSyncExternalStoreWithSelector<TSnapshot, TSelected>(subscribe: (onStoreChange: () => void) => () => void, getSnapshot: () => TSnapshot, selector: (snapshot: TSnapshot) => TSelected, isEqual: (a: TSelected, b: TSelected) => boolean): TSelected;
2
+ export declare function useSyncExternalStore(subscribe: (onStoreChange: () => void) => () => void, getSnapshot: () => any): any;
3
+ export declare function useSyncExternalStoreWithSelector<TSnapshot, TSelected>(subscribe: (onStoreChange: () => void) => () => void, getSnapshot: () => TSnapshot, selector: (snapshot: TSnapshot) => TSelected, isEqual: (a: TSelected, b: TSelected) => boolean): TSelected;
4
4
  //#endregion
5
- export { useSyncExternalStore, useSyncExternalStoreWithSelector };
6
5
  //# sourceMappingURL=utils.d.ts.map
package/build/legacy/utils.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"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"}
1
+ {"version":3,"file":"utils.d.ts","names":[],"sources":["../../src/utils.ts"],"mappings":";wBAegB,qBACd,YAAY,0CACZ;wBA8Cc,iCAAiC,WAAW,WAC1D,YAAY,0CACZ,mBAAmB,WACnB,WAAW,UAAU,cAAc,WACnC,UAAU,GAAG,WAAW,GAAG,wBAC1B"}
package/build/modern/HydrationBoundary.d.cts CHANGED
@@ -4,7 +4,7 @@ import { ComponentChildren } from "preact";
4
4
  /**
5
5
  * The props accepted by `HydrationBoundary`.
6
6
  */
7
- interface HydrationBoundaryProps {
7
+ export interface HydrationBoundaryProps {
8
8
  /**
9
9
  * The state to hydrate.
10
10
  */
@@ -70,7 +70,6 @@ interface HydrationBoundaryProps {
70
70
  * }
71
71
  * ```
72
72
  */
73
- declare const HydrationBoundary: ({ children, options, state, queryClient }: HydrationBoundaryProps) => import("preact").JSX.Element;
73
+ export declare const HydrationBoundary: ({ children, options, state, queryClient }: HydrationBoundaryProps) => import("preact").JSX.Element;
74
74
  //#endregion
75
- export { HydrationBoundary, HydrationBoundaryProps };
76
75
  //# sourceMappingURL=HydrationBoundary.d.cts.map
package/build/modern/HydrationBoundary.d.cts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"HydrationBoundary.d.cts","names":[],"sources":["../../src/HydrationBoundary.tsx"],"mappings":";;;;;;UAgBiB;;;;EAIf,OAAO;;;;EAIP,UAAU,UAAU;IAClB,iBAAiB,UACf,QAAQ;;;;;;;;EAUZ,WAAW;;;;EAIX,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8CH,sBAAqB,UAAA,SAAA,OAAA,eAK/B,4CAAsB,IAAA"}
1
+ {"version":3,"file":"HydrationBoundary.d.cts","names":[],"sources":["../../src/HydrationBoundary.tsx"],"mappings":";;;;;;iBAgBiB;;;;EAIf,OAAO;;;;EAIP,UAAU,UAAU;IAClB,iBAAiB,UACf,QAAQ;;;;;;;;EAUZ,WAAW;;;;EAIX,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA8CH,sBAAqB,UAAA,SAAA,OAAA,eAK/B,4CAAsB,IAAA"}
package/build/modern/HydrationBoundary.d.ts CHANGED
@@ -4,7 +4,7 @@ import { ComponentChildren } from "preact";
4
4
  /**
5
5
  * The props accepted by `HydrationBoundary`.
6
6
  */
7
- interface HydrationBoundaryProps {
7
+ export interface HydrationBoundaryProps {
8
8
  /**
9
9
  * The state to hydrate.
10
10
  */
@@ -70,7 +70,6 @@ interface HydrationBoundaryProps {
70
70
  * }
71
71
  * ```
72
72
  */
73
- declare const HydrationBoundary: ({ children, options, state, queryClient }: HydrationBoundaryProps) => import("preact").JSX.Element;
73
+ export declare const HydrationBoundary: ({ children, options, state, queryClient }: HydrationBoundaryProps) => import("preact").JSX.Element;
74
74
  //#endregion
75
- export { HydrationBoundary, HydrationBoundaryProps };
76
75
  //# sourceMappingURL=HydrationBoundary.d.ts.map
package/build/modern/HydrationBoundary.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"HydrationBoundary.d.ts","names":[],"sources":["../../src/HydrationBoundary.tsx"],"mappings":";;;;;;UAgBiB;;;;EAIf,OAAO;;;;EAIP,UAAU,UAAU;IAClB,iBAAiB,UACf,QAAQ;;;;;;;;EAUZ,WAAW;;;;EAIX,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8CH,sBAAqB,UAAA,SAAA,OAAA,eAK/B,4CAAsB,IAAA"}
1
+ {"version":3,"file":"HydrationBoundary.d.ts","names":[],"sources":["../../src/HydrationBoundary.tsx"],"mappings":";;;;;;iBAgBiB;;;;EAIf,OAAO;;;;EAIP,UAAU,UAAU;IAClB,iBAAiB,UACf,QAAQ;;;;;;;;EAUZ,WAAW;;;;EAIX,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA8CH,sBAAqB,UAAA,SAAA,OAAA,eAK/B,4CAAsB,IAAA"}
package/build/modern/IsRestoringProvider.d.cts CHANGED
@@ -6,12 +6,11 @@
6
6
  *
7
7
  * @returns `true` while a persisted client is being restored, `false` otherwise.
8
8
  */
9
- declare const useIsRestoring: () => boolean;
9
+ export declare const useIsRestoring: () => boolean;
10
10
  /**
11
11
  * The Provider that `PersistQueryClientProvider` uses to signal whether a persisted client is currently
12
12
  * being restored, read by `useIsRestoring`.
13
13
  */
14
- declare const IsRestoringProvider: import("preact").Provider<boolean>;
14
+ export declare const IsRestoringProvider: import("preact").Provider<boolean>;
15
15
  //#endregion
16
- export { IsRestoringProvider, useIsRestoring };
17
16
  //# sourceMappingURL=IsRestoringProvider.d.cts.map
package/build/modern/IsRestoringProvider.d.cts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"IsRestoringProvider.d.cts","names":[],"sources":["../../src/IsRestoringProvider.ts"],"mappings":";;;;;;;;cAYa;;;;;cAMA,sCAAmB"}
1
+ {"version":3,"file":"IsRestoringProvider.d.cts","names":[],"sources":["../../src/IsRestoringProvider.ts"],"mappings":";;;;;;;;qBAYa;;;;;qBAMA,sCAAmB"}
package/build/modern/IsRestoringProvider.d.ts CHANGED
@@ -6,12 +6,11 @@
6
6
  *
7
7
  * @returns `true` while a persisted client is being restored, `false` otherwise.
8
8
  */
9
- declare const useIsRestoring: () => boolean;
9
+ export declare const useIsRestoring: () => boolean;
10
10
  /**
11
11
  * The Provider that `PersistQueryClientProvider` uses to signal whether a persisted client is currently
12
12
  * being restored, read by `useIsRestoring`.
13
13
  */
14
- declare const IsRestoringProvider: import("preact").Provider<boolean>;
14
+ export declare const IsRestoringProvider: import("preact").Provider<boolean>;
15
15
  //#endregion
16
- export { IsRestoringProvider, useIsRestoring };
17
16
  //# sourceMappingURL=IsRestoringProvider.d.ts.map
package/build/modern/IsRestoringProvider.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"IsRestoringProvider.d.ts","names":[],"sources":["../../src/IsRestoringProvider.ts"],"mappings":";;;;;;;;cAYa;;;;;cAMA,sCAAmB"}
1
+ {"version":3,"file":"IsRestoringProvider.d.ts","names":[],"sources":["../../src/IsRestoringProvider.ts"],"mappings":";;;;;;;;qBAYa;;;;;qBAMA,sCAAmB"}
package/build/modern/QueryClientProvider.d.cts CHANGED
@@ -4,7 +4,7 @@ import { ComponentChildren, VNode } from "preact";
4
4
  /**
5
5
  * The context that `useQueryClient` reads from. `QueryClientProvider` is the normal way to set it.
6
6
  */
7
- declare const QueryClientContext: import("preact").Context<QueryClient | undefined>;
7
+ export declare const QueryClientContext: import("preact").Context<QueryClient | undefined>;
8
8
  /**
9
9
  * The `useQueryClient` hook returns the current `QueryClient` instance.
10
10
  *
@@ -13,11 +13,11 @@ declare const QueryClientContext: import("preact").Context<QueryClient | undefin
13
13
  * @returns The current `QueryClient` instance.
14
14
  * @throws If no `queryClient` argument is passed and no `QueryClientProvider` is found in the component tree.
15
15
  */
16
- declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
16
+ export declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
17
17
  /**
18
18
  * The props accepted by `QueryClientProvider`.
19
19
  */
20
- type QueryClientProviderProps = {
20
+ export type QueryClientProviderProps = {
21
21
  /**
22
22
  * **Required**
23
23
  *
@@ -48,7 +48,6 @@ type QueryClientProviderProps = {
48
48
  * }
49
49
  * ```
50
50
  */
51
- declare const QueryClientProvider: ({ client, children }: QueryClientProviderProps) => VNode;
51
+ export declare const QueryClientProvider: ({ client, children }: QueryClientProviderProps) => VNode;
52
52
  //#endregion
53
- export { QueryClientContext, QueryClientProvider, QueryClientProviderProps, useQueryClient };
54
53
  //# sourceMappingURL=QueryClientProvider.d.cts.map
package/build/modern/QueryClientProvider.d.cts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"QueryClientProvider.d.cts","names":[],"sources":["../../src/QueryClientProvider.tsx"],"mappings":";;;;;;cAQa,qCAAkB,QAAA;;;;;;;;;cAYlB,iBAAkB,cAAc,gBAAW;;;;KAiB5C;;;;;;EAMV,QAAQ;;;;EAIR,WAAW;;;;;;;;;;;;;;;;;;;;;cAsBA,wBAAuB,QAAA,YAGjC,6BAA2B"}
1
+ {"version":3,"file":"QueryClientProvider.d.cts","names":[],"sources":["../../src/QueryClientProvider.tsx"],"mappings":";;;;;;qBAQa,qCAAkB,QAAA;;;;;;;;;qBAYlB,iBAAkB,cAAc,gBAAW;;;;YAiB5C;;;;;;EAMV,QAAQ;;;;EAIR,WAAW;;;;;;;;;;;;;;;;;;;;;qBAsBA,wBAAuB,QAAA,YAGjC,6BAA2B"}
package/build/modern/QueryClientProvider.d.ts CHANGED
@@ -4,7 +4,7 @@ import { ComponentChildren, VNode } from "preact";
4
4
  /**
5
5
  * The context that `useQueryClient` reads from. `QueryClientProvider` is the normal way to set it.
6
6
  */
7
- declare const QueryClientContext: import("preact").Context<QueryClient | undefined>;
7
+ export declare const QueryClientContext: import("preact").Context<QueryClient | undefined>;
8
8
  /**
9
9
  * The `useQueryClient` hook returns the current `QueryClient` instance.
10
10
  *
@@ -13,11 +13,11 @@ declare const QueryClientContext: import("preact").Context<QueryClient | undefin
13
13
  * @returns The current `QueryClient` instance.
14
14
  * @throws If no `queryClient` argument is passed and no `QueryClientProvider` is found in the component tree.
15
15
  */
16
- declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
16
+ export declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
17
17
  /**
18
18
  * The props accepted by `QueryClientProvider`.
19
19
  */
20
- type QueryClientProviderProps = {
20
+ export type QueryClientProviderProps = {
21
21
  /**
22
22
  * **Required**
23
23
  *
@@ -48,7 +48,6 @@ type QueryClientProviderProps = {
48
48
  * }
49
49
  * ```
50
50
  */
51
- declare const QueryClientProvider: ({ client, children }: QueryClientProviderProps) => VNode;
51
+ export declare const QueryClientProvider: ({ client, children }: QueryClientProviderProps) => VNode;
52
52
  //#endregion
53
- export { QueryClientContext, QueryClientProvider, QueryClientProviderProps, useQueryClient };
54
53
  //# sourceMappingURL=QueryClientProvider.d.ts.map
package/build/modern/QueryClientProvider.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"QueryClientProvider.d.ts","names":[],"sources":["../../src/QueryClientProvider.tsx"],"mappings":";;;;;;cAQa,qCAAkB,QAAA;;;;;;;;;cAYlB,iBAAkB,cAAc,gBAAW;;;;KAiB5C;;;;;;EAMV,QAAQ;;;;EAIR,WAAW;;;;;;;;;;;;;;;;;;;;;cAsBA,wBAAuB,QAAA,YAGjC,6BAA2B"}
1
+ {"version":3,"file":"QueryClientProvider.d.ts","names":[],"sources":["../../src/QueryClientProvider.tsx"],"mappings":";;;;;;qBAQa,qCAAkB,QAAA;;;;;;;;;qBAYlB,iBAAkB,cAAc,gBAAW;;;;YAiB5C;;;;;;EAMV,QAAQ;;;;EAIR,WAAW;;;;;;;;;;;;;;;;;;;;;qBAsBA,wBAAuB,QAAA,YAGjC,6BAA2B"}
package/build/modern/QueryErrorResetBoundary.d.cts CHANGED
@@ -3,16 +3,16 @@ import { ComponentChildren } from "preact";
3
3
  /**
4
4
  * Resets any query errors within the boundary, so queries know they can try again.
5
5
  */
6
- type QueryErrorResetFunction = () => void;
6
+ export type QueryErrorResetFunction = () => void;
7
7
  /**
8
8
  * Returns whether the boundary has been reset and not yet cleared.
9
9
  */
10
- type QueryErrorIsResetFunction = () => boolean;
10
+ export type QueryErrorIsResetFunction = () => boolean;
11
11
  /**
12
12
  * Clears the reset state, so queries know not to try again until the boundary is reset again.
13
13
  */
14
- type QueryErrorClearResetFunction = () => void;
15
- interface QueryErrorResetBoundaryValue {
14
+ export type QueryErrorClearResetFunction = () => void;
15
+ export interface QueryErrorResetBoundaryValue {
16
16
  /**
17
17
  * Clears the reset state, so queries know not to try again until the boundary is reset again.
18
18
  */
@@ -55,18 +55,18 @@ interface QueryErrorResetBoundaryValue {
55
55
  * }
56
56
  * ```
57
57
  */
58
- declare const useQueryErrorResetBoundary: () => QueryErrorResetBoundaryValue;
58
+ export declare const useQueryErrorResetBoundary: () => QueryErrorResetBoundaryValue;
59
59
  /**
60
60
  * A render-prop function usable as `children` on `QueryErrorResetBoundary`.
61
61
  *
62
62
  * @param value - The boundary's {@link QueryErrorResetBoundaryValue}.
63
63
  * @returns The children to render.
64
64
  */
65
- type QueryErrorResetBoundaryFunction = (value: QueryErrorResetBoundaryValue) => ComponentChildren;
65
+ export type QueryErrorResetBoundaryFunction = (value: QueryErrorResetBoundaryValue) => ComponentChildren;
66
66
  /**
67
67
  * The props accepted by `QueryErrorResetBoundary`.
68
68
  */
69
- interface QueryErrorResetBoundaryProps {
69
+ export interface QueryErrorResetBoundaryProps {
70
70
  /**
71
71
  * Either a plain node, or a function that receives the boundary's {@link QueryErrorResetBoundaryValue} and
72
72
  * returns a node.
@@ -121,7 +121,6 @@ interface QueryErrorResetBoundaryProps {
121
121
  * }
122
122
  * ```
123
123
  */
124
- declare const QueryErrorResetBoundary: ({ children }: QueryErrorResetBoundaryProps) => import("preact").JSX.Element;
124
+ export declare const QueryErrorResetBoundary: ({ children }: QueryErrorResetBoundaryProps) => import("preact").JSX.Element;
125
125
  //#endregion
126
- export { QueryErrorClearResetFunction, QueryErrorIsResetFunction, QueryErrorResetBoundary, QueryErrorResetBoundaryFunction, QueryErrorResetBoundaryProps, QueryErrorResetBoundaryValue, QueryErrorResetFunction, useQueryErrorResetBoundary };
127
126
  //# sourceMappingURL=QueryErrorResetBoundary.d.cts.map
package/build/modern/QueryErrorResetBoundary.d.cts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"QueryErrorResetBoundary.d.cts","names":[],"sources":["../../src/QueryErrorResetBoundary.tsx"],"mappings":";;;;;KASY;;;;KAKA;;;;KAKA;UAEK;;;;EAIf,YAAY;;;;EAIZ,SAAS;;;;EAIT,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmDI,kCAA0B;;;;;;;KAW3B,mCACV,OAAO,iCACJ;;;;UAKY;;;;;EAKf,UAAU,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmDjC,4BAA2B,YAErC,kDAA4B,IAAA"}
1
+ {"version":3,"file":"QueryErrorResetBoundary.d.cts","names":[],"sources":["../../src/QueryErrorResetBoundary.tsx"],"mappings":";;;;;YASY;;;;YAKA;;;;YAKA;iBAEK;;;;EAIf,YAAY;;;;EAIZ,SAAS;;;;EAIT,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmDI,kCAA0B;;;;;;;YAW3B,mCACV,OAAO,iCACJ;;;;iBAKY;;;;;EAKf,UAAU,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmDjC,4BAA2B,YAErC,kDAA4B,IAAA"}
package/build/modern/QueryErrorResetBoundary.d.ts CHANGED
@@ -3,16 +3,16 @@ import { ComponentChildren } from "preact";
3
3
  /**
4
4
  * Resets any query errors within the boundary, so queries know they can try again.
5
5
  */
6
- type QueryErrorResetFunction = () => void;
6
+ export type QueryErrorResetFunction = () => void;
7
7
  /**
8
8
  * Returns whether the boundary has been reset and not yet cleared.
9
9
  */
10
- type QueryErrorIsResetFunction = () => boolean;
10
+ export type QueryErrorIsResetFunction = () => boolean;
11
11
  /**
12
12
  * Clears the reset state, so queries know not to try again until the boundary is reset again.
13
13
  */
14
- type QueryErrorClearResetFunction = () => void;
15
- interface QueryErrorResetBoundaryValue {
14
+ export type QueryErrorClearResetFunction = () => void;
15
+ export interface QueryErrorResetBoundaryValue {
16
16
  /**
17
17
  * Clears the reset state, so queries know not to try again until the boundary is reset again.
18
18
  */
@@ -55,18 +55,18 @@ interface QueryErrorResetBoundaryValue {
55
55
  * }
56
56
  * ```
57
57
  */
58
- declare const useQueryErrorResetBoundary: () => QueryErrorResetBoundaryValue;
58
+ export declare const useQueryErrorResetBoundary: () => QueryErrorResetBoundaryValue;
59
59
  /**
60
60
  * A render-prop function usable as `children` on `QueryErrorResetBoundary`.
61
61
  *
62
62
  * @param value - The boundary's {@link QueryErrorResetBoundaryValue}.
63
63
  * @returns The children to render.
64
64
  */
65
- type QueryErrorResetBoundaryFunction = (value: QueryErrorResetBoundaryValue) => ComponentChildren;
65
+ export type QueryErrorResetBoundaryFunction = (value: QueryErrorResetBoundaryValue) => ComponentChildren;
66
66
  /**
67
67
  * The props accepted by `QueryErrorResetBoundary`.
68
68
  */
69
- interface QueryErrorResetBoundaryProps {
69
+ export interface QueryErrorResetBoundaryProps {
70
70
  /**
71
71
  * Either a plain node, or a function that receives the boundary's {@link QueryErrorResetBoundaryValue} and
72
72
  * returns a node.
@@ -121,7 +121,6 @@ interface QueryErrorResetBoundaryProps {
121
121
  * }
122
122
  * ```
123
123
  */
124
- declare const QueryErrorResetBoundary: ({ children }: QueryErrorResetBoundaryProps) => import("preact").JSX.Element;
124
+ export declare const QueryErrorResetBoundary: ({ children }: QueryErrorResetBoundaryProps) => import("preact").JSX.Element;
125
125
  //#endregion
126
- export { QueryErrorClearResetFunction, QueryErrorIsResetFunction, QueryErrorResetBoundary, QueryErrorResetBoundaryFunction, QueryErrorResetBoundaryProps, QueryErrorResetBoundaryValue, QueryErrorResetFunction, useQueryErrorResetBoundary };
127
126
  //# sourceMappingURL=QueryErrorResetBoundary.d.ts.map
package/build/modern/QueryErrorResetBoundary.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"QueryErrorResetBoundary.d.ts","names":[],"sources":["../../src/QueryErrorResetBoundary.tsx"],"mappings":";;;;;KASY;;;;KAKA;;;;KAKA;UAEK;;;;EAIf,YAAY;;;;EAIZ,SAAS;;;;EAIT,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmDI,kCAA0B;;;;;;;KAW3B,mCACV,OAAO,iCACJ;;;;UAKY;;;;;EAKf,UAAU,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmDjC,4BAA2B,YAErC,kDAA4B,IAAA"}
1
+ {"version":3,"file":"QueryErrorResetBoundary.d.ts","names":[],"sources":["../../src/QueryErrorResetBoundary.tsx"],"mappings":";;;;;YASY;;;;YAKA;;;;YAKA;iBAEK;;;;EAIf,YAAY;;;;EAIZ,SAAS;;;;EAIT,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmDI,kCAA0B;;;;;;;YAW3B,mCACV,OAAO,iCACJ;;;;iBAKY;;;;;EAKf,UAAU,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmDjC,4BAA2B,YAErC,kDAA4B,IAAA"}
package/build/modern/errorBoundaryUtils.d.cts CHANGED
@@ -1,9 +1,9 @@
1
1
  import { QueryErrorResetBoundaryValue } from "./QueryErrorResetBoundary.cjs";
2
2
  import { DefaultedQueryObserverOptions, Query, QueryKey, QueryObserverResult, ThrowOnError } from "@tanstack/query-core";
3
3
  //#region src/errorBoundaryUtils.d.ts
4
- declare const ensurePreventErrorBoundaryRetry: <TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, errorResetBoundary: QueryErrorResetBoundaryValue, query: Query<TQueryFnData, TError, TQueryData, TQueryKey> | undefined) => void;
5
- declare const useClearResetErrorBoundary: (errorResetBoundary: QueryErrorResetBoundaryValue) => void;
6
- declare const getHasError: <TData, TError, TQueryFnData, TQueryData, TQueryKey extends QueryKey>({ result, errorResetBoundary, throwOnError, query, suspense }: {
4
+ export declare const ensurePreventErrorBoundaryRetry: <TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, errorResetBoundary: QueryErrorResetBoundaryValue, query: Query<TQueryFnData, TError, TQueryData, TQueryKey> | undefined) => void;
5
+ export declare const useClearResetErrorBoundary: (errorResetBoundary: QueryErrorResetBoundaryValue) => void;
6
+ export declare const getHasError: <TData, TError, TQueryFnData, TQueryData, TQueryKey extends QueryKey>({ result, errorResetBoundary, throwOnError, query, suspense }: {
7
7
  result: QueryObserverResult<TData, TError>;
8
8
  errorResetBoundary: QueryErrorResetBoundaryValue;
9
9
  throwOnError: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>;
@@ -11,5 +11,4 @@ declare const getHasError: <TData, TError, TQueryFnData, TQueryData, TQueryKey e
11
11
  suspense: boolean | undefined;
12
12
  }) => boolean | undefined;
13
13
  //#endregion
14
- export { ensurePreventErrorBoundaryRetry, getHasError, useClearResetErrorBoundary };
15
14
  //# sourceMappingURL=errorBoundaryUtils.d.cts.map
package/build/modern/errorBoundaryUtils.d.cts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"errorBoundaryUtils.d.cts","names":[],"sources":["../../src/errorBoundaryUtils.ts"],"mappings":";;;cAYa,kCACX,cACA,QACA,OACA,YACA,kBAAkB,UAElB,SAAS,8BACP,cACA,QACA,OACA,YACA,YAEF,oBAAoB,8BACpB,OAAO,MAAM,cAAc,QAAQ,YAAY;cAepC,6BACX,oBAAoB;cAOT,cACX,OACA,QACA,cACA,YACA,kBAAkB,YAClB,QAAA,oBAAA,cAAA,OAAA;EAOA,QAAQ,oBAAoB,OAAO;EACnC,oBAAoB;EACpB,cAAc,aAAa,cAAc,QAAQ,YAAY;EAC7D,OAAO,MAAM,cAAc,QAAQ,YAAY;EAC/C"}
1
+ {"version":3,"file":"errorBoundaryUtils.d.cts","names":[],"sources":["../../src/errorBoundaryUtils.ts"],"mappings":";;;qBAYa,kCACX,cACA,QACA,OACA,YACA,kBAAkB,UAElB,SAAS,8BACP,cACA,QACA,OACA,YACA,YAEF,oBAAoB,8BACpB,OAAO,MAAM,cAAc,QAAQ,YAAY;qBAepC,6BACX,oBAAoB;qBAOT,cACX,OACA,QACA,cACA,YACA,kBAAkB,YAClB,QAAA,oBAAA,cAAA,OAAA;EAOA,QAAQ,oBAAoB,OAAO;EACnC,oBAAoB;EACpB,cAAc,aAAa,cAAc,QAAQ,YAAY;EAC7D,OAAO,MAAM,cAAc,QAAQ,YAAY;EAC/C"}
package/build/modern/errorBoundaryUtils.d.ts CHANGED
@@ -1,9 +1,9 @@
1
1
  import { QueryErrorResetBoundaryValue } from "./QueryErrorResetBoundary.js";
2
2
  import { DefaultedQueryObserverOptions, Query, QueryKey, QueryObserverResult, ThrowOnError } from "@tanstack/query-core";
3
3
  //#region src/errorBoundaryUtils.d.ts
4
- declare const ensurePreventErrorBoundaryRetry: <TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, errorResetBoundary: QueryErrorResetBoundaryValue, query: Query<TQueryFnData, TError, TQueryData, TQueryKey> | undefined) => void;
5
- declare const useClearResetErrorBoundary: (errorResetBoundary: QueryErrorResetBoundaryValue) => void;
6
- declare const getHasError: <TData, TError, TQueryFnData, TQueryData, TQueryKey extends QueryKey>({ result, errorResetBoundary, throwOnError, query, suspense }: {
4
+ export declare const ensurePreventErrorBoundaryRetry: <TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, errorResetBoundary: QueryErrorResetBoundaryValue, query: Query<TQueryFnData, TError, TQueryData, TQueryKey> | undefined) => void;
5
+ export declare const useClearResetErrorBoundary: (errorResetBoundary: QueryErrorResetBoundaryValue) => void;
6
+ export declare const getHasError: <TData, TError, TQueryFnData, TQueryData, TQueryKey extends QueryKey>({ result, errorResetBoundary, throwOnError, query, suspense }: {
7
7
  result: QueryObserverResult<TData, TError>;
8
8
  errorResetBoundary: QueryErrorResetBoundaryValue;
9
9
  throwOnError: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>;
@@ -11,5 +11,4 @@ declare const getHasError: <TData, TError, TQueryFnData, TQueryData, TQueryKey e
11
11
  suspense: boolean | undefined;
12
12
  }) => boolean | undefined;
13
13
  //#endregion
14
- export { ensurePreventErrorBoundaryRetry, getHasError, useClearResetErrorBoundary };
15
14
  //# sourceMappingURL=errorBoundaryUtils.d.ts.map
package/build/modern/errorBoundaryUtils.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"errorBoundaryUtils.d.ts","names":[],"sources":["../../src/errorBoundaryUtils.ts"],"mappings":";;;cAYa,kCACX,cACA,QACA,OACA,YACA,kBAAkB,UAElB,SAAS,8BACP,cACA,QACA,OACA,YACA,YAEF,oBAAoB,8BACpB,OAAO,MAAM,cAAc,QAAQ,YAAY;cAepC,6BACX,oBAAoB;cAOT,cACX,OACA,QACA,cACA,YACA,kBAAkB,YAClB,QAAA,oBAAA,cAAA,OAAA;EAOA,QAAQ,oBAAoB,OAAO;EACnC,oBAAoB;EACpB,cAAc,aAAa,cAAc,QAAQ,YAAY;EAC7D,OAAO,MAAM,cAAc,QAAQ,YAAY;EAC/C"}
1
+ {"version":3,"file":"errorBoundaryUtils.d.ts","names":[],"sources":["../../src/errorBoundaryUtils.ts"],"mappings":";;;qBAYa,kCACX,cACA,QACA,OACA,YACA,kBAAkB,UAElB,SAAS,8BACP,cACA,QACA,OACA,YACA,YAEF,oBAAoB,8BACpB,OAAO,MAAM,cAAc,QAAQ,YAAY;qBAepC,6BACX,oBAAoB;qBAOT,cACX,OACA,QACA,cACA,YACA,kBAAkB,YAClB,QAAA,oBAAA,cAAA,OAAA;EAOA,QAAQ,oBAAoB,OAAO;EACnC,oBAAoB;EACpB,cAAc,aAAa,cAAc,QAAQ,YAAY;EAC7D,OAAO,MAAM,cAAc,QAAQ,YAAY;EAC/C"}