@tanstack/solid-query 5.104.1 → 5.104.3
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.
- package/build/dev.cjs +49 -21
- package/build/dev.js +49 -21
- package/build/index.d.cts +37 -88
- package/build/index.d.cts.map +1 -1
- package/build/index.d.ts +37 -88
- package/build/index.d.ts.map +1 -1
- package/build/index.js.map +1 -1
- package/package.json +5 -4
- package/src/QueryClient.ts +13 -5
- package/src/QueryClientProvider.tsx +9 -4
- package/src/infiniteQueryOptions.ts +2 -8
- package/src/isRestoring.ts +0 -1
- package/src/mutationOptions.ts +2 -6
- package/src/queryOptions.ts +2 -8
- package/src/types.ts +11 -18
- package/src/useBaseQuery.ts +36 -2
- package/src/useInfiniteQuery.ts +8 -13
- package/src/useIsFetching.ts +0 -2
- package/src/useIsMutating.ts +0 -2
- package/src/useMutation.ts +0 -6
- package/src/useMutationState.ts +7 -4
- package/src/useQueries.ts +0 -2
- package/src/useQuery.ts +2 -11
package/build/index.d.ts
CHANGED
|
@@ -4,7 +4,6 @@ export * from "@tanstack/query-core";
|
|
|
4
4
|
//#region src/QueryClient.d.ts
|
|
5
5
|
/**
|
|
6
6
|
* The core `QueryObserverOptions`, with Solid's `reconcile` option added.
|
|
7
|
-
*
|
|
8
7
|
* @template TQueryFnData - The type your `queryFn` resolves to.
|
|
9
8
|
* @template TError - The type of errors your `queryFn` may throw.
|
|
10
9
|
* @template TData - The type `data` ends up as after `select` runs.
|
|
@@ -24,7 +23,6 @@ interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TD
|
|
|
24
23
|
}
|
|
25
24
|
/**
|
|
26
25
|
* The core `InfiniteQueryObserverOptions`, with Solid's `reconcile` option added.
|
|
27
|
-
*
|
|
28
26
|
* @template TQueryFnData - The type of a single page, as your `queryFn` resolves it.
|
|
29
27
|
* @template TError - The type of errors your `queryFn` may throw.
|
|
30
28
|
* @template TData - The type `data` ends up as after `select` runs.
|
|
@@ -43,16 +41,22 @@ interface InfiniteQueryObserverOptions<TQueryFnData = unknown, TError = DefaultE
|
|
|
43
41
|
/**
|
|
44
42
|
* The default options a `QueryClient` applies to every query, with Solid's `reconcile` option added to
|
|
45
43
|
* `queries`.
|
|
46
|
-
*
|
|
47
44
|
* @template TError - The default type of errors thrown by queries and mutations using this `QueryClient`.
|
|
48
45
|
*/
|
|
49
46
|
interface DefaultOptions<TError = DefaultError> extends DefaultOptions$1<TError> {
|
|
47
|
+
/**
|
|
48
|
+
* Default options applied to every query, unless overridden per-query, including Solid's
|
|
49
|
+
* `reconcile` option.
|
|
50
|
+
*/
|
|
50
51
|
queries?: OmitKeyof<QueryObserverOptions<unknown, TError>, 'queryKey'>;
|
|
51
52
|
}
|
|
52
53
|
/**
|
|
53
54
|
* The config accepted by `new QueryClient(config)`, with Solid's extended {@link DefaultOptions}.
|
|
54
55
|
*/
|
|
55
56
|
interface QueryClientConfig extends QueryClientConfig$1 {
|
|
57
|
+
/**
|
|
58
|
+
* The default options of the queries and mutations of this `QueryClient`.
|
|
59
|
+
*/
|
|
56
60
|
defaultOptions?: DefaultOptions;
|
|
57
61
|
}
|
|
58
62
|
/**
|
|
@@ -67,7 +71,6 @@ export declare class QueryClient extends QueryClient$1 {
|
|
|
67
71
|
/**
|
|
68
72
|
* The options accepted by `useQuery`. Extends {@link QueryObserverOptions} from `@tanstack/query-core` with
|
|
69
73
|
* the `solid-query`-specific `deferStream` and `suspense` options.
|
|
70
|
-
*
|
|
71
74
|
* @template TQueryFnData - The type your `queryFn` resolves to.
|
|
72
75
|
* @template TError - The type of errors your `queryFn` may throw.
|
|
73
76
|
* @template TData - The type `data` ends up as after `select` runs. Defaults to `TQueryFnData` when no
|
|
@@ -81,7 +84,6 @@ export interface UseBaseQueryOptions<TQueryFnData = unknown, TError = DefaultErr
|
|
|
81
84
|
* Only applicable while rendering queries on the server with streaming.
|
|
82
85
|
* Set `deferStream` to `true` to wait for the query to resolve on the server before flushing the stream.
|
|
83
86
|
* This can be useful to avoid sending a loading state to the client before the query has resolved.
|
|
84
|
-
*
|
|
85
87
|
* @defaultValue false
|
|
86
88
|
*/
|
|
87
89
|
deferStream?: boolean;
|
|
@@ -94,7 +96,6 @@ export interface UseBaseQueryOptions<TQueryFnData = unknown, TError = DefaultErr
|
|
|
94
96
|
}
|
|
95
97
|
/**
|
|
96
98
|
* The options accepted by `useQuery` and `queryOptions`.
|
|
97
|
-
*
|
|
98
99
|
* @template TQueryFnData - The type your `queryFn` resolves to.
|
|
99
100
|
* @template TError - The type of errors your `queryFn` may throw.
|
|
100
101
|
* @template TData - The type `data` ends up as after `select` runs. Defaults to `TQueryFnData` when no
|
|
@@ -105,7 +106,6 @@ export interface QueryOptions<TQueryFnData = unknown, TError = DefaultError, TDa
|
|
|
105
106
|
/**
|
|
106
107
|
* The accessor `useQuery` expects as its first argument — Solid re-evaluates it reactively, so `queryKey` and
|
|
107
108
|
* other options can depend on signals.
|
|
108
|
-
*
|
|
109
109
|
* @template TQueryFnData - The type your `queryFn` resolves to.
|
|
110
110
|
* @template TError - The type of errors your `queryFn` may throw.
|
|
111
111
|
* @template TData - The type `data` ends up as after `select` runs. Defaults to `TQueryFnData` when no
|
|
@@ -117,7 +117,6 @@ export type UseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData
|
|
|
117
117
|
* The object `useQuery` returns when `initialData` isn't set — `data`/`error` may still be `undefined`/`null`
|
|
118
118
|
* while the query is `pending`. Re-exports {@link QueryObserverResult} from `@tanstack/query-core`.
|
|
119
119
|
* `useInfiniteQuery` returns {@link UseInfiniteQueryResult} instead.
|
|
120
|
-
*
|
|
121
120
|
* @template TData - The type `data` ends up as, after `select` runs (if set).
|
|
122
121
|
* @template TError - The type of errors this query may hold.
|
|
123
122
|
*/
|
|
@@ -125,7 +124,6 @@ export type UseBaseQueryResult<TData = unknown, TError = DefaultError> = QueryOb
|
|
|
125
124
|
/**
|
|
126
125
|
* The object `useQuery` returns — `data`/`error` may still be `undefined`/`null` while the query is
|
|
127
126
|
* `pending`.
|
|
128
|
-
*
|
|
129
127
|
* @template TData - The type `data` ends up as, after `select` runs (if set).
|
|
130
128
|
* @template TError - The type of errors this query may hold.
|
|
131
129
|
*/
|
|
@@ -133,7 +131,6 @@ export type UseQueryResult<TData = unknown, TError = DefaultError> = UseBaseQuer
|
|
|
133
131
|
/**
|
|
134
132
|
* The object `useQuery` returns when `initialData` guarantees `data` is never `undefined` (unless a
|
|
135
133
|
* `select` changes `TData` to include `undefined`).
|
|
136
|
-
*
|
|
137
134
|
* @template TData - The type `data` ends up as, after `select` runs (if set).
|
|
138
135
|
* @template TError - The type of errors this query may hold.
|
|
139
136
|
*/
|
|
@@ -141,14 +138,12 @@ export type DefinedUseBaseQueryResult<TData = unknown, TError = DefaultError> =
|
|
|
141
138
|
/**
|
|
142
139
|
* The object `useQuery` returns when `initialData` guarantees `data` is never `undefined` (unless a
|
|
143
140
|
* `select` changes `TData` to include `undefined`).
|
|
144
|
-
*
|
|
145
141
|
* @template TData - The type `data` ends up as, after `select` runs (if set).
|
|
146
142
|
* @template TError - The type of errors this query may hold.
|
|
147
143
|
*/
|
|
148
144
|
export type DefinedUseQueryResult<TData = unknown, TError = DefaultError> = DefinedUseBaseQueryResult<TData, TError>;
|
|
149
145
|
/**
|
|
150
146
|
* The options accepted by `useInfiniteQuery`.
|
|
151
|
-
*
|
|
152
147
|
* @template TQueryFnData - The type of a single page, as your `queryFn` resolves it.
|
|
153
148
|
* @template TError - The type of errors your `queryFn` may throw.
|
|
154
149
|
* @template TData - The type `data` ends up as after `select` runs.
|
|
@@ -169,7 +164,6 @@ export interface InfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultEr
|
|
|
169
164
|
* Only applicable while rendering queries on the server with streaming.
|
|
170
165
|
* Set `deferStream` to `true` to wait for the query to resolve on the server before flushing the stream.
|
|
171
166
|
* This can be useful to avoid sending a loading state to the client before the query has resolved.
|
|
172
|
-
*
|
|
173
167
|
* @defaultValue false
|
|
174
168
|
*/
|
|
175
169
|
deferStream?: boolean;
|
|
@@ -183,7 +177,6 @@ export interface InfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultEr
|
|
|
183
177
|
/**
|
|
184
178
|
* The accessor `useInfiniteQuery` expects as its first argument — Solid re-evaluates it reactively, so
|
|
185
179
|
* `queryKey` and other options can depend on signals.
|
|
186
|
-
*
|
|
187
180
|
* @template TQueryFnData - The type of a single page, as your `queryFn` resolves it.
|
|
188
181
|
* @template TError - The type of errors your `queryFn` may throw.
|
|
189
182
|
* @template TData - The type `data` ends up as after `select` runs.
|
|
@@ -194,7 +187,6 @@ export type UseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultErro
|
|
|
194
187
|
/**
|
|
195
188
|
* The object `useInfiniteQuery` returns — `data`/`error` may still be `undefined`/`null` while the query is
|
|
196
189
|
* `pending`.
|
|
197
|
-
*
|
|
198
190
|
* @template TData - The type `data` ends up as, after `select` runs (if set).
|
|
199
191
|
* @template TError - The type of errors this query may hold.
|
|
200
192
|
*/
|
|
@@ -202,14 +194,12 @@ export type UseInfiniteQueryResult<TData = unknown, TError = DefaultError> = Inf
|
|
|
202
194
|
/**
|
|
203
195
|
* The object `useInfiniteQuery` returns when `initialData` guarantees `data` is never `undefined` (unless a
|
|
204
196
|
* `select` changes `TData` to include `undefined`).
|
|
205
|
-
*
|
|
206
197
|
* @template TData - The type `data` ends up as, after `select` runs (if set).
|
|
207
198
|
* @template TError - The type of errors this query may hold.
|
|
208
199
|
*/
|
|
209
200
|
export type DefinedUseInfiniteQueryResult<TData = unknown, TError = DefaultError> = DefinedInfiniteQueryObserverResult<TData, TError>;
|
|
210
201
|
/**
|
|
211
202
|
* The options accepted by `useMutation` and `mutationOptions`.
|
|
212
|
-
*
|
|
213
203
|
* @template TData - The type your `mutationFn` resolves to.
|
|
214
204
|
* @template TError - The type of errors your `mutationFn` may throw.
|
|
215
205
|
* @template TVariables - The type of the variables your `mutationFn` accepts.
|
|
@@ -219,18 +209,27 @@ export interface MutationOptions<TData = unknown, TError = DefaultError, TVariab
|
|
|
219
209
|
/**
|
|
220
210
|
* The accessor `useMutation` expects as its first argument — Solid re-evaluates it reactively, so callbacks
|
|
221
211
|
* and other options can depend on signals.
|
|
222
|
-
*
|
|
223
212
|
* @template TData - The type your `mutationFn` resolves to.
|
|
224
213
|
* @template TError - The type of errors your `mutationFn` may throw.
|
|
225
214
|
* @template TVariables - The type of the variables your `mutationFn` accepts.
|
|
226
215
|
* @template TOnMutateResult - The type returned by `onMutate`, passed on to `onSuccess`/`onError`/`onSettled`.
|
|
227
216
|
*/
|
|
228
217
|
export type UseMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = Accessor<MutationOptions<TData, TError, TVariables, TOnMutateResult>>;
|
|
218
|
+
/**
|
|
219
|
+
* The type of `mutate`, as returned by `useMutation`. Forwards the variables (and an optional per-call
|
|
220
|
+
* `onSuccess`/`onError`/`onSettled`) to the underlying `mutate` call. Fire-and-forget — errors are surfaced
|
|
221
|
+
* through the mutation result instead of being thrown by `mutate`, unless `throwOnError` makes `useMutation`
|
|
222
|
+
* rethrow them.
|
|
223
|
+
* @template TData - The type your mutation function resolves to.
|
|
224
|
+
* @template TError - The type of errors your mutation function may throw.
|
|
225
|
+
* @template TVariables - The type of the variable passed to `mutate`.
|
|
226
|
+
* @template TOnMutateResult - The type returned by `onMutate`, passed to `onSuccess`/`onError`/`onSettled` as
|
|
227
|
+
* their `onMutateResult` parameter — useful for optimistic-update rollback data.
|
|
228
|
+
*/
|
|
229
229
|
export type UseMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TOnMutateResult>>) => void;
|
|
230
230
|
/**
|
|
231
231
|
* The type of `mutateAsync`, as returned by `useMutation`. Similar to {@link UseMutateFunction}, but returns a
|
|
232
232
|
* promise which can be awaited.
|
|
233
|
-
*
|
|
234
233
|
* @template TData - The type your `mutationFn` resolves to.
|
|
235
234
|
* @template TError - The type of errors your `mutationFn` may throw.
|
|
236
235
|
* @template TVariables - The type of the variable passed to `mutateAsync`.
|
|
@@ -241,7 +240,6 @@ export type UseMutateAsyncFunction<TData = unknown, TError = DefaultError, TVari
|
|
|
241
240
|
/**
|
|
242
241
|
* The result of `useMutation`. Same as {@link MutationObserverResult} from `@tanstack/query-core`, with
|
|
243
242
|
* `mutate` narrowed to the fire-and-forget {@link UseMutateFunction} signature, plus the added `mutateAsync`.
|
|
244
|
-
*
|
|
245
243
|
* @template TData - The type your `mutationFn` resolves to.
|
|
246
244
|
* @template TError - The type of errors your `mutationFn` may throw.
|
|
247
245
|
* @template TVariables - The type of the variable passed to `mutate`/`mutateAsync`.
|
|
@@ -258,7 +256,6 @@ export type UseBaseMutationResult<TData = unknown, TError = DefaultError, TVaria
|
|
|
258
256
|
};
|
|
259
257
|
/**
|
|
260
258
|
* The result of `useMutation`. Same as {@link UseBaseMutationResult}.
|
|
261
|
-
*
|
|
262
259
|
* @template TData - The type your `mutationFn` resolves to.
|
|
263
260
|
* @template TError - The type of errors your `mutationFn` may throw.
|
|
264
261
|
* @template TVariables - The type of the variable passed to `mutate`/`mutateAsync`.
|
|
@@ -273,7 +270,6 @@ export type UseMutationResult<TData = unknown, TError = DefaultError, TVariables
|
|
|
273
270
|
* `undefined` while the query is `pending`. `queryOptions` itself accepts and returns a plain object (its
|
|
274
271
|
* parameter type is `ReturnType<UndefinedInitialDataOptions<...>>`, i.e. this `Accessor` called); Solid's
|
|
275
272
|
* reactivity applies where the result is consumed instead, e.g. `useQuery(() => options)`.
|
|
276
|
-
*
|
|
277
273
|
* @template TQueryFnData - The type your `queryFn` resolves to.
|
|
278
274
|
* @template TError - The type of errors your `queryFn` may throw.
|
|
279
275
|
* @template TData - The type `data` ends up as after `select` runs.
|
|
@@ -285,7 +281,6 @@ type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError,
|
|
|
285
281
|
/**
|
|
286
282
|
* The options accepted by the `queryOptions` overload selected when `initialData` is set — `data` is never
|
|
287
283
|
* `undefined` (unless a `select` changes `TData` to include `undefined`).
|
|
288
|
-
*
|
|
289
284
|
* @template TQueryFnData - The type your `queryFn` resolves to.
|
|
290
285
|
* @template TError - The type of errors your `queryFn` may throw.
|
|
291
286
|
* @template TData - The type `data` ends up as after `select` runs.
|
|
@@ -301,11 +296,9 @@ type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TD
|
|
|
301
296
|
*
|
|
302
297
|
* This overload is selected when `initialData` is set, so the resulting `data` is never `undefined` (unless
|
|
303
298
|
* a `select` changes `TData` to include `undefined`).
|
|
304
|
-
*
|
|
305
|
-
* @see {@link useQuery} to run a query with these options.
|
|
306
299
|
* @param options - The {@link DefinedInitialDataOptions} to use — everything you can pass to `useQuery`, with `initialData` set.
|
|
307
300
|
* @returns The same options object, typed so that `queryKey` carries the inferred data type.
|
|
308
|
-
*
|
|
301
|
+
* @see {@link useQuery} to run a query with these options.
|
|
309
302
|
* @example
|
|
310
303
|
* ```tsx
|
|
311
304
|
* import { For } from 'solid-js'
|
|
@@ -338,11 +331,9 @@ export declare function queryOptions<TQueryFnData = unknown, TError = DefaultErr
|
|
|
338
331
|
* You can generally pass everything to `queryOptions` that you can also pass to `useQuery`. These options can
|
|
339
332
|
* be shared across hooks and imperative APIs such as `queryClient.query`. `options.queryKey` is required and
|
|
340
333
|
* is the query key to generate options for.
|
|
341
|
-
*
|
|
342
|
-
* @see {@link useQuery} to run a query with these options.
|
|
343
334
|
* @param options - The {@link UndefinedInitialDataOptions} to use — everything you can pass to `useQuery`.
|
|
344
335
|
* @returns The same options object, typed so that `queryKey` carries the inferred data type.
|
|
345
|
-
*
|
|
336
|
+
* @see {@link useQuery} to run a query with these options.
|
|
346
337
|
* @example
|
|
347
338
|
* A parameterized factory, so the same options object can be reused per `id`:
|
|
348
339
|
* ```tsx
|
|
@@ -376,8 +367,6 @@ export declare function queryOptions<TQueryFnData = unknown, TError = DefaultErr
|
|
|
376
367
|
/**
|
|
377
368
|
* Subscribes to a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
|
|
378
369
|
* The query runs when the options call for it — `enabled: false` skips the initial fetch.
|
|
379
|
-
*
|
|
380
|
-
* @see {@link queryOptions} to share these options between `useQuery` and imperative APIs like `queryClient.query`.
|
|
381
370
|
* @param options - An accessor returning the {@link UndefinedInitialDataOptions} to use — everything you can
|
|
382
371
|
* pass to `useQuery`.
|
|
383
372
|
* @param queryClient - An accessor for a custom `QueryClient`. Otherwise, the one from the nearest context
|
|
@@ -385,7 +374,7 @@ export declare function queryOptions<TQueryFnData = unknown, TError = DefaultErr
|
|
|
385
374
|
* @returns The current query result, as a Solid store. `status` is `pending` if there is no cached data to
|
|
386
375
|
* display, `error` if the last fetch attempt failed, or `success` if the query has data to display.
|
|
387
376
|
* `isPending`/`isSuccess`/`isError` are derived booleans for convenience.
|
|
388
|
-
*
|
|
377
|
+
* @see {@link queryOptions} to share these options between `useQuery` and imperative APIs like `queryClient.query`.
|
|
389
378
|
* @example
|
|
390
379
|
* ```tsx
|
|
391
380
|
* import { For, Match, Switch } from 'solid-js'
|
|
@@ -411,7 +400,6 @@ export declare function queryOptions<TQueryFnData = unknown, TError = DefaultErr
|
|
|
411
400
|
* )
|
|
412
401
|
* }
|
|
413
402
|
* ```
|
|
414
|
-
*
|
|
415
403
|
* @example
|
|
416
404
|
* `select` derives whatever `data` a component needs from the cached value, without changing what's
|
|
417
405
|
* actually stored in the cache — the cache still holds the full `Post[]`, but `data` here is a `number`:
|
|
@@ -435,7 +423,6 @@ export declare function queryOptions<TQueryFnData = unknown, TError = DefaultErr
|
|
|
435
423
|
* )
|
|
436
424
|
* }
|
|
437
425
|
* ```
|
|
438
|
-
*
|
|
439
426
|
* @example
|
|
440
427
|
* A dependent query, only enabled once `postId` is set:
|
|
441
428
|
* ```tsx
|
|
@@ -458,7 +445,6 @@ export declare function queryOptions<TQueryFnData = unknown, TError = DefaultErr
|
|
|
458
445
|
* )
|
|
459
446
|
* }
|
|
460
447
|
* ```
|
|
461
|
-
*
|
|
462
448
|
* @example
|
|
463
449
|
* The same dependent query, using `skipToken` to disable it in a type-safe way instead of relying on
|
|
464
450
|
* `enabled`. The non-null assertion is still needed — Solid's `props` narrowing doesn't survive into the
|
|
@@ -484,7 +470,6 @@ export declare function queryOptions<TQueryFnData = unknown, TError = DefaultErr
|
|
|
484
470
|
* )
|
|
485
471
|
* }
|
|
486
472
|
* ```
|
|
487
|
-
*
|
|
488
473
|
* @example
|
|
489
474
|
* Seeding a detail query from an already-cached list, to skip the loading state. `initialDataUpdatedAt` carries
|
|
490
475
|
* over the list's own fetch time, so that if you set a `staleTime`, it's measured from when the list was
|
|
@@ -509,7 +494,6 @@ export declare function queryOptions<TQueryFnData = unknown, TError = DefaultErr
|
|
|
509
494
|
* return postQuery.isError ? <span>Error: {postQuery.error.message}</span> : <h1>{postQuery.data?.title}</h1>
|
|
510
495
|
* }
|
|
511
496
|
* ```
|
|
512
|
-
*
|
|
513
497
|
* @example
|
|
514
498
|
* Paginated data, keeping the previous page's data visible while the next page loads:
|
|
515
499
|
* ```tsx
|
|
@@ -548,8 +532,6 @@ export declare function useQuery<TQueryFnData = unknown, TError = DefaultError,
|
|
|
548
532
|
*
|
|
549
533
|
* This overload is selected when `initialData` is set, so the resulting `data` is never `undefined` (unless
|
|
550
534
|
* a `select` changes `TData` to include `undefined`).
|
|
551
|
-
*
|
|
552
|
-
* @see {@link queryOptions} to share these options between `useQuery` and imperative APIs like `queryClient.query`.
|
|
553
535
|
* @param options - An accessor returning the {@link DefinedInitialDataOptions} to use — everything you can
|
|
554
536
|
* pass to `useQuery`, with `initialData` set.
|
|
555
537
|
* @param queryClient - An accessor for a custom `QueryClient`. Otherwise, the one from the nearest context
|
|
@@ -558,7 +540,7 @@ export declare function useQuery<TQueryFnData = unknown, TError = DefaultError,
|
|
|
558
540
|
* fetch attempt fails while keeping the existing data (`status` never resolves to `pending` in this overload's
|
|
559
541
|
* type, since `initialData` guarantees data upfront). `isSuccess`/`isError` are derived booleans for
|
|
560
542
|
* convenience.
|
|
561
|
-
*
|
|
543
|
+
* @see {@link queryOptions} to share these options between `useQuery` and imperative APIs like `queryClient.query`.
|
|
562
544
|
* @example
|
|
563
545
|
* ```tsx
|
|
564
546
|
* import { For } from 'solid-js'
|
|
@@ -593,7 +575,6 @@ export declare function useQuery<TQueryFnData = unknown, TError = DefaultError,
|
|
|
593
575
|
* object (its parameter type is `ReturnType<UndefinedInitialDataInfiniteOptions<...>>`, i.e. this `Accessor`
|
|
594
576
|
* called); Solid's reactivity applies where the result is consumed instead, e.g.
|
|
595
577
|
* `useInfiniteQuery(() => options)`.
|
|
596
|
-
*
|
|
597
578
|
* @template TQueryFnData - The type of a single page, as your `queryFn` resolves it.
|
|
598
579
|
* @template TError - The type of errors your `queryFn` may throw.
|
|
599
580
|
* @template TData - The type `data` ends up as after `select` runs — defaults to `InfiniteData<TQueryFnData>`,
|
|
@@ -607,7 +588,6 @@ type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TD
|
|
|
607
588
|
/**
|
|
608
589
|
* The options accepted by the `infiniteQueryOptions` overload selected when `initialData` is set — `data` is
|
|
609
590
|
* never `undefined` (unless a `select` changes `TData` to include `undefined`).
|
|
610
|
-
*
|
|
611
591
|
* @template TQueryFnData - The type of a single page, as your `queryFn` resolves it.
|
|
612
592
|
* @template TError - The type of errors your `queryFn` may throw.
|
|
613
593
|
* @template TData - The type `data` ends up as after `select` runs — defaults to `InfiniteData<TQueryFnData>`,
|
|
@@ -624,11 +604,9 @@ type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TDat
|
|
|
624
604
|
* `options.queryKey` is required and is the query key to generate options for.
|
|
625
605
|
*
|
|
626
606
|
* This overload is selected when `initialData` is set.
|
|
627
|
-
*
|
|
628
|
-
* @see {@link useInfiniteQuery} to run an infinite query with these options.
|
|
629
607
|
* @param options - The {@link DefinedInitialDataInfiniteOptions} to use — everything you can pass to `useInfiniteQuery`, with `initialData` set.
|
|
630
608
|
* @returns The same options object, typed so that `queryKey` carries the inferred data type.
|
|
631
|
-
*
|
|
609
|
+
* @see {@link useInfiniteQuery} to run an infinite query with these options.
|
|
632
610
|
* @example
|
|
633
611
|
* ```tsx
|
|
634
612
|
* import { For } from 'solid-js'
|
|
@@ -665,11 +643,9 @@ export declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError
|
|
|
665
643
|
* You can generally pass everything to `infiniteQueryOptions` that you can also pass to `useInfiniteQuery`.
|
|
666
644
|
* These options can be shared across hooks and imperative APIs such as `queryClient.infiniteQuery`.
|
|
667
645
|
* `options.queryKey` is required and is the query key to generate options for.
|
|
668
|
-
*
|
|
669
|
-
* @see {@link useInfiniteQuery} to run an infinite query with these options.
|
|
670
646
|
* @param options - The {@link UndefinedInitialDataInfiniteOptions} to use — everything you can pass to `useInfiniteQuery`.
|
|
671
647
|
* @returns The same options object, typed so that `queryKey` carries the inferred data type.
|
|
672
|
-
*
|
|
648
|
+
* @see {@link useInfiniteQuery} to run an infinite query with these options.
|
|
673
649
|
* @example
|
|
674
650
|
* A parameterized factory, so the same options object can be reused per `postId`:
|
|
675
651
|
* ```tsx
|
|
@@ -711,11 +687,6 @@ export declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError
|
|
|
711
687
|
* `initialPageParam`, `getNextPageParam`, `getPreviousPageParam`, and `maxPages`.
|
|
712
688
|
*
|
|
713
689
|
* This overload is selected when `initialData` is set.
|
|
714
|
-
*
|
|
715
|
-
* @remarks Keep in mind that imperative fetch calls, such as `fetchNextPage`, may interfere with the default
|
|
716
|
-
* refetch behavior, resulting in outdated data. Make sure to call these functions only in response to user
|
|
717
|
-
* actions, or add conditions like `hasNextPage && !isFetching`.
|
|
718
|
-
* @see {@link infiniteQueryOptions} to share these options between `useInfiniteQuery` and imperative APIs like `queryClient.infiniteQuery`.
|
|
719
690
|
* @param options - An accessor returning the {@link DefinedInitialDataInfiniteOptions} to use — everything you
|
|
720
691
|
* can pass to `useInfiniteQuery`, with `initialData` set.
|
|
721
692
|
* @param queryClient - An accessor for a custom `QueryClient`. Otherwise, the one from the nearest context
|
|
@@ -724,7 +695,10 @@ export declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError
|
|
|
724
695
|
* `hasNextPage`, `hasPreviousPage`, `isFetchingNextPage`, and `isFetchingPreviousPage`. `data.pages` and
|
|
725
696
|
* `data.pageParams` are also added, as long as a `select` doesn't change `TData` away from its default
|
|
726
697
|
* `InfiniteData<TQueryFnData>` shape.
|
|
727
|
-
*
|
|
698
|
+
* @remarks Keep in mind that imperative fetch calls, such as `fetchNextPage`, may interfere with the default
|
|
699
|
+
* refetch behavior, resulting in outdated data. Make sure to call these functions only in response to user
|
|
700
|
+
* actions, or add conditions like `hasNextPage && !isFetching`.
|
|
701
|
+
* @see {@link infiniteQueryOptions} to share these options between `useInfiniteQuery` and imperative APIs like `queryClient.infiniteQuery`.
|
|
728
702
|
* @example
|
|
729
703
|
* ```tsx
|
|
730
704
|
* import { For } from 'solid-js'
|
|
@@ -758,11 +732,6 @@ export declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TD
|
|
|
758
732
|
/**
|
|
759
733
|
* The options for `useInfiniteQuery` are identical to `useQuery`, with the addition of
|
|
760
734
|
* `initialPageParam`, `getNextPageParam`, `getPreviousPageParam`, and `maxPages`.
|
|
761
|
-
*
|
|
762
|
-
* @remarks Keep in mind that imperative fetch calls, such as `fetchNextPage`, may interfere with the default
|
|
763
|
-
* refetch behavior, resulting in outdated data. Make sure to call these functions only in response to user
|
|
764
|
-
* actions, or add conditions like `hasNextPage && !isFetching`.
|
|
765
|
-
* @see {@link infiniteQueryOptions} to share these options between `useInfiniteQuery` and imperative APIs like `queryClient.infiniteQuery`.
|
|
766
735
|
* @param options - An accessor returning the {@link UndefinedInitialDataInfiniteOptions} to use — everything
|
|
767
736
|
* you can pass to `useInfiniteQuery`.
|
|
768
737
|
* @param queryClient - An accessor for a custom `QueryClient`. Otherwise, the one from the nearest context
|
|
@@ -771,7 +740,10 @@ export declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TD
|
|
|
771
740
|
* `hasNextPage`, `hasPreviousPage`, `isFetchingNextPage`, and `isFetchingPreviousPage`. `data.pages` and
|
|
772
741
|
* `data.pageParams` are also added, as long as a `select` doesn't change `TData` away from its default
|
|
773
742
|
* `InfiniteData<TQueryFnData>` shape.
|
|
774
|
-
*
|
|
743
|
+
* @remarks Keep in mind that imperative fetch calls, such as `fetchNextPage`, may interfere with the default
|
|
744
|
+
* refetch behavior, resulting in outdated data. Make sure to call these functions only in response to user
|
|
745
|
+
* actions, or add conditions like `hasNextPage && !isFetching`.
|
|
746
|
+
* @see {@link infiniteQueryOptions} to share these options between `useInfiniteQuery` and imperative APIs like `queryClient.infiniteQuery`.
|
|
775
747
|
* @example
|
|
776
748
|
* Fetching the next page from a "Load More" button click:
|
|
777
749
|
* ```tsx
|
|
@@ -811,7 +783,6 @@ export declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TD
|
|
|
811
783
|
* )
|
|
812
784
|
* }
|
|
813
785
|
* ```
|
|
814
|
-
*
|
|
815
786
|
* @example
|
|
816
787
|
* Fetching the next page automatically as the user scrolls, using an `IntersectionObserver` on a
|
|
817
788
|
* sentinel element after the list:
|
|
@@ -863,7 +834,6 @@ export declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TD
|
|
|
863
834
|
/**
|
|
864
835
|
* Unlike queries, mutations are typically used to create/update/delete data or perform server side-effects.
|
|
865
836
|
* `useMutation` is the primitive for that.
|
|
866
|
-
*
|
|
867
837
|
* @param options - An accessor returning the {@link UseMutationOptions} to use.
|
|
868
838
|
* @param queryClient - An accessor for a custom `QueryClient`. Otherwise, the one from the nearest context
|
|
869
839
|
* will be used.
|
|
@@ -872,7 +842,6 @@ export declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TD
|
|
|
872
842
|
* mutation definition. Hook-level callbacks (passed to `options`) fire for every mutation; per-call callbacks
|
|
873
843
|
* fire only for the latest call you've made, and only while the component is still mounted — unmounting before
|
|
874
844
|
* the mutation settles removes the subscription and prevents them from firing.
|
|
875
|
-
*
|
|
876
845
|
* @example
|
|
877
846
|
* ```tsx
|
|
878
847
|
* import { useMutation, useQueryClient } from '@tanstack/solid-query'
|
|
@@ -894,7 +863,6 @@ export declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TD
|
|
|
894
863
|
* )
|
|
895
864
|
* }
|
|
896
865
|
* ```
|
|
897
|
-
*
|
|
898
866
|
* @example
|
|
899
867
|
* Rendering the mutation's own state, rather than just firing it off:
|
|
900
868
|
* ```tsx
|
|
@@ -920,7 +888,6 @@ export declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TD
|
|
|
920
888
|
* )
|
|
921
889
|
* }
|
|
922
890
|
* ```
|
|
923
|
-
*
|
|
924
891
|
* @example
|
|
925
892
|
* Optimistic update via `onMutate`, rolling back on `onError`:
|
|
926
893
|
* ```tsx
|
|
@@ -956,7 +923,6 @@ export declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TD
|
|
|
956
923
|
* )
|
|
957
924
|
* }
|
|
958
925
|
* ```
|
|
959
|
-
*
|
|
960
926
|
* @example
|
|
961
927
|
* Callbacks passed per call to `mutate` only fire for the last call — `mutateAsync` gives you a
|
|
962
928
|
* promise per call instead, so you can wait for all of them when they succeed:
|
|
@@ -986,7 +952,6 @@ export declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TD
|
|
|
986
952
|
* )
|
|
987
953
|
* }
|
|
988
954
|
* ```
|
|
989
|
-
*
|
|
990
955
|
* @example
|
|
991
956
|
* If some of the mutations above can fail independently of the others, and you want to know which ones
|
|
992
957
|
* did — rather than losing that information the moment the first one rejects — swap `Promise.all` for
|
|
@@ -1097,7 +1062,6 @@ type QueriesResults<T extends Array<any>, TResult extends Array<any> = [], TDept
|
|
|
1097
1062
|
* will be used.
|
|
1098
1063
|
* @returns The combined result. Without `combine`, this is an array with all the query results, in the same
|
|
1099
1064
|
* order as the input. When `combine` is provided, this is the value returned by `combine` instead.
|
|
1100
|
-
*
|
|
1101
1065
|
* @example
|
|
1102
1066
|
* ```tsx
|
|
1103
1067
|
* import { For } from 'solid-js'
|
|
@@ -1125,7 +1089,6 @@ type QueriesResults<T extends Array<any>, TResult extends Array<any> = [], TDept
|
|
|
1125
1089
|
* )
|
|
1126
1090
|
* }
|
|
1127
1091
|
* ```
|
|
1128
|
-
*
|
|
1129
1092
|
* @example
|
|
1130
1093
|
* Combining results into a single value:
|
|
1131
1094
|
* ```tsx
|
|
@@ -1174,11 +1137,11 @@ export declare function useQueries<T extends Array<any>, TCombinedResult extends
|
|
|
1174
1137
|
export declare const QueryClientContext: import("solid-js").Context<(() => QueryClient) | undefined>;
|
|
1175
1138
|
/**
|
|
1176
1139
|
* The `useQueryClient` primitive returns the current `QueryClient` instance.
|
|
1177
|
-
*
|
|
1178
1140
|
* @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will
|
|
1179
1141
|
* be used.
|
|
1180
1142
|
* @returns The current `QueryClient` instance.
|
|
1181
|
-
* @throws If no `queryClient` argument is passed and no `QueryClientProvider` is found in the
|
|
1143
|
+
* @throws {Error} If no `queryClient` argument is passed and no `QueryClientProvider` is found in the
|
|
1144
|
+
* component tree.
|
|
1182
1145
|
*/
|
|
1183
1146
|
export declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
|
|
1184
1147
|
/**
|
|
@@ -1201,9 +1164,8 @@ type QueryClientProviderProps = {
|
|
|
1201
1164
|
* calls `client.mount()`/`client.unmount()` as this component mounts/unmounts, which subscribes the client to
|
|
1202
1165
|
* focus/online events (resuming any paused mutations and refetching as needed when the app regains focus or
|
|
1203
1166
|
* comes back online).
|
|
1204
|
-
*
|
|
1167
|
+
* @param props - The `client` to provide, and the `children` that get access to it.
|
|
1205
1168
|
* @returns The provided `children`, wrapped so they can read the `QueryClient` via `useQueryClient`.
|
|
1206
|
-
*
|
|
1207
1169
|
* @example
|
|
1208
1170
|
* ```tsx
|
|
1209
1171
|
* import { QueryClient, QueryClientProvider } from '@tanstack/solid-query'
|
|
@@ -1221,13 +1183,11 @@ export declare const QueryClientProvider: (props: QueryClientProviderProps) => J
|
|
|
1221
1183
|
/**
|
|
1222
1184
|
* The `useIsFetching` primitive returns the `number` of the queries that your application is loading or fetching
|
|
1223
1185
|
* in the background (useful for app-wide loading indicators).
|
|
1224
|
-
*
|
|
1225
1186
|
* @param filters - An accessor returning the {@link QueryFilters} to narrow down the matched queries.
|
|
1226
1187
|
* @param queryClient - An accessor for a custom `QueryClient`. Otherwise, the one from the nearest context
|
|
1227
1188
|
* will be used.
|
|
1228
1189
|
* @returns An accessor for the `number` of the queries that your application is currently loading or fetching
|
|
1229
1190
|
* in the background.
|
|
1230
|
-
*
|
|
1231
1191
|
* @example
|
|
1232
1192
|
* ```tsx
|
|
1233
1193
|
* import { useIsFetching } from '@tanstack/solid-query'
|
|
@@ -1247,12 +1207,10 @@ export declare function useIsFetching(filters?: Accessor<QueryFilters>, queryCli
|
|
|
1247
1207
|
* You can generally pass everything to `mutationOptions` that you can also pass to `useMutation`. A
|
|
1248
1208
|
* `mutationKey` is required on this overload so the mutation can be looked up later, e.g. with
|
|
1249
1209
|
* `useMutationState`.
|
|
1250
|
-
*
|
|
1251
|
-
* @see {@link useMutation} to run the mutation these options describe.
|
|
1252
1210
|
* @param options - The mutation options to use, identical to what you'd pass to `useMutation`, with a
|
|
1253
1211
|
* required `mutationKey`.
|
|
1254
1212
|
* @returns The same options object, unchanged.
|
|
1255
|
-
*
|
|
1213
|
+
* @see {@link useMutation} to run the mutation these options describe.
|
|
1256
1214
|
* @example
|
|
1257
1215
|
* Looking the mutation up elsewhere via its `mutationKey`, e.g. for a global "saving…" indicator:
|
|
1258
1216
|
* ```tsx
|
|
@@ -1278,13 +1236,11 @@ export declare function mutationOptions<TData = unknown, TError = DefaultError,
|
|
|
1278
1236
|
* `mutationKey` is required on this overload — use this when you don't need to target the mutation via a
|
|
1279
1237
|
* `mutationKey` filter later (e.g. with `useMutationState`); it can still be observed through other filters,
|
|
1280
1238
|
* such as `status`.
|
|
1281
|
-
*
|
|
1282
|
-
* @see {@link useMutation} to run the mutation these options describe.
|
|
1283
1239
|
* @param options - The mutation options to use, identical to what you'd pass to `useMutation`, without a
|
|
1284
1240
|
* `mutationKey`.
|
|
1285
1241
|
* @returns The same options object, unchanged.
|
|
1286
1242
|
* @remarks See the other overload's example for looking a mutation up via `useMutationState`.
|
|
1287
|
-
*
|
|
1243
|
+
* @see {@link useMutation} to run the mutation these options describe.
|
|
1288
1244
|
* @example
|
|
1289
1245
|
* ```tsx
|
|
1290
1246
|
* import { mutationOptions, useMutation } from '@tanstack/solid-query'
|
|
@@ -1305,12 +1261,10 @@ export declare function mutationOptions<TData = unknown, TError = DefaultError,
|
|
|
1305
1261
|
/**
|
|
1306
1262
|
* The `useIsMutating` primitive returns the `number` of mutations that your application currently has `pending`
|
|
1307
1263
|
* (useful for app-wide loading indicators).
|
|
1308
|
-
*
|
|
1309
1264
|
* @param filters - An accessor returning the {@link MutationFilters} to narrow down the matched mutations.
|
|
1310
1265
|
* @param queryClient - An accessor for a custom `QueryClient`. Otherwise, the one from the nearest context
|
|
1311
1266
|
* will be used.
|
|
1312
1267
|
* @returns An accessor for the `number` of the mutations that your application currently has `pending`.
|
|
1313
|
-
*
|
|
1314
1268
|
* @example
|
|
1315
1269
|
* ```tsx
|
|
1316
1270
|
* import { useIsMutating } from '@tanstack/solid-query'
|
|
@@ -1335,13 +1289,11 @@ type MutationStateOptions<TResult = MutationState, TMutation extends Mutation<an
|
|
|
1335
1289
|
* `useMutationState` is a primitive that gives you access to all mutations in the `MutationCache`. You can pass
|
|
1336
1290
|
* `filters` ({@link MutationFilters}) to narrow down your mutations, and `select` to transform the mutation
|
|
1337
1291
|
* state.
|
|
1338
|
-
*
|
|
1339
1292
|
* @param options - An accessor returning the `filters` to narrow down matched mutations, and an optional
|
|
1340
1293
|
* `select` to transform the mutation state.
|
|
1341
1294
|
* @param queryClient - An accessor for a custom `QueryClient`. Otherwise, the one from the nearest context
|
|
1342
1295
|
* will be used.
|
|
1343
1296
|
* @returns An accessor for an array of whatever `select` returns for each matching mutation.
|
|
1344
|
-
*
|
|
1345
1297
|
* @example
|
|
1346
1298
|
* Get all variables of all running mutations:
|
|
1347
1299
|
* ```tsx
|
|
@@ -1356,7 +1308,6 @@ type MutationStateOptions<TResult = MutationState, TMutation extends Mutation<an
|
|
|
1356
1308
|
* return <>{pendingVariables().length} posts saving...</>
|
|
1357
1309
|
* }
|
|
1358
1310
|
* ```
|
|
1359
|
-
*
|
|
1360
1311
|
* @example
|
|
1361
1312
|
* Get all data for specific mutations via the `mutationKey`:
|
|
1362
1313
|
* ```tsx
|
|
@@ -1384,7 +1335,6 @@ type MutationStateOptions<TResult = MutationState, TMutation extends Mutation<an
|
|
|
1384
1335
|
* )
|
|
1385
1336
|
* }
|
|
1386
1337
|
* ```
|
|
1387
|
-
*
|
|
1388
1338
|
* @example
|
|
1389
1339
|
* Access the latest successful mutation data via the `mutationKey`. Each invocation of `mutate` adds a new
|
|
1390
1340
|
* entry to the mutation cache for `gcTime` milliseconds — with the `status: 'success'` filter below, check the
|
|
@@ -1411,7 +1361,6 @@ export declare function useMutationState<TResult = MutationState, TMutation exte
|
|
|
1411
1361
|
* If you are using `PersistQueryClientProvider`, you can also use the `useIsRestoring` primitive alongside it to
|
|
1412
1362
|
* check if a restore is currently in progress. `useQuery` and friends also check this internally to avoid
|
|
1413
1363
|
* race conditions between the restore and mounting queries.
|
|
1414
|
-
*
|
|
1415
1364
|
* @returns An accessor that reads `true` while a persisted client is being restored, `false` otherwise.
|
|
1416
1365
|
*/
|
|
1417
1366
|
export declare const useIsRestoring: () => Accessor<boolean>;
|
package/build/index.d.ts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"index.d.ts","names":["QueryCoreObserverOptions","QueryCoreInfiniteQueryObserverOptions","CoreDefaultOptions","QueryCoreClientConfig","QueryCoreClient"],"sources":["../src/QueryClient.ts","../src/types.ts","../src/queryOptions.ts","../src/useQuery.ts","../src/infiniteQueryOptions.ts","../src/useInfiniteQuery.ts","../src/useMutation.ts","../src/useQueries.ts","../src/QueryClientProvider.tsx","../src/useIsFetching.ts","../src/mutationOptions.ts","../src/useIsMutating.ts","../src/useMutationState.ts","../src/isRestoring.ts","../src/index.ts"],"mappings":"
|
|
1
|
+
{"version":3,"file":"index.d.ts","names":["QueryCoreObserverOptions","QueryCoreInfiniteQueryObserverOptions","CoreDefaultOptions","QueryCoreClientConfig","QueryCoreClient"],"sources":["../src/QueryClient.ts","../src/types.ts","../src/queryOptions.ts","../src/useQuery.ts","../src/infiniteQueryOptions.ts","../src/useInfiniteQuery.ts","../src/useMutation.ts","../src/useQueries.ts","../src/QueryClientProvider.tsx","../src/useIsFetching.ts","../src/mutationOptions.ts","../src/useIsMutating.ts","../src/useMutationState.ts","../src/isRestoring.ts","../src/index.ts"],"mappings":"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"}
|