@tanstack/react-query 5.103.3 → 5.104.1

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 (186) hide show
  1. package/build/legacy/HydrationBoundary.d.cts +2 -3
  2. package/build/legacy/HydrationBoundary.d.cts.map +1 -1
  3. package/build/legacy/HydrationBoundary.d.ts +2 -3
  4. package/build/legacy/HydrationBoundary.d.ts.map +1 -1
  5. package/build/legacy/IsRestoringProvider.d.cts +2 -3
  6. package/build/legacy/IsRestoringProvider.d.cts.map +1 -1
  7. package/build/legacy/IsRestoringProvider.d.ts +2 -3
  8. package/build/legacy/IsRestoringProvider.d.ts.map +1 -1
  9. package/build/legacy/QueryClientProvider.d.cts +4 -5
  10. package/build/legacy/QueryClientProvider.d.cts.map +1 -1
  11. package/build/legacy/QueryClientProvider.d.ts +4 -5
  12. package/build/legacy/QueryClientProvider.d.ts.map +1 -1
  13. package/build/legacy/QueryErrorResetBoundary.d.cts +8 -9
  14. package/build/legacy/QueryErrorResetBoundary.d.cts.map +1 -1
  15. package/build/legacy/QueryErrorResetBoundary.d.ts +8 -9
  16. package/build/legacy/QueryErrorResetBoundary.d.ts.map +1 -1
  17. package/build/legacy/errorBoundaryUtils.d.cts +3 -4
  18. package/build/legacy/errorBoundaryUtils.d.cts.map +1 -1
  19. package/build/legacy/errorBoundaryUtils.d.ts +3 -4
  20. package/build/legacy/errorBoundaryUtils.d.ts.map +1 -1
  21. package/build/legacy/infiniteQueryOptions.d.cts +6 -7
  22. package/build/legacy/infiniteQueryOptions.d.cts.map +1 -1
  23. package/build/legacy/infiniteQueryOptions.d.ts +6 -7
  24. package/build/legacy/infiniteQueryOptions.d.ts.map +1 -1
  25. package/build/legacy/mutationOptions.d.cts +2 -3
  26. package/build/legacy/mutationOptions.d.cts.map +1 -1
  27. package/build/legacy/mutationOptions.d.ts +2 -3
  28. package/build/legacy/mutationOptions.d.ts.map +1 -1
  29. package/build/legacy/queryOptions.d.cts +6 -7
  30. package/build/legacy/queryOptions.d.cts.map +1 -1
  31. package/build/legacy/queryOptions.d.ts +6 -7
  32. package/build/legacy/queryOptions.d.ts.map +1 -1
  33. package/build/legacy/suspense.d.cts +4 -5
  34. package/build/legacy/suspense.d.cts.map +1 -1
  35. package/build/legacy/suspense.d.ts +4 -5
  36. package/build/legacy/suspense.d.ts.map +1 -1
  37. package/build/legacy/types.d.cts +25 -26
  38. package/build/legacy/types.d.cts.map +1 -1
  39. package/build/legacy/types.d.ts +25 -26
  40. package/build/legacy/types.d.ts.map +1 -1
  41. package/build/legacy/useBaseQuery.d.cts +1 -2
  42. package/build/legacy/useBaseQuery.d.cts.map +1 -1
  43. package/build/legacy/useBaseQuery.d.ts +1 -2
  44. package/build/legacy/useBaseQuery.d.ts.map +1 -1
  45. package/build/legacy/useInfiniteQuery.d.cts +3 -4
  46. package/build/legacy/useInfiniteQuery.d.cts.map +1 -1
  47. package/build/legacy/useInfiniteQuery.d.ts +3 -4
  48. package/build/legacy/useInfiniteQuery.d.ts.map +1 -1
  49. package/build/legacy/useIsFetching.d.cts +1 -2
  50. package/build/legacy/useIsFetching.d.cts.map +1 -1
  51. package/build/legacy/useIsFetching.d.ts +1 -2
  52. package/build/legacy/useIsFetching.d.ts.map +1 -1
  53. package/build/legacy/useMutation.d.cts +1 -2
  54. package/build/legacy/useMutation.d.cts.map +1 -1
  55. package/build/legacy/useMutation.d.ts +1 -2
  56. package/build/legacy/useMutation.d.ts.map +1 -1
  57. package/build/legacy/useMutationState.cjs +6 -6
  58. package/build/legacy/useMutationState.cjs.map +1 -1
  59. package/build/legacy/useMutationState.d.cts +2 -3
  60. package/build/legacy/useMutationState.d.cts.map +1 -1
  61. package/build/legacy/useMutationState.d.ts +2 -3
  62. package/build/legacy/useMutationState.d.ts.map +1 -1
  63. package/build/legacy/useMutationState.js +6 -6
  64. package/build/legacy/useMutationState.js.map +1 -1
  65. package/build/legacy/usePrefetchInfiniteQuery.d.cts +1 -2
  66. package/build/legacy/usePrefetchInfiniteQuery.d.cts.map +1 -1
  67. package/build/legacy/usePrefetchInfiniteQuery.d.ts +1 -2
  68. package/build/legacy/usePrefetchInfiniteQuery.d.ts.map +1 -1
  69. package/build/legacy/usePrefetchQuery.d.cts +1 -2
  70. package/build/legacy/usePrefetchQuery.d.cts.map +1 -1
  71. package/build/legacy/usePrefetchQuery.d.ts +1 -2
  72. package/build/legacy/usePrefetchQuery.d.ts.map +1 -1
  73. package/build/legacy/useQueries.d.cts +3 -4
  74. package/build/legacy/useQueries.d.cts.map +1 -1
  75. package/build/legacy/useQueries.d.ts +3 -4
  76. package/build/legacy/useQueries.d.ts.map +1 -1
  77. package/build/legacy/useQuery.d.cts +3 -4
  78. package/build/legacy/useQuery.d.cts.map +1 -1
  79. package/build/legacy/useQuery.d.ts +3 -4
  80. package/build/legacy/useQuery.d.ts.map +1 -1
  81. package/build/legacy/useSuspenseInfiniteQuery.d.cts +1 -2
  82. package/build/legacy/useSuspenseInfiniteQuery.d.cts.map +1 -1
  83. package/build/legacy/useSuspenseInfiniteQuery.d.ts +1 -2
  84. package/build/legacy/useSuspenseInfiniteQuery.d.ts.map +1 -1
  85. package/build/legacy/useSuspenseQueries.d.cts +4 -5
  86. package/build/legacy/useSuspenseQueries.d.cts.map +1 -1
  87. package/build/legacy/useSuspenseQueries.d.ts +4 -5
  88. package/build/legacy/useSuspenseQueries.d.ts.map +1 -1
  89. package/build/legacy/useSuspenseQuery.d.cts +1 -2
  90. package/build/legacy/useSuspenseQuery.d.cts.map +1 -1
  91. package/build/legacy/useSuspenseQuery.d.ts +1 -2
  92. package/build/legacy/useSuspenseQuery.d.ts.map +1 -1
  93. package/build/modern/HydrationBoundary.d.cts +2 -3
  94. package/build/modern/HydrationBoundary.d.cts.map +1 -1
  95. package/build/modern/HydrationBoundary.d.ts +2 -3
  96. package/build/modern/HydrationBoundary.d.ts.map +1 -1
  97. package/build/modern/IsRestoringProvider.d.cts +2 -3
  98. package/build/modern/IsRestoringProvider.d.cts.map +1 -1
  99. package/build/modern/IsRestoringProvider.d.ts +2 -3
  100. package/build/modern/IsRestoringProvider.d.ts.map +1 -1
  101. package/build/modern/QueryClientProvider.d.cts +4 -5
  102. package/build/modern/QueryClientProvider.d.cts.map +1 -1
  103. package/build/modern/QueryClientProvider.d.ts +4 -5
  104. package/build/modern/QueryClientProvider.d.ts.map +1 -1
  105. package/build/modern/QueryErrorResetBoundary.d.cts +8 -9
  106. package/build/modern/QueryErrorResetBoundary.d.cts.map +1 -1
  107. package/build/modern/QueryErrorResetBoundary.d.ts +8 -9
  108. package/build/modern/QueryErrorResetBoundary.d.ts.map +1 -1
  109. package/build/modern/errorBoundaryUtils.d.cts +3 -4
  110. package/build/modern/errorBoundaryUtils.d.cts.map +1 -1
  111. package/build/modern/errorBoundaryUtils.d.ts +3 -4
  112. package/build/modern/errorBoundaryUtils.d.ts.map +1 -1
  113. package/build/modern/infiniteQueryOptions.d.cts +6 -7
  114. package/build/modern/infiniteQueryOptions.d.cts.map +1 -1
  115. package/build/modern/infiniteQueryOptions.d.ts +6 -7
  116. package/build/modern/infiniteQueryOptions.d.ts.map +1 -1
  117. package/build/modern/mutationOptions.d.cts +2 -3
  118. package/build/modern/mutationOptions.d.cts.map +1 -1
  119. package/build/modern/mutationOptions.d.ts +2 -3
  120. package/build/modern/mutationOptions.d.ts.map +1 -1
  121. package/build/modern/queryOptions.d.cts +6 -7
  122. package/build/modern/queryOptions.d.cts.map +1 -1
  123. package/build/modern/queryOptions.d.ts +6 -7
  124. package/build/modern/queryOptions.d.ts.map +1 -1
  125. package/build/modern/suspense.d.cts +4 -5
  126. package/build/modern/suspense.d.cts.map +1 -1
  127. package/build/modern/suspense.d.ts +4 -5
  128. package/build/modern/suspense.d.ts.map +1 -1
  129. package/build/modern/types.d.cts +25 -26
  130. package/build/modern/types.d.cts.map +1 -1
  131. package/build/modern/types.d.ts +25 -26
  132. package/build/modern/types.d.ts.map +1 -1
  133. package/build/modern/useBaseQuery.d.cts +1 -2
  134. package/build/modern/useBaseQuery.d.cts.map +1 -1
  135. package/build/modern/useBaseQuery.d.ts +1 -2
  136. package/build/modern/useBaseQuery.d.ts.map +1 -1
  137. package/build/modern/useInfiniteQuery.d.cts +3 -4
  138. package/build/modern/useInfiniteQuery.d.cts.map +1 -1
  139. package/build/modern/useInfiniteQuery.d.ts +3 -4
  140. package/build/modern/useInfiniteQuery.d.ts.map +1 -1
  141. package/build/modern/useIsFetching.d.cts +1 -2
  142. package/build/modern/useIsFetching.d.cts.map +1 -1
  143. package/build/modern/useIsFetching.d.ts +1 -2
  144. package/build/modern/useIsFetching.d.ts.map +1 -1
  145. package/build/modern/useMutation.d.cts +1 -2
  146. package/build/modern/useMutation.d.cts.map +1 -1
  147. package/build/modern/useMutation.d.ts +1 -2
  148. package/build/modern/useMutation.d.ts.map +1 -1
  149. package/build/modern/useMutationState.cjs +6 -6
  150. package/build/modern/useMutationState.cjs.map +1 -1
  151. package/build/modern/useMutationState.d.cts +2 -3
  152. package/build/modern/useMutationState.d.cts.map +1 -1
  153. package/build/modern/useMutationState.d.ts +2 -3
  154. package/build/modern/useMutationState.d.ts.map +1 -1
  155. package/build/modern/useMutationState.js +6 -6
  156. package/build/modern/useMutationState.js.map +1 -1
  157. package/build/modern/usePrefetchInfiniteQuery.d.cts +1 -2
  158. package/build/modern/usePrefetchInfiniteQuery.d.cts.map +1 -1
  159. package/build/modern/usePrefetchInfiniteQuery.d.ts +1 -2
  160. package/build/modern/usePrefetchInfiniteQuery.d.ts.map +1 -1
  161. package/build/modern/usePrefetchQuery.d.cts +1 -2
  162. package/build/modern/usePrefetchQuery.d.cts.map +1 -1
  163. package/build/modern/usePrefetchQuery.d.ts +1 -2
  164. package/build/modern/usePrefetchQuery.d.ts.map +1 -1
  165. package/build/modern/useQueries.d.cts +3 -4
  166. package/build/modern/useQueries.d.cts.map +1 -1
  167. package/build/modern/useQueries.d.ts +3 -4
  168. package/build/modern/useQueries.d.ts.map +1 -1
  169. package/build/modern/useQuery.d.cts +3 -4
  170. package/build/modern/useQuery.d.cts.map +1 -1
  171. package/build/modern/useQuery.d.ts +3 -4
  172. package/build/modern/useQuery.d.ts.map +1 -1
  173. package/build/modern/useSuspenseInfiniteQuery.d.cts +1 -2
  174. package/build/modern/useSuspenseInfiniteQuery.d.cts.map +1 -1
  175. package/build/modern/useSuspenseInfiniteQuery.d.ts +1 -2
  176. package/build/modern/useSuspenseInfiniteQuery.d.ts.map +1 -1
  177. package/build/modern/useSuspenseQueries.d.cts +4 -5
  178. package/build/modern/useSuspenseQueries.d.cts.map +1 -1
  179. package/build/modern/useSuspenseQueries.d.ts +4 -5
  180. package/build/modern/useSuspenseQueries.d.ts.map +1 -1
  181. package/build/modern/useSuspenseQuery.d.cts +1 -2
  182. package/build/modern/useSuspenseQuery.d.cts.map +1 -1
  183. package/build/modern/useSuspenseQuery.d.ts +1 -2
  184. package/build/modern/useSuspenseQuery.d.ts.map +1 -1
  185. package/package.json +9 -7
  186. package/src/useMutationState.ts +8 -8
@@ -4,7 +4,7 @@ import { DefaultError, DefinedInfiniteQueryObserverResult, DefinedQueryObserverR
4
4
  * {@link UseBaseQueryOptions} with all type parameters set to `any`, useful when the specific types aren't
5
5
  * relevant, e.g. when accepting options for any query in a helper function.
6
6
  */
7
- type AnyUseBaseQueryOptions = UseBaseQueryOptions<any, any, any, any, any>;
7
+ export type AnyUseBaseQueryOptions = UseBaseQueryOptions<any, any, any, any, any>;
8
8
  /**
9
9
  * The options shared by `useQuery` and `useSuspenseQuery`. Extends {@link QueryObserverOptions} from
10
10
  * `@tanstack/query-core` with the `react-query`-specific `subscribed` option.
@@ -17,7 +17,7 @@ type AnyUseBaseQueryOptions = UseBaseQueryOptions<any, any, any, any, any>;
17
17
  * `placeholderData`. Defaults to, and is usually the same as, `TQueryFnData`.
18
18
  * @template TQueryKey - The type of your `queryKey`.
19
19
  */
20
- interface UseBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {
20
+ export interface UseBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {
21
21
  /**
22
22
  * Set this to `false` to unsubscribe this observer from updates to the query cache.
23
23
  *
@@ -37,7 +37,7 @@ interface UseBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TDa
37
37
  * `placeholderData`. Defaults to, and is usually the same as, `TQueryFnData`.
38
38
  * @template TQueryKey - The type of your `queryKey`.
39
39
  */
40
- type UsePrefetchQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = DistributiveOmit<QueryExecuteOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'queryFn'> & {
40
+ export type UsePrefetchQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = DistributiveOmit<QueryExecuteOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'queryFn'> & {
41
41
  /**
42
42
  * `skipToken` is not allowed as a value here — a prefetch always needs a query function to actually run,
43
43
  * unless a default query function has been defined.
@@ -56,7 +56,7 @@ type UsePrefetchQueryOptions<TQueryFnData = unknown, TError = DefaultError, TDat
56
56
  * @template TQueryKey - The type of your `queryKey`.
57
57
  * @template TPageParam - The type of the parameter passed to `queryFn` to fetch a given page.
58
58
  */
59
- type UsePrefetchInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = DistributiveOmit<InfiniteQueryExecuteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn'> & {
59
+ export type UsePrefetchInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = DistributiveOmit<InfiniteQueryExecuteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn'> & {
60
60
  /**
61
61
  * `skipToken` is not allowed as a value here — a prefetch always needs a query function to actually run,
62
62
  * unless a default query function has been defined.
@@ -67,7 +67,7 @@ type UsePrefetchInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultErr
67
67
  * {@link UseQueryOptions} with all type parameters set to `any`, useful when the specific types aren't
68
68
  * relevant, e.g. when accepting options for any query in a helper function.
69
69
  */
70
- type AnyUseQueryOptions = UseQueryOptions<any, any, any, any>;
70
+ export type AnyUseQueryOptions = UseQueryOptions<any, any, any, any>;
71
71
  /**
72
72
  * The options accepted by `useQuery`. Same as {@link UseBaseQueryOptions}, minus `suspense` (which
73
73
  * `react-query` derives from which hook you call rather than exposing as an option).
@@ -78,12 +78,12 @@ type AnyUseQueryOptions = UseQueryOptions<any, any, any, any>;
78
78
  * `select` is used.
79
79
  * @template TQueryKey - The type of your `queryKey`.
80
80
  */
81
- interface UseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'suspense'> {}
81
+ export interface UseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'suspense'> {}
82
82
  /**
83
83
  * {@link UseSuspenseQueryOptions} with all type parameters set to `any`, useful when the specific types aren't
84
84
  * relevant, e.g. when accepting options for any query in a helper function.
85
85
  */
86
- type AnyUseSuspenseQueryOptions = UseSuspenseQueryOptions<any, any, any, any>;
86
+ export type AnyUseSuspenseQueryOptions = UseSuspenseQueryOptions<any, any, any, any>;
87
87
  /**
88
88
  * The options accepted by `useSuspenseQuery`. Same as {@link UseQueryOptions}, minus `enabled`, `throwOnError`,
89
89
  * and `placeholderData` — Suspense hooks cannot render a "disabled" or "placeholder" state, so those options
@@ -95,7 +95,7 @@ type AnyUseSuspenseQueryOptions = UseSuspenseQueryOptions<any, any, any, any>;
95
95
  * `select` is used.
96
96
  * @template TQueryKey - The type of your `queryKey`.
97
97
  */
98
- interface UseSuspenseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn' | 'enabled' | 'throwOnError' | 'placeholderData'> {
98
+ export interface UseSuspenseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn' | 'enabled' | 'throwOnError' | 'placeholderData'> {
99
99
  /**
100
100
  * `skipToken` is not allowed here — Suspense hooks cannot render a "disabled" state, so a query function
101
101
  * must always be provided, unless a default query function has been defined.
@@ -106,7 +106,7 @@ interface UseSuspenseQueryOptions<TQueryFnData = unknown, TError = DefaultError,
106
106
  * {@link UseInfiniteQueryOptions} with all type parameters set to `any`, useful when the specific types aren't
107
107
  * relevant, e.g. when accepting options for any query in a helper function.
108
108
  */
109
- type AnyUseInfiniteQueryOptions = UseInfiniteQueryOptions<any, any, any, any, any>;
109
+ export type AnyUseInfiniteQueryOptions = UseInfiniteQueryOptions<any, any, any, any, any>;
110
110
  /**
111
111
  * The options accepted by `useInfiniteQuery`. Extends {@link InfiniteQueryObserverOptions} from
112
112
  * `@tanstack/query-core` with the `react-query`-specific `subscribed` option, minus `suspense` (which
@@ -119,7 +119,7 @@ type AnyUseInfiniteQueryOptions = UseInfiniteQueryOptions<any, any, any, any, an
119
119
  * @template TQueryKey - The type of your `queryKey`.
120
120
  * @template TPageParam - The type of the parameter passed to `queryFn` to fetch a given page.
121
121
  */
122
- interface UseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'suspense'> {
122
+ export interface UseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'suspense'> {
123
123
  /**
124
124
  * Set this to `false` to unsubscribe this observer from updates to the query cache.
125
125
  *
@@ -131,7 +131,7 @@ interface UseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError,
131
131
  * {@link UseSuspenseInfiniteQueryOptions} with all type parameters set to `any`, useful when the specific types
132
132
  * aren't relevant, e.g. when accepting options for any query in a helper function.
133
133
  */
134
- type AnyUseSuspenseInfiniteQueryOptions = UseSuspenseInfiniteQueryOptions<any, any, any, any, any>;
134
+ export type AnyUseSuspenseInfiniteQueryOptions = UseSuspenseInfiniteQueryOptions<any, any, any, any, any>;
135
135
  /**
136
136
  * The options accepted by `useSuspenseInfiniteQuery`. Same as {@link UseInfiniteQueryOptions}, minus `enabled`,
137
137
  * `throwOnError`, and `placeholderData` — Suspense hooks cannot render a "disabled" or "placeholder" state, so
@@ -144,7 +144,7 @@ type AnyUseSuspenseInfiniteQueryOptions = UseSuspenseInfiniteQueryOptions<any, a
144
144
  * @template TQueryKey - The type of your `queryKey`.
145
145
  * @template TPageParam - The type of the parameter passed to `queryFn` to fetch a given page.
146
146
  */
147
- interface UseSuspenseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn' | 'enabled' | 'throwOnError' | 'placeholderData'> {
147
+ export interface UseSuspenseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn' | 'enabled' | 'throwOnError' | 'placeholderData'> {
148
148
  /**
149
149
  * `skipToken` is not allowed here — Suspense hooks cannot render a "disabled" state, so a query function
150
150
  * must always be provided, unless a default query function has been defined.
@@ -159,14 +159,14 @@ interface UseSuspenseInfiniteQueryOptions<TQueryFnData = unknown, TError = Defau
159
159
  * @template TData - The type `data` ends up as after `select` runs.
160
160
  * @template TError - The type of errors your `queryFn` may throw.
161
161
  */
162
- type UseBaseQueryResult<TData = unknown, TError = DefaultError> = QueryObserverResult<TData, TError>;
162
+ export type UseBaseQueryResult<TData = unknown, TError = DefaultError> = QueryObserverResult<TData, TError>;
163
163
  /**
164
164
  * The result of `useQuery`. Same as {@link UseBaseQueryResult}.
165
165
  *
166
166
  * @template TData - The type `data` ends up as after `select` runs.
167
167
  * @template TError - The type of errors your `queryFn` may throw.
168
168
  */
169
- type UseQueryResult<TData = unknown, TError = DefaultError> = UseBaseQueryResult<TData, TError>;
169
+ export type UseQueryResult<TData = unknown, TError = DefaultError> = UseBaseQueryResult<TData, TError>;
170
170
  /**
171
171
  * The result of `useSuspenseQuery`. Same as {@link DefinedUseQueryResult}, minus `isPlaceholderData` — always
172
172
  * `false` on that type, so this drops the dead field rather than an active state.
@@ -174,7 +174,7 @@ type UseQueryResult<TData = unknown, TError = DefaultError> = UseBaseQueryResult
174
174
  * @template TData - The type `data` ends up as after `select` runs.
175
175
  * @template TError - The type of errors your `queryFn` may throw.
176
176
  */
177
- type UseSuspenseQueryResult<TData = unknown, TError = DefaultError> = DistributiveOmit<DefinedQueryObserverResult<TData, TError>, 'isPlaceholderData'>;
177
+ export type UseSuspenseQueryResult<TData = unknown, TError = DefaultError> = DistributiveOmit<DefinedQueryObserverResult<TData, TError>, 'isPlaceholderData'>;
178
178
  /**
179
179
  * The result of `useQuery` when `initialData` is set, or of `useSuspenseQuery` before the `isPlaceholderData`
180
180
  * omission — `data` is never `undefined` (unless a `select` changes `TData` to include `undefined`).
@@ -183,7 +183,7 @@ type UseSuspenseQueryResult<TData = unknown, TError = DefaultError> = Distributi
183
183
  * @template TData - The type `data` ends up as after `select` runs.
184
184
  * @template TError - The type of errors your `queryFn` may throw.
185
185
  */
186
- type DefinedUseQueryResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError>;
186
+ export type DefinedUseQueryResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError>;
187
187
  /**
188
188
  * The result of `useInfiniteQuery` when `initialData` isn't set — `data` may be `undefined` while the query is
189
189
  * `pending`. Re-exports {@link InfiniteQueryObserverResult} from `@tanstack/query-core`.
@@ -191,7 +191,7 @@ type DefinedUseQueryResult<TData = unknown, TError = DefaultError> = DefinedQuer
191
191
  * @template TData - The type `data` ends up as after `select` runs.
192
192
  * @template TError - The type of errors your `queryFn` may throw.
193
193
  */
194
- type UseInfiniteQueryResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverResult<TData, TError>;
194
+ export type UseInfiniteQueryResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverResult<TData, TError>;
195
195
  /**
196
196
  * The result of `useInfiniteQuery` when `initialData` is set — `data` is never `undefined` (unless a
197
197
  * `select` changes `TData` to include `undefined`). Re-exports {@link DefinedInfiniteQueryObserverResult}
@@ -200,7 +200,7 @@ type UseInfiniteQueryResult<TData = unknown, TError = DefaultError> = InfiniteQu
200
200
  * @template TData - The type `data` ends up as after `select` runs.
201
201
  * @template TError - The type of errors your `queryFn` may throw.
202
202
  */
203
- type DefinedUseInfiniteQueryResult<TData = unknown, TError = DefaultError> = DefinedInfiniteQueryObserverResult<TData, TError>;
203
+ export type DefinedUseInfiniteQueryResult<TData = unknown, TError = DefaultError> = DefinedInfiniteQueryObserverResult<TData, TError>;
204
204
  /**
205
205
  * The result of `useSuspenseInfiniteQuery`. Same as {@link DefinedUseInfiniteQueryResult}, minus
206
206
  * `isPlaceholderData` — Suspense hooks never render placeholder data.
@@ -208,12 +208,12 @@ type DefinedUseInfiniteQueryResult<TData = unknown, TError = DefaultError> = Def
208
208
  * @template TData - The type `data` ends up as after `select` runs.
209
209
  * @template TError - The type of errors your `queryFn` may throw.
210
210
  */
211
- type UseSuspenseInfiniteQueryResult<TData = unknown, TError = DefaultError> = OmitKeyof<DefinedInfiniteQueryObserverResult<TData, TError>, 'isPlaceholderData'>;
211
+ export type UseSuspenseInfiniteQueryResult<TData = unknown, TError = DefaultError> = OmitKeyof<DefinedInfiniteQueryObserverResult<TData, TError>, 'isPlaceholderData'>;
212
212
  /**
213
213
  * {@link UseMutationOptions} with all type parameters set to `any`, useful when the specific types aren't
214
214
  * relevant, e.g. when accepting options for any mutation in a helper function.
215
215
  */
216
- type AnyUseMutationOptions = UseMutationOptions<any, any, any, any>;
216
+ export type AnyUseMutationOptions = UseMutationOptions<any, any, any, any>;
217
217
  /**
218
218
  * The options accepted by `useMutation`. Same as {@link MutationObserverOptions} from `@tanstack/query-core`,
219
219
  * minus the internal `_defaulted` flag.
@@ -224,7 +224,7 @@ type AnyUseMutationOptions = UseMutationOptions<any, any, any, any>;
224
224
  * @template TOnMutateResult - The type returned by `onMutate`, passed to `onSuccess`/`onError`/`onSettled` as
225
225
  * their `onMutateResult` parameter — useful for optimistic-update rollback data.
226
226
  */
227
- interface UseMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>, '_defaulted'> {}
227
+ export interface UseMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>, '_defaulted'> {}
228
228
  /**
229
229
  * The type of `mutate`, as returned by `useMutation`. Forwards the variables (and an optional per-call
230
230
  * `onSuccess`/`onError`/`onSettled`) to the underlying `mutate` call. Fire-and-forget — errors are surfaced
@@ -236,7 +236,7 @@ interface UseMutationOptions<TData = unknown, TError = DefaultError, TVariables
236
236
  * @template TOnMutateResult - The type returned by `onMutate`, passed to `onSuccess`/`onError`/`onSettled` as
237
237
  * their `onMutateResult` parameter — useful for optimistic-update rollback data.
238
238
  */
239
- type UseMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TOnMutateResult>>) => void;
239
+ export type UseMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TOnMutateResult>>) => void;
240
240
  /**
241
241
  * The type of `mutateAsync`, as returned by `useMutation`. Similar to {@link UseMutateFunction}, but returns a
242
242
  * promise which can be awaited.
@@ -247,7 +247,7 @@ type UseMutateFunction<TData = unknown, TError = DefaultError, TVariables = void
247
247
  * @template TOnMutateResult - The type returned by `onMutate`, passed to `onSuccess`/`onError`/`onSettled` as
248
248
  * their `onMutateResult` parameter — useful for optimistic-update rollback data.
249
249
  */
250
- type UseMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = MutateFunction<TData, TError, TVariables, TOnMutateResult>;
250
+ export type UseMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = MutateFunction<TData, TError, TVariables, TOnMutateResult>;
251
251
  /**
252
252
  * The result of `useMutation`. Same as {@link MutationObserverResult} from `@tanstack/query-core`, with
253
253
  * `mutate` narrowed to the fire-and-forget {@link UseMutateFunction} signature, plus the added `mutateAsync`.
@@ -258,7 +258,7 @@ type UseMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables =
258
258
  * @template TOnMutateResult - The type returned by `onMutate`, passed to `onSuccess`/`onError`/`onSettled` as
259
259
  * their `onMutateResult` parameter — useful for optimistic-update rollback data.
260
260
  */
261
- type UseBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TOnMutateResult>, {
261
+ export type UseBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TOnMutateResult>, {
262
262
  mutate: UseMutateFunction<TData, TError, TVariables, TOnMutateResult>;
263
263
  }> & {
264
264
  /**
@@ -275,7 +275,6 @@ type UseBaseMutationResult<TData = unknown, TError = DefaultError, TVariables =
275
275
  * @template TOnMutateResult - The type returned by `onMutate`, passed to `onSuccess`/`onError`/`onSettled` as
276
276
  * their `onMutateResult` parameter — useful for optimistic-update rollback data.
277
277
  */
278
- type UseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = UseBaseMutationResult<TData, TError, TVariables, TOnMutateResult>;
278
+ export type UseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = UseBaseMutationResult<TData, TError, TVariables, TOnMutateResult>;
279
279
  //#endregion
280
- export { AnyUseBaseQueryOptions, AnyUseInfiniteQueryOptions, AnyUseMutationOptions, AnyUseQueryOptions, AnyUseSuspenseInfiniteQueryOptions, AnyUseSuspenseQueryOptions, DefinedUseInfiniteQueryResult, DefinedUseQueryResult, UseBaseMutationResult, UseBaseQueryOptions, UseBaseQueryResult, UseInfiniteQueryOptions, UseInfiniteQueryResult, UseMutateAsyncFunction, UseMutateFunction, UseMutationOptions, UseMutationResult, UsePrefetchInfiniteQueryOptions, UsePrefetchQueryOptions, UseQueryOptions, UseQueryResult, UseSuspenseInfiniteQueryOptions, UseSuspenseInfiniteQueryResult, UseSuspenseQueryOptions, UseSuspenseQueryResult };
281
280
  //# sourceMappingURL=types.d.ts.map
@@ -1 +1 @@
1
- {"version":3,"file":"types.d.ts","names":[],"sources":["../../src/types.ts"],"mappings":";;;;;;KA2BY,yBAAyB;;;;;;;;;;;;;UAmBpB,oBACf,wBACA,SAAS,cACT,QAAQ,cACR,aAAa,cACb,kBAAkB,WAAW,kBACrB,qBACR,cACA,QACA,OACA,YACA;;;;;;EAOA;;;;;;;;;;;;;;KAeU,wBACV,wBACA,SAAS,cACT,QAAQ,cACR,aAAa,cACb,kBAAkB,WAAW,YAC3B,iBACF,oBAAoB,cAAc,QAAQ,OAAO,YAAY;;;;;EAO7D,UAAU,QACR,oBACE,cACA,QACA,OACA,YACA,uBAEF;;;;;;;;;;;;;;KAgBQ,gCACV,wBACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,iBACF,4BACE,cACA,QACA,OACA,WACA;;;;;EAQF,UAAU,QACR,4BACE,cACA,QACA,OACA,WACA,wBAEF;;;;;;KAQQ,qBAAqB;;;;;;;;;;;UAWhB,gBACf,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,kBACrB,UACR,oBAAoB,cAAc,QAAQ,OAAO,cAAc;;;;;KAQrD,6BAA6B;;;;;;;;;;;;UAiBxB,wBACf,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,kBACrB,UACR,gBAAgB,cAAc,QAAQ,OAAO;;;;;EAO7C,UAAU,QACR,gBAAgB,cAAc,QAAQ,OAAO,uBAC7C;;;;;;KAQQ,6BAA6B;;;;;;;;;;;;;UAmBxB,wBACf,wBACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,8BACQ,UACR,6BACE,cACA,QACA,OACA,WACA;;;;;;EASF;;;;;;KAOU,qCACV;;;;;;;;;;;;;UAae,gCACf,wBACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,8BACQ,UACR,wBAAwB,cAAc,QAAQ,OAAO,WAAW;;;;;EAOhE,UAAU,QACR,wBACE,cACA,QACA,OACA,WACA,wBAEF;;;;;;;;;;KAYQ,mBACV,iBACA,SAAS,gBACP,oBAAoB,OAAO;;;;;;;KAQnB,eACV,iBACA,SAAS,gBACP,mBAAmB,OAAO;;;;;;;;KASlB,uBACV,iBACA,SAAS,gBACP,iBACF,2BAA2B,OAAO;;;;;;;;;KAYxB,sBACV,iBACA,SAAS,gBACP,2BAA2B,OAAO;;;;;;;;KAS1B,uBACV,iBACA,SAAS,gBACP,4BAA4B,OAAO;;;;;;;;;KAU3B,8BACV,iBACA,SAAS,gBACP,mCAAmC,OAAO;;;;;;;;KASlC,+BACV,iBACA,SAAS,gBACP,UACF,mCAAmC,OAAO;;;;;KAQhC,wBAAwB;;;;;;;;;;;UAWnB,mBACf,iBACA,SAAS,cACT,mBACA,mCACQ,UACR,wBAAwB,OAAO,QAAQ,YAAY;;;;;;;;;;;;KAezC,kBACV,iBACA,SAAS,cACT,mBACA,iCAEG,MAAM,WACP,eAAe,OAAO,QAAQ,YAAY;;;;;;;;;;;KAclC,uBACV,iBACA,SAAS,cACT,mBACA,6BACE,eAAe,OAAO,QAAQ,YAAY;;;;;;;;;;;KAYlC,sBACV,iBACA,SAAS,cACT,sBACA,6BACE,SACF,uBAAuB,OAAO,QAAQ,YAAY;EAChD,QAAQ,kBAAkB,OAAO,QAAQ,YAAY;;;;;EAKvD,aAAa,uBACX,OACA,QACA,YACA;;;;;;;;;;;KAaQ,kBACV,iBACA,SAAS,cACT,sBACA,6BACE,sBAAsB,OAAO,QAAQ,YAAY"}
1
+ {"version":3,"file":"types.d.ts","names":[],"sources":["../../src/types.ts"],"mappings":";;;;;;YA2BY,yBAAyB;;;;;;;;;;;;;iBAmBpB,oBACf,wBACA,SAAS,cACT,QAAQ,cACR,aAAa,cACb,kBAAkB,WAAW,kBACrB,qBACR,cACA,QACA,OACA,YACA;;;;;;EAOA;;;;;;;;;;;;;;YAeU,wBACV,wBACA,SAAS,cACT,QAAQ,cACR,aAAa,cACb,kBAAkB,WAAW,YAC3B,iBACF,oBAAoB,cAAc,QAAQ,OAAO,YAAY;;;;;EAO7D,UAAU,QACR,oBACE,cACA,QACA,OACA,YACA,uBAEF;;;;;;;;;;;;;;YAgBQ,gCACV,wBACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,iBACF,4BACE,cACA,QACA,OACA,WACA;;;;;EAQF,UAAU,QACR,4BACE,cACA,QACA,OACA,WACA,wBAEF;;;;;;YAQQ,qBAAqB;;;;;;;;;;;iBAWhB,gBACf,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,kBACrB,UACR,oBAAoB,cAAc,QAAQ,OAAO,cAAc;;;;;YAQrD,6BAA6B;;;;;;;;;;;;iBAiBxB,wBACf,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,kBACrB,UACR,gBAAgB,cAAc,QAAQ,OAAO;;;;;EAO7C,UAAU,QACR,gBAAgB,cAAc,QAAQ,OAAO,uBAC7C;;;;;;YAQQ,6BAA6B;;;;;;;;;;;;;iBAmBxB,wBACf,wBACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,8BACQ,UACR,6BACE,cACA,QACA,OACA,WACA;;;;;;EASF;;;;;;YAOU,qCACV;;;;;;;;;;;;;iBAae,gCACf,wBACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,8BACQ,UACR,wBAAwB,cAAc,QAAQ,OAAO,WAAW;;;;;EAOhE,UAAU,QACR,wBACE,cACA,QACA,OACA,WACA,wBAEF;;;;;;;;;;YAYQ,mBACV,iBACA,SAAS,gBACP,oBAAoB,OAAO;;;;;;;YAQnB,eACV,iBACA,SAAS,gBACP,mBAAmB,OAAO;;;;;;;;YASlB,uBACV,iBACA,SAAS,gBACP,iBACF,2BAA2B,OAAO;;;;;;;;;YAYxB,sBACV,iBACA,SAAS,gBACP,2BAA2B,OAAO;;;;;;;;YAS1B,uBACV,iBACA,SAAS,gBACP,4BAA4B,OAAO;;;;;;;;;YAU3B,8BACV,iBACA,SAAS,gBACP,mCAAmC,OAAO;;;;;;;;YASlC,+BACV,iBACA,SAAS,gBACP,UACF,mCAAmC,OAAO;;;;;YAQhC,wBAAwB;;;;;;;;;;;iBAWnB,mBACf,iBACA,SAAS,cACT,mBACA,mCACQ,UACR,wBAAwB,OAAO,QAAQ,YAAY;;;;;;;;;;;;YAezC,kBACV,iBACA,SAAS,cACT,mBACA,iCAEG,MAAM,WACP,eAAe,OAAO,QAAQ,YAAY;;;;;;;;;;;YAclC,uBACV,iBACA,SAAS,cACT,mBACA,6BACE,eAAe,OAAO,QAAQ,YAAY;;;;;;;;;;;YAYlC,sBACV,iBACA,SAAS,cACT,sBACA,6BACE,SACF,uBAAuB,OAAO,QAAQ,YAAY;EAChD,QAAQ,kBAAkB,OAAO,QAAQ,YAAY;;;;;EAKvD,aAAa,uBACX,OACA,QACA,YACA;;;;;;;;;;;YAaQ,kBACV,iBACA,SAAS,cACT,sBACA,6BACE,sBAAsB,OAAO,QAAQ,YAAY"}
@@ -1,7 +1,6 @@
1
1
  import { UseBaseQueryOptions } from "./types.cjs";
2
2
  import { QueryClient, QueryKey, QueryObserver, QueryObserverResult } from "@tanstack/query-core";
3
3
  //#region src/useBaseQuery.d.ts
4
- declare function useBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, Observer: typeof QueryObserver, queryClient?: QueryClient): QueryObserverResult<TData, TError>;
4
+ export declare function useBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, Observer: typeof QueryObserver, queryClient?: QueryClient): QueryObserverResult<TData, TError>;
5
5
  //#endregion
6
- export { useBaseQuery };
7
6
  //# sourceMappingURL=useBaseQuery.d.cts.map
@@ -1 +1 @@
1
- {"version":3,"file":"useBaseQuery.d.cts","names":[],"sources":["../../src/useBaseQuery.ts"],"mappings":";;;iBAyBgB,aACd,cACA,QACA,OACA,YACA,kBAAkB,UAElB,SAAS,oBACP,cACA,QACA,OACA,YACA,YAEF,iBAAiB,eACjB,cAAc,cACb,oBAAoB,OAAO"}
1
+ {"version":3,"file":"useBaseQuery.d.cts","names":[],"sources":["../../src/useBaseQuery.ts"],"mappings":";;;wBAyBgB,aACd,cACA,QACA,OACA,YACA,kBAAkB,UAElB,SAAS,oBACP,cACA,QACA,OACA,YACA,YAEF,iBAAiB,eACjB,cAAc,cACb,oBAAoB,OAAO"}
@@ -1,7 +1,6 @@
1
1
  import { UseBaseQueryOptions } from "./types.js";
2
2
  import { QueryClient, QueryKey, QueryObserver, QueryObserverResult } from "@tanstack/query-core";
3
3
  //#region src/useBaseQuery.d.ts
4
- declare function useBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, Observer: typeof QueryObserver, queryClient?: QueryClient): QueryObserverResult<TData, TError>;
4
+ export declare function useBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, Observer: typeof QueryObserver, queryClient?: QueryClient): QueryObserverResult<TData, TError>;
5
5
  //#endregion
6
- export { useBaseQuery };
7
6
  //# sourceMappingURL=useBaseQuery.d.ts.map
@@ -1 +1 @@
1
- {"version":3,"file":"useBaseQuery.d.ts","names":[],"sources":["../../src/useBaseQuery.ts"],"mappings":";;;iBAyBgB,aACd,cACA,QACA,OACA,YACA,kBAAkB,UAElB,SAAS,oBACP,cACA,QACA,OACA,YACA,YAEF,iBAAiB,eACjB,cAAc,cACb,oBAAoB,OAAO"}
1
+ {"version":3,"file":"useBaseQuery.d.ts","names":[],"sources":["../../src/useBaseQuery.ts"],"mappings":";;;wBAyBgB,aACd,cACA,QACA,OACA,YACA,kBAAkB,UAElB,SAAS,oBACP,cACA,QACA,OACA,YACA,YAEF,iBAAiB,eACjB,cAAc,cACb,oBAAoB,OAAO"}
@@ -46,7 +46,7 @@ import { DefaultError, InfiniteData, QueryClient, QueryKey } from "@tanstack/que
46
46
  * }
47
47
  * ```
48
48
  */
49
- declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): DefinedUseInfiniteQueryResult<TData, TError>;
49
+ export declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): DefinedUseInfiniteQueryResult<TData, TError>;
50
50
  /**
51
51
  * The options for `useInfiniteQuery` are identical to `useQuery`, with the addition of
52
52
  * `initialPageParam`, `getNextPageParam`, `getPreviousPageParam`, and `maxPages`.
@@ -156,7 +156,7 @@ declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = I
156
156
  * }
157
157
  * ```
158
158
  */
159
- declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseInfiniteQueryResult<TData, TError>;
159
+ export declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseInfiniteQueryResult<TData, TError>;
160
160
  /**
161
161
  * The options for `useInfiniteQuery` are identical to `useQuery`, with the addition of
162
162
  * `initialPageParam`, `getNextPageParam`, `getPreviousPageParam`, and `maxPages`.
@@ -296,7 +296,6 @@ declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = I
296
296
  * }
297
297
  * ```
298
298
  */
299
- declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseInfiniteQueryResult<TData, TError>;
299
+ export declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseInfiniteQueryResult<TData, TError>;
300
300
  //#endregion
301
- export { useInfiniteQuery };
302
301
  //# sourceMappingURL=useInfiniteQuery.d.cts.map
@@ -1 +1 @@
1
- {"version":3,"file":"useInfiniteQuery.d.cts","names":[],"sources":["../../src/useInfiniteQuery.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgEgB,iBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,kCACP,cACA,QACA,OACA,WACA,aAEF,cAAc,cACb,8BAA8B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+GxB,iBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,oCACP,cACA,QACA,OACA,WACA,aAEF,cAAc,cACb,uBAAuB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6IjB,iBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,wBACP,cACA,QACA,OACA,WACA,aAEF,cAAc,cACb,uBAAuB,OAAO"}
1
+ {"version":3,"file":"useInfiniteQuery.d.cts","names":[],"sources":["../../src/useInfiniteQuery.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAgEgB,iBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,kCACP,cACA,QACA,OACA,WACA,aAEF,cAAc,cACb,8BAA8B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA+GxB,iBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,oCACP,cACA,QACA,OACA,WACA,aAEF,cAAc,cACb,uBAAuB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA6IjB,iBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,wBACP,cACA,QACA,OACA,WACA,aAEF,cAAc,cACb,uBAAuB,OAAO"}
@@ -46,7 +46,7 @@ import { DefaultError, InfiniteData, QueryClient, QueryKey } from "@tanstack/que
46
46
  * }
47
47
  * ```
48
48
  */
49
- declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): DefinedUseInfiniteQueryResult<TData, TError>;
49
+ export declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): DefinedUseInfiniteQueryResult<TData, TError>;
50
50
  /**
51
51
  * The options for `useInfiniteQuery` are identical to `useQuery`, with the addition of
52
52
  * `initialPageParam`, `getNextPageParam`, `getPreviousPageParam`, and `maxPages`.
@@ -156,7 +156,7 @@ declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = I
156
156
  * }
157
157
  * ```
158
158
  */
159
- declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseInfiniteQueryResult<TData, TError>;
159
+ export declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseInfiniteQueryResult<TData, TError>;
160
160
  /**
161
161
  * The options for `useInfiniteQuery` are identical to `useQuery`, with the addition of
162
162
  * `initialPageParam`, `getNextPageParam`, `getPreviousPageParam`, and `maxPages`.
@@ -296,7 +296,6 @@ declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = I
296
296
  * }
297
297
  * ```
298
298
  */
299
- declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseInfiniteQueryResult<TData, TError>;
299
+ export declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseInfiniteQueryResult<TData, TError>;
300
300
  //#endregion
301
- export { useInfiniteQuery };
302
301
  //# sourceMappingURL=useInfiniteQuery.d.ts.map
@@ -1 +1 @@
1
- {"version":3,"file":"useInfiniteQuery.d.ts","names":[],"sources":["../../src/useInfiniteQuery.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgEgB,iBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,kCACP,cACA,QACA,OACA,WACA,aAEF,cAAc,cACb,8BAA8B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+GxB,iBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,oCACP,cACA,QACA,OACA,WACA,aAEF,cAAc,cACb,uBAAuB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6IjB,iBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,wBACP,cACA,QACA,OACA,WACA,aAEF,cAAc,cACb,uBAAuB,OAAO"}
1
+ {"version":3,"file":"useInfiniteQuery.d.ts","names":[],"sources":["../../src/useInfiniteQuery.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAgEgB,iBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,kCACP,cACA,QACA,OACA,WACA,aAEF,cAAc,cACb,8BAA8B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA+GxB,iBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,oCACP,cACA,QACA,OACA,WACA,aAEF,cAAc,cACb,uBAAuB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA6IjB,iBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,wBACP,cACA,QACA,OACA,WACA,aAEF,cAAc,cACb,uBAAuB,OAAO"}
@@ -36,7 +36,6 @@ import { QueryClient, QueryFilters } from "@tanstack/query-core";
36
36
  * }
37
37
  * ```
38
38
  */
39
- declare function useIsFetching(filters?: QueryFilters, queryClient?: QueryClient): number;
39
+ export declare function useIsFetching(filters?: QueryFilters, queryClient?: QueryClient): number;
40
40
  //#endregion
41
- export { useIsFetching };
42
41
  //# sourceMappingURL=useIsFetching.d.cts.map
@@ -1 +1 @@
1
- {"version":3,"file":"useIsFetching.d.cts","names":[],"sources":["../../src/useIsFetching.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2CgB,cACd,UAAU,cACV,cAAc"}
1
+ {"version":3,"file":"useIsFetching.d.cts","names":[],"sources":["../../src/useIsFetching.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA2CgB,cACd,UAAU,cACV,cAAc"}
@@ -36,7 +36,6 @@ import { QueryClient, QueryFilters } from "@tanstack/query-core";
36
36
  * }
37
37
  * ```
38
38
  */
39
- declare function useIsFetching(filters?: QueryFilters, queryClient?: QueryClient): number;
39
+ export declare function useIsFetching(filters?: QueryFilters, queryClient?: QueryClient): number;
40
40
  //#endregion
41
- export { useIsFetching };
42
41
  //# sourceMappingURL=useIsFetching.d.ts.map
@@ -1 +1 @@
1
- {"version":3,"file":"useIsFetching.d.ts","names":[],"sources":["../../src/useIsFetching.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2CgB,cACd,UAAU,cACV,cAAc"}
1
+ {"version":3,"file":"useIsFetching.d.ts","names":[],"sources":["../../src/useIsFetching.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA2CgB,cACd,UAAU,cACV,cAAc"}
@@ -173,7 +173,6 @@ import { DefaultError, QueryClient } from "@tanstack/query-core";
173
173
  * }
174
174
  * ```
175
175
  */
176
- declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, queryClient?: QueryClient): UseMutationResult<TData, TError, TVariables, TOnMutateResult>;
176
+ export declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, queryClient?: QueryClient): UseMutationResult<TData, TError, TVariables, TOnMutateResult>;
177
177
  //#endregion
178
- export { useMutation };
179
178
  //# sourceMappingURL=useMutation.d.cts.map
@@ -1 +1 @@
1
- {"version":3,"file":"useMutation.d.cts","names":[],"sources":["../../src/useMutation.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8LgB,YACd,iBACA,SAAS,cACT,mBACA,2BAEA,SAAS,mBAAmB,OAAO,QAAQ,YAAY,kBACvD,cAAc,cACb,kBAAkB,OAAO,QAAQ,YAAY"}
1
+ {"version":3,"file":"useMutation.d.cts","names":[],"sources":["../../src/useMutation.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8LgB,YACd,iBACA,SAAS,cACT,mBACA,2BAEA,SAAS,mBAAmB,OAAO,QAAQ,YAAY,kBACvD,cAAc,cACb,kBAAkB,OAAO,QAAQ,YAAY"}
@@ -173,7 +173,6 @@ import { DefaultError, QueryClient } from "@tanstack/query-core";
173
173
  * }
174
174
  * ```
175
175
  */
176
- declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, queryClient?: QueryClient): UseMutationResult<TData, TError, TVariables, TOnMutateResult>;
176
+ export declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, queryClient?: QueryClient): UseMutationResult<TData, TError, TVariables, TOnMutateResult>;
177
177
  //#endregion
178
- export { useMutation };
179
178
  //# sourceMappingURL=useMutation.d.ts.map
@@ -1 +1 @@
1
- {"version":3,"file":"useMutation.d.ts","names":[],"sources":["../../src/useMutation.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8LgB,YACd,iBACA,SAAS,cACT,mBACA,2BAEA,SAAS,mBAAmB,OAAO,QAAQ,YAAY,kBACvD,cAAc,cACb,kBAAkB,OAAO,QAAQ,YAAY"}
1
+ {"version":3,"file":"useMutation.d.ts","names":[],"sources":["../../src/useMutation.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8LgB,YACd,iBACA,SAAS,cACT,mBACA,2BAEA,SAAS,mBAAmB,OAAO,QAAQ,YAAY,kBACvD,cAAc,cACb,kBAAkB,OAAO,QAAQ,YAAY"}
@@ -113,18 +113,18 @@ function getResult(mutationCache, options) {
113
113
  function useMutationState(options = {}, queryClient) {
114
114
  const mutationCache = require_QueryClientProvider.useQueryClient(queryClient).getMutationCache();
115
115
  const optionsRef = react.useRef(options);
116
- const result = react.useRef(null);
117
- if (result.current === null) result.current = getResult(mutationCache, options);
116
+ const resultRef = react.useRef(null);
117
+ if (resultRef.current === null) resultRef.current = getResult(mutationCache, options);
118
118
  react.useEffect(() => {
119
119
  optionsRef.current = options;
120
120
  });
121
121
  return react.useSyncExternalStore(react.useCallback((onStoreChange) => mutationCache.subscribe(() => {
122
- const nextResult = (0, _tanstack_query_core.replaceEqualDeep)(result.current, getResult(mutationCache, optionsRef.current));
123
- if (result.current !== nextResult) {
124
- result.current = nextResult;
122
+ const nextResult = (0, _tanstack_query_core.replaceEqualDeep)(resultRef.current, getResult(mutationCache, optionsRef.current));
123
+ if (resultRef.current !== nextResult) {
124
+ resultRef.current = nextResult;
125
125
  _tanstack_query_core.notifyManager.schedule(onStoreChange);
126
126
  }
127
- }), [mutationCache]), () => result.current, () => result.current);
127
+ }), [mutationCache]), () => resultRef.current, () => resultRef.current);
128
128
  }
129
129
  //#endregion
130
130
  exports.useIsMutating = useIsMutating;
@@ -1 +1 @@
1
- {"version":3,"file":"useMutationState.cjs","names":["useQueryClient","React","replaceEqualDeep"],"sources":["../../src/useMutationState.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { notifyManager, replaceEqualDeep } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n Mutation,\n MutationCache,\n MutationFilters,\n MutationState,\n QueryClient,\n} from '@tanstack/query-core'\n\n/**\n * The `useIsMutating` hook returns the `number` of mutations that your application currently has `pending`\n * (useful for app-wide loading indicators).\n *\n * @param filters - The {@link MutationFilters} to narrow down the matched mutations.\n * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will\n * be used.\n * @returns Will be the `number` of the mutations that your application currently has `pending`.\n *\n * @example\n * ```tsx\n * import { useIsMutating } from '@tanstack/react-query'\n *\n * function PostsMutatingIndicator() {\n * // How many mutations matching the posts prefix are in progress?\n * const isMutatingPosts = useIsMutating({ mutationKey: ['posts'] })\n *\n * return isMutatingPosts ? <span>Saving posts...</span> : null\n * }\n * ```\n */\nexport function useIsMutating(\n filters?: MutationFilters,\n queryClient?: QueryClient,\n): number {\n const client = useQueryClient(queryClient)\n return useMutationState(\n { filters: { ...filters, status: 'pending' } },\n client,\n ).length\n}\n\ntype MutationTypeFromResult<TResult> = [TResult] extends [\n MutationState<\n infer TData,\n infer TError,\n infer TVariables,\n infer TOnMutateResult\n >,\n]\n ? Mutation<TData, TError, TVariables, TOnMutateResult>\n : Mutation\n\ntype MutationStateOptions<\n TResult = MutationState,\n TMutation extends Mutation<any, any, any, any> =\n MutationTypeFromResult<TResult>,\n> = {\n filters?: MutationFilters\n select?: (mutation: TMutation) => TResult\n}\n\nfunction getResult<\n TResult = MutationState,\n TMutation extends Mutation<any, any, any, any> =\n MutationTypeFromResult<TResult>,\n>(\n mutationCache: MutationCache,\n options: MutationStateOptions<TResult, TMutation>,\n): Array<TResult> {\n return mutationCache\n .findAll(options.filters)\n .map(\n (mutation): TResult =>\n (options.select\n ? options.select(mutation as TMutation)\n : mutation.state) as TResult,\n )\n}\n\n/**\n * `useMutationState` is a hook that gives you access to all mutations in the `MutationCache`. You can pass\n * `filters` ({@link MutationFilters}) to narrow down your mutations, and `select` to transform the mutation\n * state.\n *\n * @param options - The `filters` to narrow down matched mutations, and an optional `select` to transform the\n * mutation state.\n * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will\n * be used.\n * @returns Will be an Array of whatever `select` returns for each matching mutation.\n *\n * @example\n * Get all variables of all running mutations:\n * ```tsx\n * import { useMutationState } from '@tanstack/react-query'\n *\n * function PendingPosts() {\n * const pendingVariables = useMutationState({\n * filters: { status: 'pending' },\n * select: (mutation) => mutation.state.variables,\n * })\n *\n * return <>{pendingVariables.length} posts saving...</>\n * }\n * ```\n *\n * @example\n * Get all data for specific mutations via the `mutationKey`:\n * ```tsx\n * import { useMutation, useMutationState } from '@tanstack/react-query'\n *\n * const mutationKey = ['posts']\n *\n * function Posts() {\n * // Some mutation that we want to get the state for\n * const mutation = useMutation({\n * mutationKey,\n * mutationFn: createPosts,\n * })\n *\n * const savedPosts = useMutationState({\n * // this mutation key needs to match the mutation key of the given mutation (see above)\n * filters: { mutationKey, status: 'success' },\n * select: (mutation) => mutation.state.data,\n * })\n *\n * return (\n * <button onClick={() => mutation.mutate(['New Post'])}>\n * Create post ({savedPosts.length} saved so far)\n * </button>\n * )\n * }\n * ```\n *\n * @example\n * Access the latest successful mutation data via the `mutationKey`. Each invocation of `mutate` adds a new\n * entry to the mutation cache for `gcTime` milliseconds — with the `status: 'success'` filter below, check the\n * last item that `useMutationState` returns to get the latest successful invocation:\n * ```tsx\n * import { useMutationState } from '@tanstack/react-query'\n *\n * function LatestPost() {\n * const savedPosts = useMutationState({\n * filters: { mutationKey: ['posts'], status: 'success' },\n * select: (mutation) => mutation.state.data,\n * })\n *\n * const latestSavedPost = savedPosts[savedPosts.length - 1]\n *\n * return <>{latestSavedPost ? 'Saved' : 'Nothing saved yet'}</>\n * }\n * ```\n */\nexport function useMutationState<\n TResult = MutationState,\n TMutation extends Mutation<any, any, any, any> =\n MutationTypeFromResult<TResult>,\n>(\n options: MutationStateOptions<TResult, TMutation> = {},\n queryClient?: QueryClient,\n): Array<TResult> {\n const mutationCache = useQueryClient(queryClient).getMutationCache()\n const optionsRef = React.useRef(options)\n const result = React.useRef<Array<TResult>>(null)\n if (result.current === null) {\n result.current = getResult(mutationCache, options)\n }\n\n React.useEffect(() => {\n optionsRef.current = options\n })\n\n return React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n mutationCache.subscribe(() => {\n const nextResult = replaceEqualDeep(\n result.current,\n getResult(mutationCache, optionsRef.current),\n )\n if (result.current !== nextResult) {\n result.current = nextResult\n notifyManager.schedule(onStoreChange)\n }\n }),\n [mutationCache],\n ),\n () => result.current,\n () => result.current,\n )!\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,SAAgB,cACd,SACA,aACQ;CACR,MAAM,SAASA,4BAAAA,eAAe,WAAW;CACzC,OAAO,iBACL,EAAE,SAAS;EAAE,GAAG;EAAS,QAAQ;CAAU,EAAE,GAC7C,MACF,CAAC,CAAC;AACJ;AAsBA,SAAS,UAKP,eACA,SACgB;CAChB,OAAO,cACJ,QAAQ,QAAQ,OAAO,CAAC,CACxB,KACE,aACE,QAAQ,SACL,QAAQ,OAAO,QAAqB,IACpC,SAAS,KACjB;AACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2EA,SAAgB,iBAKd,UAAoD,CAAC,GACrD,aACgB;CAChB,MAAM,gBAAgBA,4BAAAA,eAAe,WAAW,CAAC,CAAC,iBAAiB;CACnE,MAAM,aAAaC,MAAM,OAAO,OAAO;CACvC,MAAM,SAASA,MAAM,OAAuB,IAAI;CAChD,IAAI,OAAO,YAAY,MACrB,OAAO,UAAU,UAAU,eAAe,OAAO;CAGnD,MAAM,gBAAgB;EACpB,WAAW,UAAU;CACvB,CAAC;CAED,OAAOA,MAAM,qBACXA,MAAM,aACH,kBACC,cAAc,gBAAgB;EAC5B,MAAM,cAAA,GAAaC,qBAAAA,iBAAAA,CACjB,OAAO,SACP,UAAU,eAAe,WAAW,OAAO,CAC7C;EACA,IAAI,OAAO,YAAY,YAAY;GACjC,OAAO,UAAU;GACjB,qBAAA,cAAc,SAAS,aAAa;EACtC;CACF,CAAC,GACH,CAAC,aAAa,CAChB,SACM,OAAO,eACP,OAAO,OACf;AACF"}
1
+ {"version":3,"file":"useMutationState.cjs","names":["useQueryClient","React","replaceEqualDeep"],"sources":["../../src/useMutationState.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { notifyManager, replaceEqualDeep } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n Mutation,\n MutationCache,\n MutationFilters,\n MutationState,\n QueryClient,\n} from '@tanstack/query-core'\n\n/**\n * The `useIsMutating` hook returns the `number` of mutations that your application currently has `pending`\n * (useful for app-wide loading indicators).\n *\n * @param filters - The {@link MutationFilters} to narrow down the matched mutations.\n * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will\n * be used.\n * @returns Will be the `number` of the mutations that your application currently has `pending`.\n *\n * @example\n * ```tsx\n * import { useIsMutating } from '@tanstack/react-query'\n *\n * function PostsMutatingIndicator() {\n * // How many mutations matching the posts prefix are in progress?\n * const isMutatingPosts = useIsMutating({ mutationKey: ['posts'] })\n *\n * return isMutatingPosts ? <span>Saving posts...</span> : null\n * }\n * ```\n */\nexport function useIsMutating(\n filters?: MutationFilters,\n queryClient?: QueryClient,\n): number {\n const client = useQueryClient(queryClient)\n return useMutationState(\n { filters: { ...filters, status: 'pending' } },\n client,\n ).length\n}\n\ntype MutationTypeFromResult<TResult> = [TResult] extends [\n MutationState<\n infer TData,\n infer TError,\n infer TVariables,\n infer TOnMutateResult\n >,\n]\n ? Mutation<TData, TError, TVariables, TOnMutateResult>\n : Mutation\n\ntype MutationStateOptions<\n TResult = MutationState,\n TMutation extends Mutation<any, any, any, any> =\n MutationTypeFromResult<TResult>,\n> = {\n filters?: MutationFilters\n select?: (mutation: TMutation) => TResult\n}\n\nfunction getResult<\n TResult = MutationState,\n TMutation extends Mutation<any, any, any, any> =\n MutationTypeFromResult<TResult>,\n>(\n mutationCache: MutationCache,\n options: MutationStateOptions<TResult, TMutation>,\n): Array<TResult> {\n return mutationCache\n .findAll(options.filters)\n .map(\n (mutation): TResult =>\n (options.select\n ? options.select(mutation as TMutation)\n : mutation.state) as TResult,\n )\n}\n\n/**\n * `useMutationState` is a hook that gives you access to all mutations in the `MutationCache`. You can pass\n * `filters` ({@link MutationFilters}) to narrow down your mutations, and `select` to transform the mutation\n * state.\n *\n * @param options - The `filters` to narrow down matched mutations, and an optional `select` to transform the\n * mutation state.\n * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will\n * be used.\n * @returns Will be an Array of whatever `select` returns for each matching mutation.\n *\n * @example\n * Get all variables of all running mutations:\n * ```tsx\n * import { useMutationState } from '@tanstack/react-query'\n *\n * function PendingPosts() {\n * const pendingVariables = useMutationState({\n * filters: { status: 'pending' },\n * select: (mutation) => mutation.state.variables,\n * })\n *\n * return <>{pendingVariables.length} posts saving...</>\n * }\n * ```\n *\n * @example\n * Get all data for specific mutations via the `mutationKey`:\n * ```tsx\n * import { useMutation, useMutationState } from '@tanstack/react-query'\n *\n * const mutationKey = ['posts']\n *\n * function Posts() {\n * // Some mutation that we want to get the state for\n * const mutation = useMutation({\n * mutationKey,\n * mutationFn: createPosts,\n * })\n *\n * const savedPosts = useMutationState({\n * // this mutation key needs to match the mutation key of the given mutation (see above)\n * filters: { mutationKey, status: 'success' },\n * select: (mutation) => mutation.state.data,\n * })\n *\n * return (\n * <button onClick={() => mutation.mutate(['New Post'])}>\n * Create post ({savedPosts.length} saved so far)\n * </button>\n * )\n * }\n * ```\n *\n * @example\n * Access the latest successful mutation data via the `mutationKey`. Each invocation of `mutate` adds a new\n * entry to the mutation cache for `gcTime` milliseconds — with the `status: 'success'` filter below, check the\n * last item that `useMutationState` returns to get the latest successful invocation:\n * ```tsx\n * import { useMutationState } from '@tanstack/react-query'\n *\n * function LatestPost() {\n * const savedPosts = useMutationState({\n * filters: { mutationKey: ['posts'], status: 'success' },\n * select: (mutation) => mutation.state.data,\n * })\n *\n * const latestSavedPost = savedPosts[savedPosts.length - 1]\n *\n * return <>{latestSavedPost ? 'Saved' : 'Nothing saved yet'}</>\n * }\n * ```\n */\nexport function useMutationState<\n TResult = MutationState,\n TMutation extends Mutation<any, any, any, any> =\n MutationTypeFromResult<TResult>,\n>(\n options: MutationStateOptions<TResult, TMutation> = {},\n queryClient?: QueryClient,\n): Array<TResult> {\n const mutationCache = useQueryClient(queryClient).getMutationCache()\n const optionsRef = React.useRef(options)\n const resultRef = React.useRef<Array<TResult>>(null)\n if (resultRef.current === null) {\n resultRef.current = getResult(mutationCache, options)\n }\n\n React.useEffect(() => {\n optionsRef.current = options\n })\n\n return React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n mutationCache.subscribe(() => {\n const nextResult = replaceEqualDeep(\n resultRef.current,\n getResult(mutationCache, optionsRef.current),\n )\n if (resultRef.current !== nextResult) {\n resultRef.current = nextResult\n notifyManager.schedule(onStoreChange)\n }\n }),\n [mutationCache],\n ),\n () => resultRef.current,\n () => resultRef.current,\n )!\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,SAAgB,cACd,SACA,aACQ;CACR,MAAM,SAASA,4BAAAA,eAAe,WAAW;CACzC,OAAO,iBACL,EAAE,SAAS;EAAE,GAAG;EAAS,QAAQ;CAAU,EAAE,GAC7C,MACF,CAAC,CAAC;AACJ;AAsBA,SAAS,UAKP,eACA,SACgB;CAChB,OAAO,cACJ,QAAQ,QAAQ,OAAO,CAAC,CACxB,KACE,aACE,QAAQ,SACL,QAAQ,OAAO,QAAqB,IACpC,SAAS,KACjB;AACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2EA,SAAgB,iBAKd,UAAoD,CAAC,GACrD,aACgB;CAChB,MAAM,gBAAgBA,4BAAAA,eAAe,WAAW,CAAC,CAAC,iBAAiB;CACnE,MAAM,aAAaC,MAAM,OAAO,OAAO;CACvC,MAAM,YAAYA,MAAM,OAAuB,IAAI;CACnD,IAAI,UAAU,YAAY,MACxB,UAAU,UAAU,UAAU,eAAe,OAAO;CAGtD,MAAM,gBAAgB;EACpB,WAAW,UAAU;CACvB,CAAC;CAED,OAAOA,MAAM,qBACXA,MAAM,aACH,kBACC,cAAc,gBAAgB;EAC5B,MAAM,cAAA,GAAaC,qBAAAA,iBAAAA,CACjB,UAAU,SACV,UAAU,eAAe,WAAW,OAAO,CAC7C;EACA,IAAI,UAAU,YAAY,YAAY;GACpC,UAAU,UAAU;GACpB,qBAAA,cAAc,SAAS,aAAa;EACtC;CACF,CAAC,GACH,CAAC,aAAa,CAChB,SACM,UAAU,eACV,UAAU,OAClB;AACF"}
@@ -21,7 +21,7 @@ import { Mutation, MutationFilters, MutationState, QueryClient } from "@tanstack
21
21
  * }
22
22
  * ```
23
23
  */
24
- declare function useIsMutating(filters?: MutationFilters, queryClient?: QueryClient): number;
24
+ export declare function useIsMutating(filters?: MutationFilters, queryClient?: QueryClient): number;
25
25
  type MutationTypeFromResult<TResult> = [TResult] extends [MutationState<infer TData, infer TError, infer TVariables, infer TOnMutateResult>] ? Mutation<TData, TError, TVariables, TOnMutateResult> : Mutation;
26
26
  type MutationStateOptions<TResult = MutationState, TMutation extends Mutation<any, any, any, any> = MutationTypeFromResult<TResult>> = {
27
27
  filters?: MutationFilters;
@@ -100,7 +100,6 @@ type MutationStateOptions<TResult = MutationState, TMutation extends Mutation<an
100
100
  * }
101
101
  * ```
102
102
  */
103
- declare function useMutationState<TResult = MutationState, TMutation extends Mutation<any, any, any, any> = MutationTypeFromResult<TResult>>(options?: MutationStateOptions<TResult, TMutation>, queryClient?: QueryClient): Array<TResult>;
103
+ export declare function useMutationState<TResult = MutationState, TMutation extends Mutation<any, any, any, any> = MutationTypeFromResult<TResult>>(options?: MutationStateOptions<TResult, TMutation>, queryClient?: QueryClient): Array<TResult>;
104
104
  //#endregion
105
- export { useIsMutating, useMutationState };
106
105
  //# sourceMappingURL=useMutationState.d.cts.map
@@ -1 +1 @@
1
- {"version":3,"file":"useMutationState.d.cts","names":[],"sources":["../../src/useMutationState.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;iBAkCgB,cACd,UAAU,iBACV,cAAc;KASX,uBAAuB,YAAY,kBACtC,oBACQ,aACA,cACA,kBACA,oBAGN,SAAS,OAAO,QAAQ,YAAY,mBACpC;KAEC,qBACH,UAAU,eACV,kBAAkB,+BAChB,uBAAuB;EAEzB,UAAU;EACV,UAAU,UAAU,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8FpB,iBACd,UAAU,eACV,kBAAkB,+BAChB,uBAAuB,UAEzB,UAAS,qBAAqB,SAAS,YACvC,cAAc,cACb,MAAM"}
1
+ {"version":3,"file":"useMutationState.d.cts","names":[],"sources":["../../src/useMutationState.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;wBAkCgB,cACd,UAAU,iBACV,cAAc;KASX,uBAAuB,YAAY,kBACtC,oBACQ,aACA,cACA,kBACA,oBAGN,SAAS,OAAO,QAAQ,YAAY,mBACpC;KAEC,qBACH,UAAU,eACV,kBAAkB,+BAChB,uBAAuB;EAEzB,UAAU;EACV,UAAU,UAAU,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8FpB,iBACd,UAAU,eACV,kBAAkB,+BAChB,uBAAuB,UAEzB,UAAS,qBAAqB,SAAS,YACvC,cAAc,cACb,MAAM"}
@@ -21,7 +21,7 @@ import { Mutation, MutationFilters, MutationState, QueryClient } from "@tanstack
21
21
  * }
22
22
  * ```
23
23
  */
24
- declare function useIsMutating(filters?: MutationFilters, queryClient?: QueryClient): number;
24
+ export declare function useIsMutating(filters?: MutationFilters, queryClient?: QueryClient): number;
25
25
  type MutationTypeFromResult<TResult> = [TResult] extends [MutationState<infer TData, infer TError, infer TVariables, infer TOnMutateResult>] ? Mutation<TData, TError, TVariables, TOnMutateResult> : Mutation;
26
26
  type MutationStateOptions<TResult = MutationState, TMutation extends Mutation<any, any, any, any> = MutationTypeFromResult<TResult>> = {
27
27
  filters?: MutationFilters;
@@ -100,7 +100,6 @@ type MutationStateOptions<TResult = MutationState, TMutation extends Mutation<an
100
100
  * }
101
101
  * ```
102
102
  */
103
- declare function useMutationState<TResult = MutationState, TMutation extends Mutation<any, any, any, any> = MutationTypeFromResult<TResult>>(options?: MutationStateOptions<TResult, TMutation>, queryClient?: QueryClient): Array<TResult>;
103
+ export declare function useMutationState<TResult = MutationState, TMutation extends Mutation<any, any, any, any> = MutationTypeFromResult<TResult>>(options?: MutationStateOptions<TResult, TMutation>, queryClient?: QueryClient): Array<TResult>;
104
104
  //#endregion
105
- export { useIsMutating, useMutationState };
106
105
  //# sourceMappingURL=useMutationState.d.ts.map
@@ -1 +1 @@
1
- {"version":3,"file":"useMutationState.d.ts","names":[],"sources":["../../src/useMutationState.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;iBAkCgB,cACd,UAAU,iBACV,cAAc;KASX,uBAAuB,YAAY,kBACtC,oBACQ,aACA,cACA,kBACA,oBAGN,SAAS,OAAO,QAAQ,YAAY,mBACpC;KAEC,qBACH,UAAU,eACV,kBAAkB,+BAChB,uBAAuB;EAEzB,UAAU;EACV,UAAU,UAAU,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8FpB,iBACd,UAAU,eACV,kBAAkB,+BAChB,uBAAuB,UAEzB,UAAS,qBAAqB,SAAS,YACvC,cAAc,cACb,MAAM"}
1
+ {"version":3,"file":"useMutationState.d.ts","names":[],"sources":["../../src/useMutationState.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;wBAkCgB,cACd,UAAU,iBACV,cAAc;KASX,uBAAuB,YAAY,kBACtC,oBACQ,aACA,cACA,kBACA,oBAGN,SAAS,OAAO,QAAQ,YAAY,mBACpC;KAEC,qBACH,UAAU,eACV,kBAAkB,+BAChB,uBAAuB;EAEzB,UAAU;EACV,UAAU,UAAU,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8FpB,iBACd,UAAU,eACV,kBAAkB,+BAChB,uBAAuB,UAEzB,UAAS,qBAAqB,SAAS,YACvC,cAAc,cACb,MAAM"}
@@ -110,18 +110,18 @@ function getResult(mutationCache, options) {
110
110
  function useMutationState(options = {}, queryClient) {
111
111
  const mutationCache = useQueryClient(queryClient).getMutationCache();
112
112
  const optionsRef = React.useRef(options);
113
- const result = React.useRef(null);
114
- if (result.current === null) result.current = getResult(mutationCache, options);
113
+ const resultRef = React.useRef(null);
114
+ if (resultRef.current === null) resultRef.current = getResult(mutationCache, options);
115
115
  React.useEffect(() => {
116
116
  optionsRef.current = options;
117
117
  });
118
118
  return React.useSyncExternalStore(React.useCallback((onStoreChange) => mutationCache.subscribe(() => {
119
- const nextResult = replaceEqualDeep(result.current, getResult(mutationCache, optionsRef.current));
120
- if (result.current !== nextResult) {
121
- result.current = nextResult;
119
+ const nextResult = replaceEqualDeep(resultRef.current, getResult(mutationCache, optionsRef.current));
120
+ if (resultRef.current !== nextResult) {
121
+ resultRef.current = nextResult;
122
122
  notifyManager.schedule(onStoreChange);
123
123
  }
124
- }), [mutationCache]), () => result.current, () => result.current);
124
+ }), [mutationCache]), () => resultRef.current, () => resultRef.current);
125
125
  }
126
126
  //#endregion
127
127
  export { useIsMutating, useMutationState };
@@ -1 +1 @@
1
- {"version":3,"file":"useMutationState.js","names":[],"sources":["../../src/useMutationState.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { notifyManager, replaceEqualDeep } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n Mutation,\n MutationCache,\n MutationFilters,\n MutationState,\n QueryClient,\n} from '@tanstack/query-core'\n\n/**\n * The `useIsMutating` hook returns the `number` of mutations that your application currently has `pending`\n * (useful for app-wide loading indicators).\n *\n * @param filters - The {@link MutationFilters} to narrow down the matched mutations.\n * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will\n * be used.\n * @returns Will be the `number` of the mutations that your application currently has `pending`.\n *\n * @example\n * ```tsx\n * import { useIsMutating } from '@tanstack/react-query'\n *\n * function PostsMutatingIndicator() {\n * // How many mutations matching the posts prefix are in progress?\n * const isMutatingPosts = useIsMutating({ mutationKey: ['posts'] })\n *\n * return isMutatingPosts ? <span>Saving posts...</span> : null\n * }\n * ```\n */\nexport function useIsMutating(\n filters?: MutationFilters,\n queryClient?: QueryClient,\n): number {\n const client = useQueryClient(queryClient)\n return useMutationState(\n { filters: { ...filters, status: 'pending' } },\n client,\n ).length\n}\n\ntype MutationTypeFromResult<TResult> = [TResult] extends [\n MutationState<\n infer TData,\n infer TError,\n infer TVariables,\n infer TOnMutateResult\n >,\n]\n ? Mutation<TData, TError, TVariables, TOnMutateResult>\n : Mutation\n\ntype MutationStateOptions<\n TResult = MutationState,\n TMutation extends Mutation<any, any, any, any> =\n MutationTypeFromResult<TResult>,\n> = {\n filters?: MutationFilters\n select?: (mutation: TMutation) => TResult\n}\n\nfunction getResult<\n TResult = MutationState,\n TMutation extends Mutation<any, any, any, any> =\n MutationTypeFromResult<TResult>,\n>(\n mutationCache: MutationCache,\n options: MutationStateOptions<TResult, TMutation>,\n): Array<TResult> {\n return mutationCache\n .findAll(options.filters)\n .map(\n (mutation): TResult =>\n (options.select\n ? options.select(mutation as TMutation)\n : mutation.state) as TResult,\n )\n}\n\n/**\n * `useMutationState` is a hook that gives you access to all mutations in the `MutationCache`. You can pass\n * `filters` ({@link MutationFilters}) to narrow down your mutations, and `select` to transform the mutation\n * state.\n *\n * @param options - The `filters` to narrow down matched mutations, and an optional `select` to transform the\n * mutation state.\n * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will\n * be used.\n * @returns Will be an Array of whatever `select` returns for each matching mutation.\n *\n * @example\n * Get all variables of all running mutations:\n * ```tsx\n * import { useMutationState } from '@tanstack/react-query'\n *\n * function PendingPosts() {\n * const pendingVariables = useMutationState({\n * filters: { status: 'pending' },\n * select: (mutation) => mutation.state.variables,\n * })\n *\n * return <>{pendingVariables.length} posts saving...</>\n * }\n * ```\n *\n * @example\n * Get all data for specific mutations via the `mutationKey`:\n * ```tsx\n * import { useMutation, useMutationState } from '@tanstack/react-query'\n *\n * const mutationKey = ['posts']\n *\n * function Posts() {\n * // Some mutation that we want to get the state for\n * const mutation = useMutation({\n * mutationKey,\n * mutationFn: createPosts,\n * })\n *\n * const savedPosts = useMutationState({\n * // this mutation key needs to match the mutation key of the given mutation (see above)\n * filters: { mutationKey, status: 'success' },\n * select: (mutation) => mutation.state.data,\n * })\n *\n * return (\n * <button onClick={() => mutation.mutate(['New Post'])}>\n * Create post ({savedPosts.length} saved so far)\n * </button>\n * )\n * }\n * ```\n *\n * @example\n * Access the latest successful mutation data via the `mutationKey`. Each invocation of `mutate` adds a new\n * entry to the mutation cache for `gcTime` milliseconds — with the `status: 'success'` filter below, check the\n * last item that `useMutationState` returns to get the latest successful invocation:\n * ```tsx\n * import { useMutationState } from '@tanstack/react-query'\n *\n * function LatestPost() {\n * const savedPosts = useMutationState({\n * filters: { mutationKey: ['posts'], status: 'success' },\n * select: (mutation) => mutation.state.data,\n * })\n *\n * const latestSavedPost = savedPosts[savedPosts.length - 1]\n *\n * return <>{latestSavedPost ? 'Saved' : 'Nothing saved yet'}</>\n * }\n * ```\n */\nexport function useMutationState<\n TResult = MutationState,\n TMutation extends Mutation<any, any, any, any> =\n MutationTypeFromResult<TResult>,\n>(\n options: MutationStateOptions<TResult, TMutation> = {},\n queryClient?: QueryClient,\n): Array<TResult> {\n const mutationCache = useQueryClient(queryClient).getMutationCache()\n const optionsRef = React.useRef(options)\n const result = React.useRef<Array<TResult>>(null)\n if (result.current === null) {\n result.current = getResult(mutationCache, options)\n }\n\n React.useEffect(() => {\n optionsRef.current = options\n })\n\n return React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n mutationCache.subscribe(() => {\n const nextResult = replaceEqualDeep(\n result.current,\n getResult(mutationCache, optionsRef.current),\n )\n if (result.current !== nextResult) {\n result.current = nextResult\n notifyManager.schedule(onStoreChange)\n }\n }),\n [mutationCache],\n ),\n () => result.current,\n () => result.current,\n )!\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,SAAgB,cACd,SACA,aACQ;CACR,MAAM,SAAS,eAAe,WAAW;CACzC,OAAO,iBACL,EAAE,SAAS;EAAE,GAAG;EAAS,QAAQ;CAAU,EAAE,GAC7C,MACF,CAAC,CAAC;AACJ;AAsBA,SAAS,UAKP,eACA,SACgB;CAChB,OAAO,cACJ,QAAQ,QAAQ,OAAO,CAAC,CACxB,KACE,aACE,QAAQ,SACL,QAAQ,OAAO,QAAqB,IACpC,SAAS,KACjB;AACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2EA,SAAgB,iBAKd,UAAoD,CAAC,GACrD,aACgB;CAChB,MAAM,gBAAgB,eAAe,WAAW,CAAC,CAAC,iBAAiB;CACnE,MAAM,aAAa,MAAM,OAAO,OAAO;CACvC,MAAM,SAAS,MAAM,OAAuB,IAAI;CAChD,IAAI,OAAO,YAAY,MACrB,OAAO,UAAU,UAAU,eAAe,OAAO;CAGnD,MAAM,gBAAgB;EACpB,WAAW,UAAU;CACvB,CAAC;CAED,OAAO,MAAM,qBACX,MAAM,aACH,kBACC,cAAc,gBAAgB;EAC5B,MAAM,aAAa,iBACjB,OAAO,SACP,UAAU,eAAe,WAAW,OAAO,CAC7C;EACA,IAAI,OAAO,YAAY,YAAY;GACjC,OAAO,UAAU;GACjB,cAAc,SAAS,aAAa;EACtC;CACF,CAAC,GACH,CAAC,aAAa,CAChB,SACM,OAAO,eACP,OAAO,OACf;AACF"}
1
+ {"version":3,"file":"useMutationState.js","names":[],"sources":["../../src/useMutationState.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { notifyManager, replaceEqualDeep } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n Mutation,\n MutationCache,\n MutationFilters,\n MutationState,\n QueryClient,\n} from '@tanstack/query-core'\n\n/**\n * The `useIsMutating` hook returns the `number` of mutations that your application currently has `pending`\n * (useful for app-wide loading indicators).\n *\n * @param filters - The {@link MutationFilters} to narrow down the matched mutations.\n * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will\n * be used.\n * @returns Will be the `number` of the mutations that your application currently has `pending`.\n *\n * @example\n * ```tsx\n * import { useIsMutating } from '@tanstack/react-query'\n *\n * function PostsMutatingIndicator() {\n * // How many mutations matching the posts prefix are in progress?\n * const isMutatingPosts = useIsMutating({ mutationKey: ['posts'] })\n *\n * return isMutatingPosts ? <span>Saving posts...</span> : null\n * }\n * ```\n */\nexport function useIsMutating(\n filters?: MutationFilters,\n queryClient?: QueryClient,\n): number {\n const client = useQueryClient(queryClient)\n return useMutationState(\n { filters: { ...filters, status: 'pending' } },\n client,\n ).length\n}\n\ntype MutationTypeFromResult<TResult> = [TResult] extends [\n MutationState<\n infer TData,\n infer TError,\n infer TVariables,\n infer TOnMutateResult\n >,\n]\n ? Mutation<TData, TError, TVariables, TOnMutateResult>\n : Mutation\n\ntype MutationStateOptions<\n TResult = MutationState,\n TMutation extends Mutation<any, any, any, any> =\n MutationTypeFromResult<TResult>,\n> = {\n filters?: MutationFilters\n select?: (mutation: TMutation) => TResult\n}\n\nfunction getResult<\n TResult = MutationState,\n TMutation extends Mutation<any, any, any, any> =\n MutationTypeFromResult<TResult>,\n>(\n mutationCache: MutationCache,\n options: MutationStateOptions<TResult, TMutation>,\n): Array<TResult> {\n return mutationCache\n .findAll(options.filters)\n .map(\n (mutation): TResult =>\n (options.select\n ? options.select(mutation as TMutation)\n : mutation.state) as TResult,\n )\n}\n\n/**\n * `useMutationState` is a hook that gives you access to all mutations in the `MutationCache`. You can pass\n * `filters` ({@link MutationFilters}) to narrow down your mutations, and `select` to transform the mutation\n * state.\n *\n * @param options - The `filters` to narrow down matched mutations, and an optional `select` to transform the\n * mutation state.\n * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will\n * be used.\n * @returns Will be an Array of whatever `select` returns for each matching mutation.\n *\n * @example\n * Get all variables of all running mutations:\n * ```tsx\n * import { useMutationState } from '@tanstack/react-query'\n *\n * function PendingPosts() {\n * const pendingVariables = useMutationState({\n * filters: { status: 'pending' },\n * select: (mutation) => mutation.state.variables,\n * })\n *\n * return <>{pendingVariables.length} posts saving...</>\n * }\n * ```\n *\n * @example\n * Get all data for specific mutations via the `mutationKey`:\n * ```tsx\n * import { useMutation, useMutationState } from '@tanstack/react-query'\n *\n * const mutationKey = ['posts']\n *\n * function Posts() {\n * // Some mutation that we want to get the state for\n * const mutation = useMutation({\n * mutationKey,\n * mutationFn: createPosts,\n * })\n *\n * const savedPosts = useMutationState({\n * // this mutation key needs to match the mutation key of the given mutation (see above)\n * filters: { mutationKey, status: 'success' },\n * select: (mutation) => mutation.state.data,\n * })\n *\n * return (\n * <button onClick={() => mutation.mutate(['New Post'])}>\n * Create post ({savedPosts.length} saved so far)\n * </button>\n * )\n * }\n * ```\n *\n * @example\n * Access the latest successful mutation data via the `mutationKey`. Each invocation of `mutate` adds a new\n * entry to the mutation cache for `gcTime` milliseconds — with the `status: 'success'` filter below, check the\n * last item that `useMutationState` returns to get the latest successful invocation:\n * ```tsx\n * import { useMutationState } from '@tanstack/react-query'\n *\n * function LatestPost() {\n * const savedPosts = useMutationState({\n * filters: { mutationKey: ['posts'], status: 'success' },\n * select: (mutation) => mutation.state.data,\n * })\n *\n * const latestSavedPost = savedPosts[savedPosts.length - 1]\n *\n * return <>{latestSavedPost ? 'Saved' : 'Nothing saved yet'}</>\n * }\n * ```\n */\nexport function useMutationState<\n TResult = MutationState,\n TMutation extends Mutation<any, any, any, any> =\n MutationTypeFromResult<TResult>,\n>(\n options: MutationStateOptions<TResult, TMutation> = {},\n queryClient?: QueryClient,\n): Array<TResult> {\n const mutationCache = useQueryClient(queryClient).getMutationCache()\n const optionsRef = React.useRef(options)\n const resultRef = React.useRef<Array<TResult>>(null)\n if (resultRef.current === null) {\n resultRef.current = getResult(mutationCache, options)\n }\n\n React.useEffect(() => {\n optionsRef.current = options\n })\n\n return React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n mutationCache.subscribe(() => {\n const nextResult = replaceEqualDeep(\n resultRef.current,\n getResult(mutationCache, optionsRef.current),\n )\n if (resultRef.current !== nextResult) {\n resultRef.current = nextResult\n notifyManager.schedule(onStoreChange)\n }\n }),\n [mutationCache],\n ),\n () => resultRef.current,\n () => resultRef.current,\n )!\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,SAAgB,cACd,SACA,aACQ;CACR,MAAM,SAAS,eAAe,WAAW;CACzC,OAAO,iBACL,EAAE,SAAS;EAAE,GAAG;EAAS,QAAQ;CAAU,EAAE,GAC7C,MACF,CAAC,CAAC;AACJ;AAsBA,SAAS,UAKP,eACA,SACgB;CAChB,OAAO,cACJ,QAAQ,QAAQ,OAAO,CAAC,CACxB,KACE,aACE,QAAQ,SACL,QAAQ,OAAO,QAAqB,IACpC,SAAS,KACjB;AACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2EA,SAAgB,iBAKd,UAAoD,CAAC,GACrD,aACgB;CAChB,MAAM,gBAAgB,eAAe,WAAW,CAAC,CAAC,iBAAiB;CACnE,MAAM,aAAa,MAAM,OAAO,OAAO;CACvC,MAAM,YAAY,MAAM,OAAuB,IAAI;CACnD,IAAI,UAAU,YAAY,MACxB,UAAU,UAAU,UAAU,eAAe,OAAO;CAGtD,MAAM,gBAAgB;EACpB,WAAW,UAAU;CACvB,CAAC;CAED,OAAO,MAAM,qBACX,MAAM,aACH,kBACC,cAAc,gBAAgB;EAC5B,MAAM,aAAa,iBACjB,UAAU,SACV,UAAU,eAAe,WAAW,OAAO,CAC7C;EACA,IAAI,UAAU,YAAY,YAAY;GACpC,UAAU,UAAU;GACpB,cAAc,SAAS,aAAa;EACtC;CACF,CAAC,GACH,CAAC,aAAa,CAChB,SACM,UAAU,eACV,UAAU,OAClB;AACF"}
@@ -45,7 +45,6 @@ import { DefaultError, InfiniteData, QueryClient, QueryKey } from "@tanstack/que
45
45
  * }
46
46
  * ```
47
47
  */
48
- declare function usePrefetchInfiniteQuery<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UsePrefetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): void;
48
+ export declare function usePrefetchInfiniteQuery<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UsePrefetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): void;
49
49
  //#endregion
50
- export { usePrefetchInfiniteQuery };
51
50
  //# sourceMappingURL=usePrefetchInfiniteQuery.d.cts.map
@@ -1 +1 @@
1
- {"version":3,"file":"usePrefetchInfiniteQuery.d.cts","names":[],"sources":["../../src/usePrefetchInfiniteQuery.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuDgB,yBACd,wBACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,gCACP,cACA,QACA,OACA,WACA,aAEF,cAAc"}
1
+ {"version":3,"file":"usePrefetchInfiniteQuery.d.cts","names":[],"sources":["../../src/usePrefetchInfiniteQuery.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAuDgB,yBACd,wBACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,gCACP,cACA,QACA,OACA,WACA,aAEF,cAAc"}