@tanstack/vue-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 (234) hide show
  1. package/build/legacy/devtools/devtools.d.cts +2 -3
  2. package/build/legacy/devtools/devtools.d.cts.map +1 -1
  3. package/build/legacy/devtools/devtools.d.ts +2 -3
  4. package/build/legacy/devtools/devtools.d.ts.map +1 -1
  5. package/build/legacy/devtools/utils.d.cts +5 -6
  6. package/build/legacy/devtools/utils.d.cts.map +1 -1
  7. package/build/legacy/devtools/utils.d.ts +5 -6
  8. package/build/legacy/devtools/utils.d.ts.map +1 -1
  9. package/build/legacy/index.d.cts +3 -3
  10. package/build/legacy/index.d.ts +3 -3
  11. package/build/legacy/{infiniteQueryOptions-qN6sOJM-.d.cts → infiniteQueryOptions-CnTRbIP5.d.cts} +16 -6
  12. package/build/legacy/infiniteQueryOptions-CnTRbIP5.d.cts.map +1 -0
  13. package/build/legacy/{infiniteQueryOptions-CEDiLwh5.d.ts → infiniteQueryOptions-NucMX_M_.d.ts} +16 -6
  14. package/build/legacy/infiniteQueryOptions-NucMX_M_.d.ts.map +1 -0
  15. package/build/legacy/infiniteQueryOptions.cjs.map +1 -1
  16. package/build/legacy/infiniteQueryOptions.d.cts +1 -1
  17. package/build/legacy/infiniteQueryOptions.d.ts +1 -1
  18. package/build/legacy/infiniteQueryOptions.js.map +1 -1
  19. package/build/legacy/mutationCache.d.cts +1 -2
  20. package/build/legacy/mutationCache.d.cts.map +1 -1
  21. package/build/legacy/mutationCache.d.ts +1 -2
  22. package/build/legacy/mutationCache.d.ts.map +1 -1
  23. package/build/legacy/mutationOptions.cjs.map +1 -1
  24. package/build/legacy/mutationOptions.d.cts +8 -5
  25. package/build/legacy/mutationOptions.d.cts.map +1 -1
  26. package/build/legacy/mutationOptions.d.ts +8 -5
  27. package/build/legacy/mutationOptions.d.ts.map +1 -1
  28. package/build/legacy/mutationOptions.js.map +1 -1
  29. package/build/legacy/queryCache.d.cts +1 -2
  30. package/build/legacy/queryCache.d.cts.map +1 -1
  31. package/build/legacy/queryCache.d.ts +1 -2
  32. package/build/legacy/queryCache.d.ts.map +1 -1
  33. package/build/legacy/{queryClient-Cv73nzNT.d.ts → queryClient-B6mLtXOj.d.ts} +9 -2
  34. package/build/legacy/queryClient-B6mLtXOj.d.ts.map +1 -0
  35. package/build/{modern/queryClient-CZeNAt68.d.cts → legacy/queryClient-Bn2Ql_Lu.d.cts} +9 -2
  36. package/build/legacy/queryClient-Bn2Ql_Lu.d.cts.map +1 -0
  37. package/build/legacy/queryClient.cjs +7 -0
  38. package/build/legacy/queryClient.cjs.map +1 -1
  39. package/build/legacy/queryClient.d.cts +1 -1
  40. package/build/legacy/queryClient.d.ts +1 -1
  41. package/build/legacy/queryClient.js +7 -0
  42. package/build/legacy/queryClient.js.map +1 -1
  43. package/build/{modern/queryOptions-DPDwdVBu.d.ts → legacy/queryOptions-CsM5TXD2.d.ts} +4 -3
  44. package/build/legacy/queryOptions-CsM5TXD2.d.ts.map +1 -0
  45. package/build/{modern/queryOptions-rkZ3sk6g.d.cts → legacy/queryOptions-CwqQgQmQ.d.cts} +4 -3
  46. package/build/legacy/queryOptions-CwqQgQmQ.d.cts.map +1 -0
  47. package/build/legacy/queryOptions.cjs.map +1 -1
  48. package/build/legacy/queryOptions.d.cts +1 -1
  49. package/build/legacy/queryOptions.d.ts +1 -1
  50. package/build/legacy/queryOptions.js.map +1 -1
  51. package/build/legacy/types-JpJB72CS.d.cts.map +1 -1
  52. package/build/legacy/types-JpJB72CS.d.ts.map +1 -1
  53. package/build/legacy/useBaseQuery.cjs.map +1 -1
  54. package/build/legacy/useBaseQuery.d.cts +1 -1
  55. package/build/legacy/useBaseQuery.d.ts +1 -1
  56. package/build/legacy/useBaseQuery.js.map +1 -1
  57. package/build/legacy/useInfiniteQuery.cjs.map +1 -1
  58. package/build/legacy/useInfiniteQuery.d.cts +1 -1
  59. package/build/legacy/useInfiniteQuery.d.ts +1 -1
  60. package/build/legacy/useInfiniteQuery.js.map +1 -1
  61. package/build/legacy/useIsFetching.cjs.map +1 -1
  62. package/build/legacy/useIsFetching.d.cts +3 -4
  63. package/build/legacy/useIsFetching.d.cts.map +1 -1
  64. package/build/legacy/useIsFetching.d.ts +3 -4
  65. package/build/legacy/useIsFetching.d.ts.map +1 -1
  66. package/build/legacy/useIsFetching.js.map +1 -1
  67. package/build/legacy/useMutation.d.cts +4 -5
  68. package/build/legacy/useMutation.d.cts.map +1 -1
  69. package/build/legacy/useMutation.d.ts +4 -5
  70. package/build/legacy/useMutation.d.ts.map +1 -1
  71. package/build/legacy/useMutationState.cjs.map +1 -1
  72. package/build/legacy/useMutationState.d.cts +5 -6
  73. package/build/legacy/useMutationState.d.cts.map +1 -1
  74. package/build/legacy/useMutationState.d.ts +5 -6
  75. package/build/legacy/useMutationState.d.ts.map +1 -1
  76. package/build/legacy/useMutationState.js.map +1 -1
  77. package/build/legacy/usePrefetchInfiniteQuery.d.cts +3 -4
  78. package/build/legacy/usePrefetchInfiniteQuery.d.cts.map +1 -1
  79. package/build/legacy/usePrefetchInfiniteQuery.d.ts +3 -4
  80. package/build/legacy/usePrefetchInfiniteQuery.d.ts.map +1 -1
  81. package/build/legacy/usePrefetchQuery.d.cts +3 -4
  82. package/build/legacy/usePrefetchQuery.d.cts.map +1 -1
  83. package/build/legacy/usePrefetchQuery.d.ts +3 -4
  84. package/build/legacy/usePrefetchQuery.d.ts.map +1 -1
  85. package/build/legacy/useQueries.d.cts +5 -6
  86. package/build/legacy/useQueries.d.cts.map +1 -1
  87. package/build/legacy/useQueries.d.ts +5 -6
  88. package/build/legacy/useQueries.d.ts.map +1 -1
  89. package/build/legacy/useQuery.cjs.map +1 -1
  90. package/build/legacy/useQuery.d.cts +18 -13
  91. package/build/legacy/useQuery.d.cts.map +1 -1
  92. package/build/legacy/useQuery.d.ts +18 -13
  93. package/build/legacy/useQuery.d.ts.map +1 -1
  94. package/build/legacy/useQuery.js.map +1 -1
  95. package/build/legacy/useQueryClient.d.cts +2 -3
  96. package/build/legacy/useQueryClient.d.cts.map +1 -1
  97. package/build/legacy/useQueryClient.d.ts +2 -3
  98. package/build/legacy/useQueryClient.d.ts.map +1 -1
  99. package/build/legacy/utils.d.cts +6 -7
  100. package/build/legacy/utils.d.cts.map +1 -1
  101. package/build/legacy/utils.d.ts +6 -7
  102. package/build/legacy/utils.d.ts.map +1 -1
  103. package/build/legacy/vueQueryPlugin.d.cts +3 -4
  104. package/build/legacy/vueQueryPlugin.d.cts.map +1 -1
  105. package/build/legacy/vueQueryPlugin.d.ts +3 -4
  106. package/build/legacy/vueQueryPlugin.d.ts.map +1 -1
  107. package/build/modern/devtools/devtools.d.cts +2 -3
  108. package/build/modern/devtools/devtools.d.cts.map +1 -1
  109. package/build/modern/devtools/devtools.d.ts +2 -3
  110. package/build/modern/devtools/devtools.d.ts.map +1 -1
  111. package/build/modern/devtools/utils.d.cts +5 -6
  112. package/build/modern/devtools/utils.d.cts.map +1 -1
  113. package/build/modern/devtools/utils.d.ts +5 -6
  114. package/build/modern/devtools/utils.d.ts.map +1 -1
  115. package/build/modern/index.d.cts +3 -3
  116. package/build/modern/index.d.ts +3 -3
  117. package/build/modern/{infiniteQueryOptions-qN6sOJM-.d.cts → infiniteQueryOptions-CnTRbIP5.d.cts} +16 -6
  118. package/build/modern/infiniteQueryOptions-CnTRbIP5.d.cts.map +1 -0
  119. package/build/modern/{infiniteQueryOptions-CEDiLwh5.d.ts → infiniteQueryOptions-NucMX_M_.d.ts} +16 -6
  120. package/build/modern/infiniteQueryOptions-NucMX_M_.d.ts.map +1 -0
  121. package/build/modern/infiniteQueryOptions.cjs.map +1 -1
  122. package/build/modern/infiniteQueryOptions.d.cts +1 -1
  123. package/build/modern/infiniteQueryOptions.d.ts +1 -1
  124. package/build/modern/infiniteQueryOptions.js.map +1 -1
  125. package/build/modern/mutationCache.d.cts +1 -2
  126. package/build/modern/mutationCache.d.cts.map +1 -1
  127. package/build/modern/mutationCache.d.ts +1 -2
  128. package/build/modern/mutationCache.d.ts.map +1 -1
  129. package/build/modern/mutationOptions.cjs.map +1 -1
  130. package/build/modern/mutationOptions.d.cts +8 -5
  131. package/build/modern/mutationOptions.d.cts.map +1 -1
  132. package/build/modern/mutationOptions.d.ts +8 -5
  133. package/build/modern/mutationOptions.d.ts.map +1 -1
  134. package/build/modern/mutationOptions.js.map +1 -1
  135. package/build/modern/queryCache.d.cts +1 -2
  136. package/build/modern/queryCache.d.cts.map +1 -1
  137. package/build/modern/queryCache.d.ts +1 -2
  138. package/build/modern/queryCache.d.ts.map +1 -1
  139. package/build/modern/{queryClient-Cv73nzNT.d.ts → queryClient-B6mLtXOj.d.ts} +9 -2
  140. package/build/modern/queryClient-B6mLtXOj.d.ts.map +1 -0
  141. package/build/{legacy/queryClient-CZeNAt68.d.cts → modern/queryClient-Bn2Ql_Lu.d.cts} +9 -2
  142. package/build/modern/queryClient-Bn2Ql_Lu.d.cts.map +1 -0
  143. package/build/modern/queryClient.cjs +7 -0
  144. package/build/modern/queryClient.cjs.map +1 -1
  145. package/build/modern/queryClient.d.cts +1 -1
  146. package/build/modern/queryClient.d.ts +1 -1
  147. package/build/modern/queryClient.js +7 -0
  148. package/build/modern/queryClient.js.map +1 -1
  149. package/build/{legacy/queryOptions-DPDwdVBu.d.ts → modern/queryOptions-CsM5TXD2.d.ts} +4 -3
  150. package/build/modern/queryOptions-CsM5TXD2.d.ts.map +1 -0
  151. package/build/{legacy/queryOptions-rkZ3sk6g.d.cts → modern/queryOptions-CwqQgQmQ.d.cts} +4 -3
  152. package/build/modern/queryOptions-CwqQgQmQ.d.cts.map +1 -0
  153. package/build/modern/queryOptions.cjs.map +1 -1
  154. package/build/modern/queryOptions.d.cts +1 -1
  155. package/build/modern/queryOptions.d.ts +1 -1
  156. package/build/modern/queryOptions.js.map +1 -1
  157. package/build/modern/types-JpJB72CS.d.cts.map +1 -1
  158. package/build/modern/types-JpJB72CS.d.ts.map +1 -1
  159. package/build/modern/useBaseQuery.cjs.map +1 -1
  160. package/build/modern/useBaseQuery.d.cts +1 -1
  161. package/build/modern/useBaseQuery.d.ts +1 -1
  162. package/build/modern/useBaseQuery.js.map +1 -1
  163. package/build/modern/useInfiniteQuery.cjs.map +1 -1
  164. package/build/modern/useInfiniteQuery.d.cts +1 -1
  165. package/build/modern/useInfiniteQuery.d.ts +1 -1
  166. package/build/modern/useInfiniteQuery.js.map +1 -1
  167. package/build/modern/useIsFetching.cjs.map +1 -1
  168. package/build/modern/useIsFetching.d.cts +3 -4
  169. package/build/modern/useIsFetching.d.cts.map +1 -1
  170. package/build/modern/useIsFetching.d.ts +3 -4
  171. package/build/modern/useIsFetching.d.ts.map +1 -1
  172. package/build/modern/useIsFetching.js.map +1 -1
  173. package/build/modern/useMutation.d.cts +4 -5
  174. package/build/modern/useMutation.d.cts.map +1 -1
  175. package/build/modern/useMutation.d.ts +4 -5
  176. package/build/modern/useMutation.d.ts.map +1 -1
  177. package/build/modern/useMutationState.cjs.map +1 -1
  178. package/build/modern/useMutationState.d.cts +5 -6
  179. package/build/modern/useMutationState.d.cts.map +1 -1
  180. package/build/modern/useMutationState.d.ts +5 -6
  181. package/build/modern/useMutationState.d.ts.map +1 -1
  182. package/build/modern/useMutationState.js.map +1 -1
  183. package/build/modern/usePrefetchInfiniteQuery.d.cts +3 -4
  184. package/build/modern/usePrefetchInfiniteQuery.d.cts.map +1 -1
  185. package/build/modern/usePrefetchInfiniteQuery.d.ts +3 -4
  186. package/build/modern/usePrefetchInfiniteQuery.d.ts.map +1 -1
  187. package/build/modern/usePrefetchQuery.d.cts +3 -4
  188. package/build/modern/usePrefetchQuery.d.cts.map +1 -1
  189. package/build/modern/usePrefetchQuery.d.ts +3 -4
  190. package/build/modern/usePrefetchQuery.d.ts.map +1 -1
  191. package/build/modern/useQueries.d.cts +5 -6
  192. package/build/modern/useQueries.d.cts.map +1 -1
  193. package/build/modern/useQueries.d.ts +5 -6
  194. package/build/modern/useQueries.d.ts.map +1 -1
  195. package/build/modern/useQuery.cjs.map +1 -1
  196. package/build/modern/useQuery.d.cts +18 -13
  197. package/build/modern/useQuery.d.cts.map +1 -1
  198. package/build/modern/useQuery.d.ts +18 -13
  199. package/build/modern/useQuery.d.ts.map +1 -1
  200. package/build/modern/useQuery.js.map +1 -1
  201. package/build/modern/useQueryClient.d.cts +2 -3
  202. package/build/modern/useQueryClient.d.cts.map +1 -1
  203. package/build/modern/useQueryClient.d.ts +2 -3
  204. package/build/modern/useQueryClient.d.ts.map +1 -1
  205. package/build/modern/utils.d.cts +6 -7
  206. package/build/modern/utils.d.cts.map +1 -1
  207. package/build/modern/utils.d.ts +6 -7
  208. package/build/modern/utils.d.ts.map +1 -1
  209. package/build/modern/vueQueryPlugin.d.cts +3 -4
  210. package/build/modern/vueQueryPlugin.d.cts.map +1 -1
  211. package/build/modern/vueQueryPlugin.d.ts +3 -4
  212. package/build/modern/vueQueryPlugin.d.ts.map +1 -1
  213. package/package.json +9 -9
  214. package/src/infiniteQueryOptions.ts +3 -2
  215. package/src/mutationOptions.ts +4 -0
  216. package/src/queryClient.ts +7 -0
  217. package/src/queryOptions.ts +29 -26
  218. package/src/useBaseQuery.ts +9 -3
  219. package/src/useInfiniteQuery.ts +11 -8
  220. package/src/useIsFetching.ts +1 -2
  221. package/src/useMutationState.ts +1 -2
  222. package/src/useQuery.ts +11 -6
  223. package/build/legacy/infiniteQueryOptions-CEDiLwh5.d.ts.map +0 -1
  224. package/build/legacy/infiniteQueryOptions-qN6sOJM-.d.cts.map +0 -1
  225. package/build/legacy/queryClient-CZeNAt68.d.cts.map +0 -1
  226. package/build/legacy/queryClient-Cv73nzNT.d.ts.map +0 -1
  227. package/build/legacy/queryOptions-DPDwdVBu.d.ts.map +0 -1
  228. package/build/legacy/queryOptions-rkZ3sk6g.d.cts.map +0 -1
  229. package/build/modern/infiniteQueryOptions-CEDiLwh5.d.ts.map +0 -1
  230. package/build/modern/infiniteQueryOptions-qN6sOJM-.d.cts.map +0 -1
  231. package/build/modern/queryClient-CZeNAt68.d.cts.map +0 -1
  232. package/build/modern/queryClient-Cv73nzNT.d.ts.map +0 -1
  233. package/build/modern/queryOptions-DPDwdVBu.d.ts.map +0 -1
  234. package/build/modern/queryOptions-rkZ3sk6g.d.cts.map +0 -1
@@ -1,13 +1,14 @@
1
1
  import { s as MaybeRefOrGetter } from "./types-JpJB72CS.js";
2
- import { i as UndefinedInitialQueryOptions, o as UseQueryOptions, t as DefinedInitialQueryOptions } from "./queryOptions-DPDwdVBu.js";
3
- import { t as QueryClient$1 } from "./queryClient-Cv73nzNT.js";
4
- import { s as UseBaseQueryReturnType } from "./infiniteQueryOptions-CEDiLwh5.js";
2
+ import { i as UndefinedInitialQueryOptions, o as UseQueryOptions, t as DefinedInitialQueryOptions } from "./queryOptions-CsM5TXD2.js";
3
+ import { t as QueryClient$1 } from "./queryClient-B6mLtXOj.js";
4
+ import { s as UseBaseQueryReturnType } from "./infiniteQueryOptions-NucMX_M_.js";
5
5
  import { DefaultError, DefinedQueryObserverResult, QueryKey } from "@tanstack/query-core";
6
6
  //#region src/useQuery.d.ts
7
- type UseQueryReturnType<TData, TError> = UseBaseQueryReturnType<TData, TError>;
8
- type UseQueryDefinedReturnType<TData, TError> = UseBaseQueryReturnType<TData, TError, DefinedQueryObserverResult<TData, TError>>;
7
+ export type UseQueryReturnType<TData, TError> = UseBaseQueryReturnType<TData, TError>;
8
+ export type UseQueryDefinedReturnType<TData, TError> = UseBaseQueryReturnType<TData, TError, DefinedQueryObserverResult<TData, TError>>;
9
9
  /**
10
- * This overload is selected when `initialData` is set, so the resulting `data` is never `undefined`.
10
+ * This overload is selected when `initialData` is set, so the resulting `data` is never `undefined` (unless
11
+ * a `select` changes `TData` to include `undefined`).
11
12
  *
12
13
  * `enabled` tracks reactive dependencies automatically as a `ref`, a plain value, or a reactive getter
13
14
  * (`() => ...`). `queryKey` reacts through a `ref` or a reactive getter for the array itself, or `ref`s and
@@ -18,8 +19,9 @@ type UseQueryDefinedReturnType<TData, TError> = UseBaseQueryReturnType<TData, TE
18
19
  * `initialData` set.
19
20
  * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one provided by `VueQueryPlugin`
20
21
  * will be used.
21
- * @returns The current query result, typed so that `data` is never `undefined` (`status` never resolves to
22
- * `pending` in this overload's type, since `initialData` guarantees data upfront).
22
+ * @returns The current query result, typed so that `data` is never `undefined` (unless a `select` changes
23
+ * `TData` to include `undefined`). `status` never resolves to `pending` in this overload's type, since
24
+ * `initialData` guarantees data upfront.
23
25
  *
24
26
  * @example
25
27
  * ```vue
@@ -43,7 +45,7 @@ type UseQueryDefinedReturnType<TData, TError> = UseBaseQueryReturnType<TData, TE
43
45
  * </template>
44
46
  * ```
45
47
  */
46
- declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient$1): UseQueryDefinedReturnType<TData, TError>;
48
+ export declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient$1): UseQueryDefinedReturnType<TData, TError>;
47
49
  /**
48
50
  * `enabled` tracks reactive dependencies automatically as a `ref`, a plain value, or a reactive getter
49
51
  * (`() => ...`). `queryKey` reacts through a `ref` or a reactive getter for the array itself, or `ref`s and
@@ -124,7 +126,9 @@ declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData =
124
126
  * ```
125
127
  *
126
128
  * @example
127
- * Seeding a detail query from an already-cached list, to skip the loading state:
129
+ * Seeding a detail query from an already-cached list, to skip the loading state. `initialDataUpdatedAt` carries
130
+ * over the list's own fetch time, so that if you set a `staleTime`, it's measured from when the list was
131
+ * fetched rather than from now:
128
132
  * ```vue
129
133
  * <script setup lang="ts">
130
134
  * import { useQuery, useQueryClient } from '@tanstack/vue-query'
@@ -139,6 +143,8 @@ declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData =
139
143
  * queryClient
140
144
  * .getQueryData<Array<Post>>(['posts'])
141
145
  * ?.find((post) => post.id === props.postId),
146
+ * initialDataUpdatedAt: () =>
147
+ * queryClient.getQueryState(['posts'])?.dataUpdatedAt,
142
148
  * })
143
149
  * </script>
144
150
  *
@@ -175,7 +181,7 @@ declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData =
175
181
  * </template>
176
182
  * ```
177
183
  */
178
- declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient$1): UseQueryReturnType<TData, TError>;
184
+ export declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient$1): UseQueryReturnType<TData, TError>;
179
185
  /**
180
186
  * Fallback overload for options whose `initialData` presence isn't statically known — for example, a
181
187
  * `ref`/reactive object built up conditionally, rather than a plain object literal. Prefer one of the other
@@ -242,7 +248,6 @@ declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData =
242
248
  * </template>
243
249
  * ```
244
250
  */
245
- declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: MaybeRefOrGetter<UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>>, queryClient?: QueryClient$1): UseQueryReturnType<TData, TError>;
251
+ export declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: MaybeRefOrGetter<UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>>, queryClient?: QueryClient$1): UseQueryReturnType<TData, TError>;
246
252
  //#endregion
247
- export { UseQueryDefinedReturnType, UseQueryReturnType, useQuery };
248
253
  //# sourceMappingURL=useQuery.d.ts.map
@@ -1 +1 @@
1
- {"version":3,"file":"useQuery.d.ts","names":[],"sources":["../../src/useQuery.ts"],"mappings":";;;;;;KAgBY,mBAAmB,OAAO,UAAU,uBAC9C,OACA;KAGU,0BAA0B,OAAO,UAAU,uBACrD,OACA,QACA,2BAA2B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwCpB,SACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,2BAA2B,cAAc,QAAQ,OAAO,YACjE,cAAc,gBACb,0BAA0B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqIpB,SACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,6BAA6B,cAAc,QAAQ,OAAO,YACnE,cAAc,gBACb,mBAAmB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoEb,SACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,iBACP,gBAAgB,cAAc,QAAQ,OAAO,cAAc,aAE7D,cAAc,gBACb,mBAAmB,OAAO"}
1
+ {"version":3,"file":"useQuery.d.ts","names":["QueryClient"],"sources":["../../src/useQuery.ts"],"mappings":";;;;;;YAgBY,mBAAmB,OAAO,UAAU,uBAC9C,OACA;YAGU,0BAA0B,OAAO,UAAU,uBACrD,OACA,QACA,2BAA2B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA0CpB,SACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,2BAA2B,cAAc,QAAQ,OAAO,YACjE,cAAcA,gBACb,0BAA0B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAyIpB,SACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,6BAA6B,cAAc,QAAQ,OAAO,YACnE,cAAcA,gBACb,mBAAmB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAoEb,SACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,iBACP,gBAAgB,cAAc,QAAQ,OAAO,cAAc,aAE7D,cAAcA,gBACb,mBAAmB,OAAO"}
@@ -1 +1 @@
1
- {"version":3,"file":"useQuery.js","names":[],"sources":["../../src/useQuery.ts"],"sourcesContent":["import { QueryObserver } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport type {\n DefaultError,\n DefinedQueryObserverResult,\n QueryKey,\n} from '@tanstack/query-core'\nimport type { UseBaseQueryReturnType } from './useBaseQuery'\nimport type { MaybeRefOrGetter } from './types'\nimport type { QueryClient } from './queryClient'\nimport type {\n DefinedInitialQueryOptions,\n UndefinedInitialQueryOptions,\n UseQueryOptions,\n} from './queryOptions'\n\nexport type UseQueryReturnType<TData, TError> = UseBaseQueryReturnType<\n TData,\n TError\n>\n\nexport type UseQueryDefinedReturnType<TData, TError> = UseBaseQueryReturnType<\n TData,\n TError,\n DefinedQueryObserverResult<TData, TError>\n>\n\n/**\n * This overload is selected when `initialData` is set, so the resulting `data` is never `undefined`.\n *\n * `enabled` tracks reactive dependencies automatically as a `ref`, a plain value, or a reactive getter\n * (`() => ...`). `queryKey` reacts through a `ref` or a reactive getter for the array itself, or `ref`s and\n * reactive getters as individual entries. Other options are read once when passed as a plain value, and stay\n * reactive when passed as a `ref` or a `computed`.\n *\n * @param options - The {@link DefinedInitialQueryOptions} to use — everything you can pass to `useQuery`, with\n * `initialData` set.\n * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one provided by `VueQueryPlugin`\n * will be used.\n * @returns The current query result, typed so that `data` is never `undefined` (`status` never resolves to\n * `pending` in this overload's type, since `initialData` guarantees data upfront).\n *\n * @example\n * ```vue\n * <script setup lang=\"ts\">\n * import { useQuery } from '@tanstack/vue-query'\n *\n * // `data` is `Post[]`, never `undefined`, thanks to `initialData` — even if a refetch fails,\n * // so the list stays visible alongside the error.\n * const { data, isError, error } = useQuery({\n * queryKey: ['posts'],\n * queryFn: fetchPosts,\n * initialData: [],\n * })\n * </script>\n *\n * <template>\n * <span v-if=\"isError\">Error: {{ error.message }}</span>\n * <ul>\n * <li v-for=\"post in data\" :key=\"post.id\">{{ post.title }}</li>\n * </ul>\n * </template>\n * ```\n */\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: DefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): UseQueryDefinedReturnType<TData, TError>\n\n/**\n * `enabled` tracks reactive dependencies automatically as a `ref`, a plain value, or a reactive getter\n * (`() => ...`). `queryKey` reacts through a `ref` or a reactive getter for the array itself, or `ref`s and\n * reactive getters as individual entries. Other options are read once when passed as a plain value, and stay\n * reactive when passed as a `ref` or a `computed`.\n *\n * @param options - The {@link UndefinedInitialQueryOptions} to use — everything you can pass to `useQuery`.\n * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one provided by `VueQueryPlugin`\n * will be used.\n * @returns The current query result. `status` is `pending` if there is no cached data to display, `error` if\n * the last fetch attempt failed, or `success` if the query has data to display.\n *\n * @example\n * A query key built from a reactive `ref` — the query refetches whenever `postId` changes:\n * ```vue\n * <script setup lang=\"ts\">\n * import { ref } from 'vue'\n * import { useQuery } from '@tanstack/vue-query'\n *\n * const postId = ref(1)\n * const { status, data, error } = useQuery({\n * queryKey: ['post', postId],\n * queryFn: () => fetchPost(postId.value),\n * })\n * </script>\n *\n * <template>\n * <span v-if=\"status === 'pending'\">Loading...</span>\n * <span v-else-if=\"status === 'error'\">Error: {{ error.message }}</span>\n * <h1 v-else>{{ data.title }}</h1>\n * </template>\n * ```\n *\n * @example\n * `select` derives whatever `data` a component needs from the cached value, without changing what's\n * actually stored in the cache — the cache still holds the full `Post[]`, but `data` here is a `number`:\n * ```vue\n * <script setup lang=\"ts\">\n * import { useQuery } from '@tanstack/vue-query'\n *\n * const { data, isPending, isError, error } = useQuery({\n * queryKey: ['posts'],\n * queryFn: fetchPosts,\n * select: (posts) => posts.length,\n * })\n * </script>\n *\n * <template>\n * <span v-if=\"isPending\">Loading...</span>\n * <span v-else-if=\"isError\">Error: {{ error.message }}</span>\n * <span v-else>{{ data }} posts</span>\n * </template>\n * ```\n *\n * @example\n * A dependent query, only enabled once `postId` is set — use `isLoading`, not `isPending`, so the\n * loading state doesn't show while the query is disabled:\n * ```vue\n * <script setup lang=\"ts\">\n * import { ref } from 'vue'\n * import { useQuery } from '@tanstack/vue-query'\n *\n * const props = defineProps<{ postId: number | undefined }>()\n *\n * const { data, isLoading, isError, error } = useQuery({\n * queryKey: ['post', props.postId],\n * queryFn: () => fetchPost(props.postId!),\n * enabled: () => props.postId != null,\n * })\n * </script>\n *\n * <template>\n * <span v-if=\"props.postId == null\">Select a post</span>\n * <span v-else-if=\"isLoading\">Loading...</span>\n * <span v-else-if=\"isError\">Error: {{ error.message }}</span>\n * <h1 v-else>{{ data?.title }}</h1>\n * </template>\n * ```\n *\n * @example\n * Seeding a detail query from an already-cached list, to skip the loading state:\n * ```vue\n * <script setup lang=\"ts\">\n * import { useQuery, useQueryClient } from '@tanstack/vue-query'\n *\n * const props = defineProps<{ postId: number }>()\n * const queryClient = useQueryClient()\n *\n * const { data, isError, error } = useQuery({\n * queryKey: ['post', props.postId],\n * queryFn: () => fetchPost(props.postId),\n * initialData: () =>\n * queryClient\n * .getQueryData<Array<Post>>(['posts'])\n * ?.find((post) => post.id === props.postId),\n * })\n * </script>\n *\n * <template>\n * <span v-if=\"isError\">Error: {{ error.message }}</span>\n * <h1 v-else>{{ data?.title }}</h1>\n * </template>\n * ```\n *\n * @example\n * Paginated data, keeping the previous page's data visible while the next page loads:\n * ```vue\n * <script setup lang=\"ts\">\n * import { ref } from 'vue'\n * import { keepPreviousData, useQuery } from '@tanstack/vue-query'\n *\n * const page = ref(0)\n *\n * const { data, isPlaceholderData, isError, error } = useQuery({\n * queryKey: ['posts', page],\n * queryFn: () => fetchPosts(page.value),\n * placeholderData: keepPreviousData,\n * })\n * </script>\n *\n * <template>\n * <span v-if=\"isError\">Error: {{ error.message }}</span>\n * <template v-else>\n * <ul>\n * <li v-for=\"post in data\" :key=\"post.id\">{{ post.title }}</li>\n * </ul>\n * <button :disabled=\"isPlaceholderData\" @click=\"page++\">Next Page</button>\n * </template>\n * </template>\n * ```\n */\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UndefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): UseQueryReturnType<TData, TError>\n\n/**\n * Fallback overload for options whose `initialData` presence isn't statically known — for example, a\n * `ref`/reactive object built up conditionally, rather than a plain object literal. Prefer one of the other\n * overloads when possible, since they infer whether `data` can be `undefined` from `initialData` directly.\n *\n * `enabled` tracks reactive dependencies automatically as a `ref`, a plain value, or a reactive getter\n * (`() => ...`). `queryKey` reacts through a `ref` or a reactive getter for the array itself, or `ref`s and\n * reactive getters as individual entries.\n *\n * When `options` itself is a reactive getter, the whole object is re-evaluated on every change to its\n * dependencies, so any option inside it — not just `queryKey` and `enabled` — can change over time.\n *\n * @param options - A `ref`, plain value, or reactive getter resolving to the {@link UseQueryOptions} to use.\n * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one provided by `VueQueryPlugin`\n * will be used.\n * @returns The current query result, with `data` typed as possibly `undefined`.\n *\n * @example\n * Passing a whole-options getter so `staleTime` reacts to a setting stored elsewhere, not just `queryKey`:\n * ```vue\n * <script setup lang=\"ts\">\n * import { useQuery } from '@tanstack/vue-query'\n *\n * const props = defineProps<{ id: number; staleTime: number }>()\n *\n * const { data } = useQuery(() => ({\n * queryKey: ['post', props.id],\n * queryFn: () => fetchPost(props.id),\n * staleTime: props.staleTime,\n * }))\n * </script>\n *\n * <template>\n * <h1 v-if=\"data\">{{ data.title }}</h1>\n * </template>\n * ```\n *\n * @example\n * `skipToken` disables the query in a type-safe way, without a non-null assertion on `props.postId` —\n * `queryFn` is only ever called when it's defined. The whole-options getter re-evaluates `queryFn` on every\n * change to `props.postId`. `queryFn` can also be a `computed`, but never a bare getter, since a function\n * there is the query function itself. `refetch` doesn't work while `queryFn` is `skipToken` — use\n * `enabled: false` instead if you need to trigger the query manually:\n * ```vue\n * <script setup lang=\"ts\">\n * import { skipToken, useQuery } from '@tanstack/vue-query'\n *\n * const props = defineProps<{ postId: number | undefined }>()\n *\n * const { data, isLoading, isError, error } = useQuery(() => {\n * const postId = props.postId\n * return {\n * queryKey: ['post', postId],\n * queryFn: postId != null ? () => fetchPost(postId) : skipToken,\n * }\n * })\n * </script>\n *\n * <template>\n * <span v-if=\"props.postId == null\">Select a post</span>\n * <span v-else-if=\"isLoading\">Loading...</span>\n * <span v-else-if=\"isError\">Error: {{ error.message }}</span>\n * <h1 v-else>{{ data?.title }}</h1>\n * </template>\n * ```\n */\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: MaybeRefOrGetter<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>\n >,\n queryClient?: QueryClient,\n): UseQueryReturnType<TData, TError>\n\nexport function useQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: MaybeRefOrGetter<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>\n >,\n queryClient?: QueryClient,\n):\n | UseQueryReturnType<TData, TError>\n | UseQueryDefinedReturnType<TData, TError> {\n return useBaseQuery(QueryObserver, options, queryClient)\n}\n"],"mappings":";;;AAqSA,SAAgB,SAMd,SAGA,aAG2C;CAC3C,OAAO,aAAa,eAAe,SAAS,WAAW;AACzD"}
1
+ {"version":3,"file":"useQuery.js","names":[],"sources":["../../src/useQuery.ts"],"sourcesContent":["import { QueryObserver } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport type {\n DefaultError,\n DefinedQueryObserverResult,\n QueryKey,\n} from '@tanstack/query-core'\nimport type { UseBaseQueryReturnType } from './useBaseQuery'\nimport type { MaybeRefOrGetter } from './types'\nimport type { QueryClient } from './queryClient'\nimport type {\n DefinedInitialQueryOptions,\n UndefinedInitialQueryOptions,\n UseQueryOptions,\n} from './queryOptions'\n\nexport type UseQueryReturnType<TData, TError> = UseBaseQueryReturnType<\n TData,\n TError\n>\n\nexport type UseQueryDefinedReturnType<TData, TError> = UseBaseQueryReturnType<\n TData,\n TError,\n DefinedQueryObserverResult<TData, TError>\n>\n\n/**\n * This overload is selected when `initialData` is set, so the resulting `data` is never `undefined` (unless\n * a `select` changes `TData` to include `undefined`).\n *\n * `enabled` tracks reactive dependencies automatically as a `ref`, a plain value, or a reactive getter\n * (`() => ...`). `queryKey` reacts through a `ref` or a reactive getter for the array itself, or `ref`s and\n * reactive getters as individual entries. Other options are read once when passed as a plain value, and stay\n * reactive when passed as a `ref` or a `computed`.\n *\n * @param options - The {@link DefinedInitialQueryOptions} to use — everything you can pass to `useQuery`, with\n * `initialData` set.\n * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one provided by `VueQueryPlugin`\n * will be used.\n * @returns The current query result, typed so that `data` is never `undefined` (unless a `select` changes\n * `TData` to include `undefined`). `status` never resolves to `pending` in this overload's type, since\n * `initialData` guarantees data upfront.\n *\n * @example\n * ```vue\n * <script setup lang=\"ts\">\n * import { useQuery } from '@tanstack/vue-query'\n *\n * // `data` is `Post[]`, never `undefined`, thanks to `initialData` — even if a refetch fails,\n * // so the list stays visible alongside the error.\n * const { data, isError, error } = useQuery({\n * queryKey: ['posts'],\n * queryFn: fetchPosts,\n * initialData: [],\n * })\n * </script>\n *\n * <template>\n * <span v-if=\"isError\">Error: {{ error.message }}</span>\n * <ul>\n * <li v-for=\"post in data\" :key=\"post.id\">{{ post.title }}</li>\n * </ul>\n * </template>\n * ```\n */\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: DefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): UseQueryDefinedReturnType<TData, TError>\n\n/**\n * `enabled` tracks reactive dependencies automatically as a `ref`, a plain value, or a reactive getter\n * (`() => ...`). `queryKey` reacts through a `ref` or a reactive getter for the array itself, or `ref`s and\n * reactive getters as individual entries. Other options are read once when passed as a plain value, and stay\n * reactive when passed as a `ref` or a `computed`.\n *\n * @param options - The {@link UndefinedInitialQueryOptions} to use — everything you can pass to `useQuery`.\n * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one provided by `VueQueryPlugin`\n * will be used.\n * @returns The current query result. `status` is `pending` if there is no cached data to display, `error` if\n * the last fetch attempt failed, or `success` if the query has data to display.\n *\n * @example\n * A query key built from a reactive `ref` — the query refetches whenever `postId` changes:\n * ```vue\n * <script setup lang=\"ts\">\n * import { ref } from 'vue'\n * import { useQuery } from '@tanstack/vue-query'\n *\n * const postId = ref(1)\n * const { status, data, error } = useQuery({\n * queryKey: ['post', postId],\n * queryFn: () => fetchPost(postId.value),\n * })\n * </script>\n *\n * <template>\n * <span v-if=\"status === 'pending'\">Loading...</span>\n * <span v-else-if=\"status === 'error'\">Error: {{ error.message }}</span>\n * <h1 v-else>{{ data.title }}</h1>\n * </template>\n * ```\n *\n * @example\n * `select` derives whatever `data` a component needs from the cached value, without changing what's\n * actually stored in the cache — the cache still holds the full `Post[]`, but `data` here is a `number`:\n * ```vue\n * <script setup lang=\"ts\">\n * import { useQuery } from '@tanstack/vue-query'\n *\n * const { data, isPending, isError, error } = useQuery({\n * queryKey: ['posts'],\n * queryFn: fetchPosts,\n * select: (posts) => posts.length,\n * })\n * </script>\n *\n * <template>\n * <span v-if=\"isPending\">Loading...</span>\n * <span v-else-if=\"isError\">Error: {{ error.message }}</span>\n * <span v-else>{{ data }} posts</span>\n * </template>\n * ```\n *\n * @example\n * A dependent query, only enabled once `postId` is set — use `isLoading`, not `isPending`, so the\n * loading state doesn't show while the query is disabled:\n * ```vue\n * <script setup lang=\"ts\">\n * import { ref } from 'vue'\n * import { useQuery } from '@tanstack/vue-query'\n *\n * const props = defineProps<{ postId: number | undefined }>()\n *\n * const { data, isLoading, isError, error } = useQuery({\n * queryKey: ['post', props.postId],\n * queryFn: () => fetchPost(props.postId!),\n * enabled: () => props.postId != null,\n * })\n * </script>\n *\n * <template>\n * <span v-if=\"props.postId == null\">Select a post</span>\n * <span v-else-if=\"isLoading\">Loading...</span>\n * <span v-else-if=\"isError\">Error: {{ error.message }}</span>\n * <h1 v-else>{{ data?.title }}</h1>\n * </template>\n * ```\n *\n * @example\n * Seeding a detail query from an already-cached list, to skip the loading state. `initialDataUpdatedAt` carries\n * over the list's own fetch time, so that if you set a `staleTime`, it's measured from when the list was\n * fetched rather than from now:\n * ```vue\n * <script setup lang=\"ts\">\n * import { useQuery, useQueryClient } from '@tanstack/vue-query'\n *\n * const props = defineProps<{ postId: number }>()\n * const queryClient = useQueryClient()\n *\n * const { data, isError, error } = useQuery({\n * queryKey: ['post', props.postId],\n * queryFn: () => fetchPost(props.postId),\n * initialData: () =>\n * queryClient\n * .getQueryData<Array<Post>>(['posts'])\n * ?.find((post) => post.id === props.postId),\n * initialDataUpdatedAt: () =>\n * queryClient.getQueryState(['posts'])?.dataUpdatedAt,\n * })\n * </script>\n *\n * <template>\n * <span v-if=\"isError\">Error: {{ error.message }}</span>\n * <h1 v-else>{{ data?.title }}</h1>\n * </template>\n * ```\n *\n * @example\n * Paginated data, keeping the previous page's data visible while the next page loads:\n * ```vue\n * <script setup lang=\"ts\">\n * import { ref } from 'vue'\n * import { keepPreviousData, useQuery } from '@tanstack/vue-query'\n *\n * const page = ref(0)\n *\n * const { data, isPlaceholderData, isError, error } = useQuery({\n * queryKey: ['posts', page],\n * queryFn: () => fetchPosts(page.value),\n * placeholderData: keepPreviousData,\n * })\n * </script>\n *\n * <template>\n * <span v-if=\"isError\">Error: {{ error.message }}</span>\n * <template v-else>\n * <ul>\n * <li v-for=\"post in data\" :key=\"post.id\">{{ post.title }}</li>\n * </ul>\n * <button :disabled=\"isPlaceholderData\" @click=\"page++\">Next Page</button>\n * </template>\n * </template>\n * ```\n */\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UndefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): UseQueryReturnType<TData, TError>\n\n/**\n * Fallback overload for options whose `initialData` presence isn't statically known — for example, a\n * `ref`/reactive object built up conditionally, rather than a plain object literal. Prefer one of the other\n * overloads when possible, since they infer whether `data` can be `undefined` from `initialData` directly.\n *\n * `enabled` tracks reactive dependencies automatically as a `ref`, a plain value, or a reactive getter\n * (`() => ...`). `queryKey` reacts through a `ref` or a reactive getter for the array itself, or `ref`s and\n * reactive getters as individual entries.\n *\n * When `options` itself is a reactive getter, the whole object is re-evaluated on every change to its\n * dependencies, so any option inside it — not just `queryKey` and `enabled` — can change over time.\n *\n * @param options - A `ref`, plain value, or reactive getter resolving to the {@link UseQueryOptions} to use.\n * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one provided by `VueQueryPlugin`\n * will be used.\n * @returns The current query result, with `data` typed as possibly `undefined`.\n *\n * @example\n * Passing a whole-options getter so `staleTime` reacts to a setting stored elsewhere, not just `queryKey`:\n * ```vue\n * <script setup lang=\"ts\">\n * import { useQuery } from '@tanstack/vue-query'\n *\n * const props = defineProps<{ id: number; staleTime: number }>()\n *\n * const { data } = useQuery(() => ({\n * queryKey: ['post', props.id],\n * queryFn: () => fetchPost(props.id),\n * staleTime: props.staleTime,\n * }))\n * </script>\n *\n * <template>\n * <h1 v-if=\"data\">{{ data.title }}</h1>\n * </template>\n * ```\n *\n * @example\n * `skipToken` disables the query in a type-safe way, without a non-null assertion on `props.postId` —\n * `queryFn` is only ever called when it's defined. The whole-options getter re-evaluates `queryFn` on every\n * change to `props.postId`. `queryFn` can also be a `computed`, but never a bare getter, since a function\n * there is the query function itself. `refetch` doesn't work while `queryFn` is `skipToken` — use\n * `enabled: false` instead if you need to trigger the query manually:\n * ```vue\n * <script setup lang=\"ts\">\n * import { skipToken, useQuery } from '@tanstack/vue-query'\n *\n * const props = defineProps<{ postId: number | undefined }>()\n *\n * const { data, isLoading, isError, error } = useQuery(() => {\n * const postId = props.postId\n * return {\n * queryKey: ['post', postId],\n * queryFn: postId != null ? () => fetchPost(postId) : skipToken,\n * }\n * })\n * </script>\n *\n * <template>\n * <span v-if=\"props.postId == null\">Select a post</span>\n * <span v-else-if=\"isLoading\">Loading...</span>\n * <span v-else-if=\"isError\">Error: {{ error.message }}</span>\n * <h1 v-else>{{ data?.title }}</h1>\n * </template>\n * ```\n */\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: MaybeRefOrGetter<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>\n >,\n queryClient?: QueryClient,\n): UseQueryReturnType<TData, TError>\n\nexport function useQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: MaybeRefOrGetter<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>\n >,\n queryClient?: QueryClient,\n):\n UseQueryReturnType<TData, TError> | UseQueryDefinedReturnType<TData, TError> {\n return useBaseQuery(QueryObserver, options, queryClient)\n}\n"],"mappings":";;;AA2SA,SAAgB,SAMd,SAGA,aAE6E;CAC7E,OAAO,aAAa,eAAe,SAAS,WAAW;AACzD"}
@@ -1,4 +1,4 @@
1
- import { t as QueryClient } from "./queryClient-CZeNAt68.cjs";
1
+ import { t as QueryClient } from "./queryClient-Bn2Ql_Lu.cjs";
2
2
  //#region src/useQueryClient.d.ts
3
3
  /**
4
4
  * Retrieves the `QueryClient` installed by `VueQueryPlugin`, via Vue's `inject`. Must be called inside
@@ -21,7 +21,6 @@ import { t as QueryClient } from "./queryClient-CZeNAt68.cjs";
21
21
  * </script>
22
22
  * ```
23
23
  */
24
- declare function useQueryClient(id?: string): QueryClient;
24
+ export declare function useQueryClient(id?: string): QueryClient;
25
25
  //#endregion
26
- export { useQueryClient };
27
26
  //# sourceMappingURL=useQueryClient.d.cts.map
@@ -1 +1 @@
1
- {"version":3,"file":"useQueryClient.d.cts","names":[],"sources":["../../src/useQueryClient.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;iBA0BgB,eAAe,cAAU"}
1
+ {"version":3,"file":"useQueryClient.d.cts","names":[],"sources":["../../src/useQueryClient.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;wBA0BgB,eAAe,cAAU"}
@@ -1,4 +1,4 @@
1
- import { t as QueryClient } from "./queryClient-Cv73nzNT.js";
1
+ import { t as QueryClient } from "./queryClient-B6mLtXOj.js";
2
2
  //#region src/useQueryClient.d.ts
3
3
  /**
4
4
  * Retrieves the `QueryClient` installed by `VueQueryPlugin`, via Vue's `inject`. Must be called inside
@@ -21,7 +21,6 @@ import { t as QueryClient } from "./queryClient-Cv73nzNT.js";
21
21
  * </script>
22
22
  * ```
23
23
  */
24
- declare function useQueryClient(id?: string): QueryClient;
24
+ export declare function useQueryClient(id?: string): QueryClient;
25
25
  //#endregion
26
- export { useQueryClient };
27
26
  //# sourceMappingURL=useQueryClient.d.ts.map
@@ -1 +1 @@
1
- {"version":3,"file":"useQueryClient.d.ts","names":[],"sources":["../../src/useQueryClient.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;iBA0BgB,eAAe,cAAU"}
1
+ {"version":3,"file":"useQueryClient.d.ts","names":[],"sources":["../../src/useQueryClient.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;wBA0BgB,eAAe,cAAU"}
@@ -1,26 +1,25 @@
1
1
  import { o as MaybeRefDeep } from "./types-JpJB72CS.cjs";
2
2
  //#region src/utils.d.ts
3
3
  /** @internal Base Vue injection key `VueQueryPlugin` provides the `QueryClient` under. */
4
- declare const VUE_QUERY_CLIENT = "VUE_QUERY_CLIENT";
4
+ export declare const VUE_QUERY_CLIENT = "VUE_QUERY_CLIENT";
5
5
  /** @internal Builds the injection key `useQueryClient`/`VueQueryPlugin` use for a given `queryClientKey`. */
6
- declare function getClientKey(key?: string): string;
6
+ export declare function getClientKey(key?: string): string;
7
7
  /** @internal Copies each property from `update` onto `state`, in place, for every key already on `state`. */
8
- declare function updateState(state: Record<string, any>, update: Record<string, any>): void;
8
+ export declare function updateState(state: Record<string, any>, update: Record<string, any>): void;
9
9
  /**
10
10
  * @internal Deep-clones `value`, recursing into arrays and plain objects. `customize`, if provided, can
11
11
  * intercept any node (by key and nesting level) and substitute its own return value instead of recursing
12
12
  * further.
13
13
  */
14
- declare function cloneDeep<T>(value: MaybeRefDeep<T>, customize?: (val: MaybeRefDeep<T>, key: string, level: number) => T | undefined): T;
14
+ export declare function cloneDeep<T>(value: MaybeRefDeep<T>, customize?: (val: MaybeRefDeep<T>, key: string, level: number) => T | undefined): T;
15
15
  /**
16
16
  * @internal Deep-clones `value` like {@link cloneDeep}, additionally unwrapping any `ref`s it encounters (and,
17
17
  * if `unrefGetters` is `true`, calling any functions it encounters and unwrapping their result too). Always
18
18
  * resolves `queryKey` this way, regardless of `unrefGetters` — this is what lets a `queryKey` containing `ref`s
19
19
  * be passed straight through to `@tanstack/query-core`.
20
20
  */
21
- declare function cloneDeepUnref<T>(obj: MaybeRefDeep<T>, unrefGetters?: boolean): T;
21
+ export declare function cloneDeepUnref<T>(obj: MaybeRefDeep<T>, unrefGetters?: boolean): T;
22
22
  /** @internal Resolves `source` to a plain value — calls it if it's a function, otherwise deep-unwraps it. */
23
- declare function toValueDeep<T>(source: (() => T) | MaybeRefDeep<T>): T;
23
+ export declare function toValueDeep<T>(source: (() => T) | MaybeRefDeep<T>): T;
24
24
  //#endregion
25
- export { VUE_QUERY_CLIENT, cloneDeep, cloneDeepUnref, getClientKey, toValueDeep, updateState };
26
25
  //# sourceMappingURL=utils.d.cts.map
@@ -1 +1 @@
1
- {"version":3,"file":"utils.d.cts","names":[],"sources":["../../src/utils.ts"],"mappings":";;;cAIa;;iBAGG,aAAa;;iBAMb,YACd,OAAO,qBACP,QAAQ;;;;;;iBAmDM,UAAU,GACxB,OAAO,aAAa,IACpB,aACE,KAAK,aAAa,IAClB,aACA,kBACG,gBACJ;;;;;;;iBAUa,eAAe,GAC7B,KAAK,aAAa,IAClB,yBACC;;iBAyCa,YAAY,GAAG,eAAe,KAAK,aAAa,KAAK"}
1
+ {"version":3,"file":"utils.d.cts","names":[],"sources":["../../src/utils.ts"],"mappings":";;;qBAIa;;wBAGG,aAAa;;wBAMb,YACd,OAAO,qBACP,QAAQ;;;;;;wBAmDM,UAAU,GACxB,OAAO,aAAa,IACpB,aACE,KAAK,aAAa,IAClB,aACA,kBACG,gBACJ;;;;;;;wBAUa,eAAe,GAC7B,KAAK,aAAa,IAClB,yBACC;;wBAyCa,YAAY,GAAG,eAAe,KAAK,aAAa,KAAK"}
@@ -1,26 +1,25 @@
1
1
  import { o as MaybeRefDeep } from "./types-JpJB72CS.js";
2
2
  //#region src/utils.d.ts
3
3
  /** @internal Base Vue injection key `VueQueryPlugin` provides the `QueryClient` under. */
4
- declare const VUE_QUERY_CLIENT = "VUE_QUERY_CLIENT";
4
+ export declare const VUE_QUERY_CLIENT = "VUE_QUERY_CLIENT";
5
5
  /** @internal Builds the injection key `useQueryClient`/`VueQueryPlugin` use for a given `queryClientKey`. */
6
- declare function getClientKey(key?: string): string;
6
+ export declare function getClientKey(key?: string): string;
7
7
  /** @internal Copies each property from `update` onto `state`, in place, for every key already on `state`. */
8
- declare function updateState(state: Record<string, any>, update: Record<string, any>): void;
8
+ export declare function updateState(state: Record<string, any>, update: Record<string, any>): void;
9
9
  /**
10
10
  * @internal Deep-clones `value`, recursing into arrays and plain objects. `customize`, if provided, can
11
11
  * intercept any node (by key and nesting level) and substitute its own return value instead of recursing
12
12
  * further.
13
13
  */
14
- declare function cloneDeep<T>(value: MaybeRefDeep<T>, customize?: (val: MaybeRefDeep<T>, key: string, level: number) => T | undefined): T;
14
+ export declare function cloneDeep<T>(value: MaybeRefDeep<T>, customize?: (val: MaybeRefDeep<T>, key: string, level: number) => T | undefined): T;
15
15
  /**
16
16
  * @internal Deep-clones `value` like {@link cloneDeep}, additionally unwrapping any `ref`s it encounters (and,
17
17
  * if `unrefGetters` is `true`, calling any functions it encounters and unwrapping their result too). Always
18
18
  * resolves `queryKey` this way, regardless of `unrefGetters` — this is what lets a `queryKey` containing `ref`s
19
19
  * be passed straight through to `@tanstack/query-core`.
20
20
  */
21
- declare function cloneDeepUnref<T>(obj: MaybeRefDeep<T>, unrefGetters?: boolean): T;
21
+ export declare function cloneDeepUnref<T>(obj: MaybeRefDeep<T>, unrefGetters?: boolean): T;
22
22
  /** @internal Resolves `source` to a plain value — calls it if it's a function, otherwise deep-unwraps it. */
23
- declare function toValueDeep<T>(source: (() => T) | MaybeRefDeep<T>): T;
23
+ export declare function toValueDeep<T>(source: (() => T) | MaybeRefDeep<T>): T;
24
24
  //#endregion
25
- export { VUE_QUERY_CLIENT, cloneDeep, cloneDeepUnref, getClientKey, toValueDeep, updateState };
26
25
  //# sourceMappingURL=utils.d.ts.map
@@ -1 +1 @@
1
- {"version":3,"file":"utils.d.ts","names":[],"sources":["../../src/utils.ts"],"mappings":";;;cAIa;;iBAGG,aAAa;;iBAMb,YACd,OAAO,qBACP,QAAQ;;;;;;iBAmDM,UAAU,GACxB,OAAO,aAAa,IACpB,aACE,KAAK,aAAa,IAClB,aACA,kBACG,gBACJ;;;;;;;iBAUa,eAAe,GAC7B,KAAK,aAAa,IAClB,yBACC;;iBAyCa,YAAY,GAAG,eAAe,KAAK,aAAa,KAAK"}
1
+ {"version":3,"file":"utils.d.ts","names":[],"sources":["../../src/utils.ts"],"mappings":";;;qBAIa;;wBAGG,aAAa;;wBAMb,YACd,OAAO,qBACP,QAAQ;;;;;;wBAmDM,UAAU,GACxB,OAAO,aAAa,IACpB,aACE,KAAK,aAAa,IAClB,aACA,kBACG,gBACJ;;;;;;;wBAUa,eAAe,GAC7B,KAAK,aAAa,IAClB,yBACC;;wBAyCa,YAAY,GAAG,eAAe,KAAK,aAAa,KAAK"}
@@ -1,5 +1,5 @@
1
1
  import { u as QueryClientConfig } from "./types-JpJB72CS.cjs";
2
- import { t as QueryClient } from "./queryClient-CZeNAt68.cjs";
2
+ import { t as QueryClient } from "./queryClient-Bn2Ql_Lu.cjs";
3
3
  //#region src/vueQueryPlugin.d.ts
4
4
  type ClientPersister = (client: QueryClient) => [() => void, Promise<void>];
5
5
  interface CommonOptions {
@@ -26,7 +26,7 @@ interface ClientOptions extends CommonOptions {
26
26
  /** Use your own `QueryClient` instance instead of having the plugin construct one from `queryClientConfig`. */
27
27
  queryClient?: QueryClient;
28
28
  }
29
- type VueQueryPluginOptions = ConfigOptions | ClientOptions;
29
+ export type VueQueryPluginOptions = ConfigOptions | ClientOptions;
30
30
  /**
31
31
  * Installs a `QueryClient` on the Vue app, making it available to every descendant component through
32
32
  * `useQueryClient` — the Vue equivalent of React's `QueryClientProvider`, but wired up as an app-level plugin
@@ -61,9 +61,8 @@ type VueQueryPluginOptions = ConfigOptions | ClientOptions;
61
61
  * })
62
62
  * ```
63
63
  */
64
- declare const VueQueryPlugin: {
64
+ export declare const VueQueryPlugin: {
65
65
  install: (app: any, options?: VueQueryPluginOptions) => void;
66
66
  };
67
67
  //#endregion
68
- export { VueQueryPlugin, VueQueryPluginOptions };
69
68
  //# sourceMappingURL=vueQueryPlugin.d.cts.map
@@ -1 +1 @@
1
- {"version":3,"file":"vueQueryPlugin.d.cts","names":[],"sources":["../../src/vueQueryPlugin.ts"],"mappings":";;;KAQK,mBAAmB,QAAQ,6BAA6B;UAEnD;;EAER;;;;;EAKA;;;;;EAKA,kBAAkB;;EAElB,4BAA4B,QAAQ;;UAG5B,sBAAsB;;EAE9B,oBAAoB;;UAGZ,sBAAsB;;EAE9B,cAAc;;KAGJ,wBAAwB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAoCvC;EACI,UAAA,UAAG,UAAW"}
1
+ {"version":3,"file":"vueQueryPlugin.d.cts","names":[],"sources":["../../src/vueQueryPlugin.ts"],"mappings":";;;KAQK,mBAAmB,QAAQ,6BAA6B;UAEnD;;EAER;;;;;EAKA;;;;;EAKA,kBAAkB;;EAElB,4BAA4B,QAAQ;;UAG5B,sBAAsB;;EAE9B,oBAAoB;;UAGZ,sBAAsB;;EAE9B,cAAc;;YAGJ,wBAAwB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoCvC;EACI,UAAA,UAAG,UAAW"}
@@ -1,5 +1,5 @@
1
1
  import { u as QueryClientConfig } from "./types-JpJB72CS.js";
2
- import { t as QueryClient } from "./queryClient-Cv73nzNT.js";
2
+ import { t as QueryClient } from "./queryClient-B6mLtXOj.js";
3
3
  //#region src/vueQueryPlugin.d.ts
4
4
  type ClientPersister = (client: QueryClient) => [() => void, Promise<void>];
5
5
  interface CommonOptions {
@@ -26,7 +26,7 @@ interface ClientOptions extends CommonOptions {
26
26
  /** Use your own `QueryClient` instance instead of having the plugin construct one from `queryClientConfig`. */
27
27
  queryClient?: QueryClient;
28
28
  }
29
- type VueQueryPluginOptions = ConfigOptions | ClientOptions;
29
+ export type VueQueryPluginOptions = ConfigOptions | ClientOptions;
30
30
  /**
31
31
  * Installs a `QueryClient` on the Vue app, making it available to every descendant component through
32
32
  * `useQueryClient` — the Vue equivalent of React's `QueryClientProvider`, but wired up as an app-level plugin
@@ -61,9 +61,8 @@ type VueQueryPluginOptions = ConfigOptions | ClientOptions;
61
61
  * })
62
62
  * ```
63
63
  */
64
- declare const VueQueryPlugin: {
64
+ export declare const VueQueryPlugin: {
65
65
  install: (app: any, options?: VueQueryPluginOptions) => void;
66
66
  };
67
67
  //#endregion
68
- export { VueQueryPlugin, VueQueryPluginOptions };
69
68
  //# sourceMappingURL=vueQueryPlugin.d.ts.map
@@ -1 +1 @@
1
- {"version":3,"file":"vueQueryPlugin.d.ts","names":[],"sources":["../../src/vueQueryPlugin.ts"],"mappings":";;;KAQK,mBAAmB,QAAQ,6BAA6B;UAEnD;;EAER;;;;;EAKA;;;;;EAKA,kBAAkB;;EAElB,4BAA4B,QAAQ;;UAG5B,sBAAsB;;EAE9B,oBAAoB;;UAGZ,sBAAsB;;EAE9B,cAAc;;KAGJ,wBAAwB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAoCvC;EACI,UAAA,UAAG,UAAW"}
1
+ {"version":3,"file":"vueQueryPlugin.d.ts","names":[],"sources":["../../src/vueQueryPlugin.ts"],"mappings":";;;KAQK,mBAAmB,QAAQ,6BAA6B;UAEnD;;EAER;;;;;EAKA;;;;;EAKA,kBAAkB;;EAElB,4BAA4B,QAAQ;;UAG5B,sBAAsB;;EAE9B,oBAAoB;;UAGZ,sBAAsB;;EAE9B,cAAc;;YAGJ,wBAAwB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoCvC;EACI,UAAA,UAAG,UAAW"}
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@tanstack/vue-query",
3
- "version": "5.103.2",
3
+ "version": "5.104.0",
4
4
  "description": "Hooks for managing, caching and syncing asynchronous and remote data in Vue",
5
5
  "author": "Damian Osipiuk",
6
6
  "license": "MIT",
@@ -39,19 +39,19 @@
39
39
  "!src/__tests__"
40
40
  ],
41
41
  "dependencies": {
42
- "@tanstack/match-sorter-utils": "^8.19.4",
42
+ "@tanstack/match-sorter-utils": "^9.1.2",
43
+ "@tanstack/query-core": "5.104.0",
43
44
  "@vue/devtools-api": "^6.6.3",
44
- "vue-demi": "^0.14.10",
45
- "@tanstack/query-core": "5.103.2"
45
+ "vue-demi": "^0.14.10"
46
46
  },
47
47
  "devDependencies": {
48
- "@vitejs/plugin-vue": "^5.2.4",
48
+ "@tanstack/query-test-utils": "0.0.0",
49
49
  "@vue/composition-api": "1.7.2",
50
- "eslint-plugin-vue": "^10.5.0",
51
- "vue": "^3.4.27",
50
+ "eslint-plugin-vue": "^10.11.1",
51
+ "unplugin-vue": "^8.0.0",
52
+ "vue": "^3.5.43",
52
53
  "vue2": "npm:vue@2.6",
53
- "vue2.7": "npm:vue@2.7",
54
- "@tanstack/query-test-utils": "0.0.0"
54
+ "vue2.7": "npm:vue@2.7"
55
55
  },
56
56
  "peerDependencies": {
57
57
  "@vue/composition-api": "^1.1.2",
@@ -36,7 +36,7 @@ export type UndefinedInitialDataInfiniteOptions<
36
36
 
37
37
  /**
38
38
  * The options accepted by the `infiniteQueryOptions` overload selected when `initialData` is set — `data` is
39
- * never `undefined`.
39
+ * never `undefined` (unless a `select` changes `TData` to include `undefined`).
40
40
  *
41
41
  * @template TQueryFnData - The type of a single page, as your `queryFn` resolves it.
42
42
  * @template TError - The type of errors your `queryFn` may throw.
@@ -124,7 +124,8 @@ export function infiniteQueryOptions<
124
124
  * These options can be shared across hooks and imperative APIs such as `queryClient.infiniteQuery`.
125
125
  * `options.queryKey` is required and is the query key to generate options for.
126
126
  *
127
- * This overload is selected when `initialData` is set, so the resulting `data` is never `undefined`.
127
+ * This overload is selected when `initialData` is set, so the resulting `data` is never `undefined` (unless
128
+ * a `select` changes `TData` to include `undefined`).
128
129
  *
129
130
  * @see {@link useInfiniteQuery} to run an infinite query with these options.
130
131
  * @param options - The {@link DefinedInitialDataInfiniteOptions} to use — everything you can pass to
@@ -6,6 +6,10 @@ import type { MutationOptions } from './types'
6
6
  * `mutationKey` is required on this overload so the mutation can be looked up later, e.g. with
7
7
  * `useMutationState`.
8
8
  *
9
+ * Unlike a `queryKey` property on a query's options (e.g. `queryOptions({ queryKey: [...] })`), `mutationKey`
10
+ * entries that are reactive getters (`() => id.value`) are never unwrapped — the getter function itself is
11
+ * stored as the entry, rather than its current value. `ref` entries are still unwrapped normally.
12
+ *
9
13
  * @see {@link useMutation} to run the mutation these options describe.
10
14
  * @param options - The mutation options to use, identical to what you'd pass to `useMutation`, with a
11
15
  * required `mutationKey`.
@@ -39,6 +39,13 @@ import type {
39
39
  * `CancelOptions` or `InvalidateOptions`) or filters (such as the `QueryFilters` accepted by
40
40
  * `invalidateQueries`) also accept a {@link MaybeRefDeep} version of it, so you can pass `ref`s directly
41
41
  * without unwrapping them yourself — e.g. `queryClient.invalidateQueries({ queryKey: ['post', myRef] })`.
42
+ *
43
+ * `ref` entries in a `queryKey` are unwrapped this way on every method, but reactive getter entries
44
+ * (`() => id.value`) are only unwrapped when the `queryKey` is passed as a `queryKey` property of a
45
+ * filters/options object (e.g. `invalidateQueries({ queryKey: ['post', idGetter] })`) — methods like
46
+ * `getQueryData` that take the `queryKey` array as their own argument do not unwrap getter entries there,
47
+ * and the getter function itself ends up in the cache key.
48
+ *
42
49
  * Install one on your app with `VueQueryPlugin`, or retrieve it with `useQueryClient`.
43
50
  */
44
51
  export class QueryClient extends QC {
@@ -34,21 +34,22 @@ export type QueryOptions<
34
34
  TQueryData = TQueryFnData,
35
35
  TQueryKey extends QueryKey = QueryKey,
36
36
  > = {
37
- [Property in keyof QueryObserverOptions<
38
- TQueryFnData,
39
- TError,
40
- TData,
41
- TQueryData,
42
- TQueryKey
43
- >]: Property extends 'enabled'
44
- ?
45
- | MaybeRefOrGetter<boolean | undefined>
46
- | (() => QueryBooleanOption<
47
- TQueryFnData,
48
- TError,
49
- TQueryData,
50
- DeepUnwrapRef<TQueryKey>
51
- >)
37
+ [
38
+ Property in keyof QueryObserverOptions<
39
+ TQueryFnData,
40
+ TError,
41
+ TData,
42
+ TQueryData,
43
+ TQueryKey
44
+ >
45
+ ]: Property extends 'enabled'
46
+ ? | MaybeRefOrGetter<boolean | undefined>
47
+ | (() => QueryBooleanOption<
48
+ TQueryFnData,
49
+ TError,
50
+ TQueryData,
51
+ DeepUnwrapRef<TQueryKey>
52
+ >)
52
53
  : Property extends 'queryKey'
53
54
  ? MaybeRefOrGetter<TQueryKey>
54
55
  : QueryObserverOptions<
@@ -96,13 +97,15 @@ export type UseQueryOptions<
96
97
  TQueryKey extends QueryKey = QueryKey,
97
98
  > = MaybeRef<
98
99
  {
99
- [Property in keyof QueryObserverOptions<
100
- TQueryFnData,
101
- TError,
102
- TData,
103
- TQueryData,
104
- TQueryKey
105
- >]: Property extends 'enabled' | 'queryKey'
100
+ [
101
+ Property in keyof QueryObserverOptions<
102
+ TQueryFnData,
103
+ TError,
104
+ TData,
105
+ TQueryData,
106
+ TQueryKey
107
+ >
108
+ ]: Property extends 'enabled' | 'queryKey'
106
109
  ? QueryOptions<
107
110
  TQueryFnData,
108
111
  TError,
@@ -156,8 +159,7 @@ type WithDefinedInitialData<TQueryFnData> = {
156
159
  * cache. Unlike `queryKey`/`enabled`, this is not reactive — it isn't re-evaluated on `ref` changes.
157
160
  */
158
161
  initialData:
159
- | NonUndefinedGuard<TQueryFnData>
160
- | (() => NonUndefinedGuard<TQueryFnData>)
162
+ NonUndefinedGuard<TQueryFnData> | (() => NonUndefinedGuard<TQueryFnData>)
161
163
  }
162
164
 
163
165
  /**
@@ -179,7 +181,7 @@ export type UndefinedInitialQueryOptions<
179
181
 
180
182
  /**
181
183
  * The options accepted by the `queryOptions` overload selected when `initialData` is set — `data` is never
182
- * `undefined`.
184
+ * `undefined` (unless a `select` changes `TData` to include `undefined`).
183
185
  *
184
186
  * @template TQueryFnData - The type your `queryFn` resolves to.
185
187
  * @template TError - The type of errors your `queryFn` may throw.
@@ -217,7 +219,8 @@ export type DefinedInitialQueryOptionsWithDataTag<
217
219
  * be shared across hooks and imperative APIs such as `queryClient.query`. `options.queryKey` is required and
218
220
  * is the query key to generate options for.
219
221
  *
220
- * This overload is selected when `initialData` is set, so the resulting `data` is never `undefined`.
222
+ * This overload is selected when `initialData` is set, so the resulting `data` is never `undefined` (unless
223
+ * a `select` changes `TData` to include `undefined`).
221
224
  *
222
225
  * @see {@link useQuery} to run a query with these options.
223
226
  * @param options - The {@link DefinedInitialQueryOptions} to use — everything you can pass to `useQuery`, with
@@ -30,12 +30,18 @@ export type UseBaseQueryReturnType<
30
30
  TResult = QueryObserverResult<TData, TError>,
31
31
  > = {
32
32
  [K in keyof TResult]: K extends
33
- | 'fetchNextPage'
34
- | 'fetchPreviousPage'
35
- | 'refetch'
33
+ 'fetchNextPage' | 'fetchPreviousPage' | 'refetch'
36
34
  ? TResult[K]
37
35
  : Ref<Readonly<TResult>[K]>
38
36
  } & {
37
+ /**
38
+ * Returns a promise for use with Vue's `Suspense` or `onServerPrefetch`. It fetches the query if it has no
39
+ * data or its data is stale and resolves with the result once that fetch resolves (usually when the query
40
+ * function finishes, but earlier after the first chunk of a streamed query or when data is set during the
41
+ * fetch), or resolves immediately if the data is fresh. While the query is disabled, it waits until the query
42
+ * is enabled. If the fetch fails, it resolves with the error result, unless `throwOnError` is (or returns)
43
+ * `true`, in which case it rejects.
44
+ */
39
45
  suspense: () => Promise<TResult>
40
46
  }
41
47
 
@@ -32,13 +32,15 @@ export type UseInfiniteQueryOptions<
32
32
  TPageParam = unknown,
33
33
  > = MaybeRef<
34
34
  {
35
- [Property in keyof InfiniteQueryObserverOptions<
36
- TQueryFnData,
37
- TError,
38
- TData,
39
- TQueryKey,
40
- TPageParam
41
- >]: Property extends 'enabled'
35
+ [
36
+ Property in keyof InfiniteQueryObserverOptions<
37
+ TQueryFnData,
38
+ TError,
39
+ TData,
40
+ TQueryKey,
41
+ TPageParam
42
+ >
43
+ ]: Property extends 'enabled'
42
44
  ? MaybeRefOrGetter<
43
45
  InfiniteQueryObserverOptions<
44
46
  TQueryFnData,
@@ -70,7 +72,8 @@ export type UseInfiniteQueryReturnType<TData, TError> = UseBaseQueryReturnType<
70
72
  * The options for `useInfiniteQuery` are identical to `useQuery`, with the addition of
71
73
  * `initialPageParam`, `getNextPageParam`, `getPreviousPageParam`, and `maxPages`.
72
74
  *
73
- * This overload is selected when `initialData` is set, so the resulting `data` is never `undefined`.
75
+ * This overload is selected when `initialData` is set, so the resulting `data` is never `undefined` (unless
76
+ * a `select` changes `TData` to include `undefined`).
74
77
  *
75
78
  * `enabled` tracks reactive dependencies automatically as a `ref`, a plain value, or a reactive getter
76
79
  * (`() => ...`). `queryKey` reacts through a `ref` for the array itself, or `ref`s and reactive getters as
@@ -7,8 +7,7 @@ import type { MaybeRefDeep } from './types'
7
7
  import type { QueryClient } from './queryClient'
8
8
 
9
9
  export type UseIsFetchingFilters =
10
- | MaybeRefDeep<QueryFilters>
11
- | (() => MaybeRefDeep<QueryFilters>)
10
+ MaybeRefDeep<QueryFilters> | (() => MaybeRefDeep<QueryFilters>)
12
11
 
13
12
  /**
14
13
  * The `useIsFetching` composable returns a `ref` to the `number` of the queries that your application is
@@ -21,8 +21,7 @@ import type { MutationCache } from './mutationCache'
21
21
  type VueMutationFilters = MaybeRefDeep<MutationFilters>
22
22
 
23
23
  export type UseIsMutatingFilters =
24
- | VueMutationFilters
25
- | (() => VueMutationFilters)
24
+ VueMutationFilters | (() => VueMutationFilters)
26
25
 
27
26
  /**
28
27
  * The `useIsMutating` composable returns a `ref` to the `number` of mutations that your application currently