MCPcopy Create free account

hub / github.com/TanStack/query / functions

Functions3,004 in github.com/TanStack/query

↓ 283 callersFunctionsleep
(ms: number)
packages/query-test-utils/src/sleep.ts:6
↓ 208 callersMethodget
* Returns the `Query` instance stored under the given `queryHash`, or `undefined` if none * exists. Unlike {@link QueryCache#find}, this looks up b
packages/query-core/src/queryCache.ts:277
↓ 185 callersFunctioncreateKey
()
packages/query-test-utils/src/createKey.ts:8
↓ 132 callersFunctionuseQuery
(options: UseQueryOptions, queryClient?: QueryClient)
packages/react-query/src/useQuery.ts:295
↓ 110 callersMethodclear
* Removes all queries from the cache. * @example * ```ts * const queryCache = queryClient.getQueryCache() * * queryCache.clear() * `
packages/query-core/src/queryCache.ts:254
↓ 100 callersMethodquery
( options: VueQueryExecutionOptions< QueryExecuteOptions< TQueryFnData, TError,
packages/vue-query/src/queryClient.ts:350
↓ 86 callersMethodfind
( filters: MaybeRefDeep<WithRequired<QueryFilters, 'queryKey'>>, )
packages/vue-query/src/queryCache.ts:17
↓ 80 callersMethodinvalidateQueries
( filters: | MaybeRefDeep<InvalidateQueryFilters<TTaggedQueryKey>> | (() => InvalidateQueryFil
packages/vue-query/src/queryClient.ts:263
↓ 80 callersFunctionuseQueryClient
(queryClient?: QueryClient)
packages/react-query/src/QueryClientProvider.tsx:20
↓ 78 callersMethodmutate
* Builds a new `Mutation` in the `MutationCache` using the observer's * current options, detaches this observer from any previously observed * m
packages/query-core/src/mutationObserver.ts:217
↓ 78 callersFunctionuseQuery
( options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: Accessor<QueryClient>, )
packages/solid-query/src/useQuery.ts:239
↓ 77 callersMethodgetQueryCache
* Returns the query cache this client is connected to. * @returns The {@link QueryCache} instance. * @example * ```ts * import { QueryClie
packages/query-core/src/queryClient.ts:865
↓ 77 callersMethodsetQueryData
( queryKey: MaybeRefDeep<QueryKey>, updater: Updater<TData | undefined, TData | undefined>, option
packages/vue-query/src/queryClient.ts:186
↓ 75 callersFunctionresolve
(value: any)
packages/query-core/src/retryer.ts:190
↓ 71 callersMethodsubscribe
* Registers a listener to be called on every update this object notifies about. Returns a function * that removes the listener again — call it to s
packages/query-core/src/subscribable.ts:31
↓ 67 callersFunctionComponent
({ value }: { value: string })
packages/react-query/src/__tests__/useQuery.test.tsx:490
↓ 66 callersFunctionuseQuery
(options: UseQueryOptions, queryClient?: QueryClient)
packages/preact-query/src/useQuery.ts:294
↓ 63 callersMethodgetQueryData
( queryKey: MaybeRefDeep<QueryKey>, )
packages/vue-query/src/queryClient.ts:105
↓ 59 callersMethodrefetch
* Refetches the observed query and returns a promise that resolves with * the resulting `QueryObserverResult`. * @param options - Set `cancelRef
packages/query-core/src/queryObserver.ts:387
↓ 56 callersMethodfind
* A slightly more advanced method that can be used to get an existing query instance from the * cache. This instance not only contains all the stat
packages/query-core/src/queryCache.ts:324
↓ 54 callersFunctionrender
()
examples/preact/ssr/src/entry-server.tsx:15
↓ 53 callersMethodmount
* Called by a framework adapter's `QueryClientProvider`-equivalent when it mounts, to start * listening for focus/online events and resume paused m
packages/query-core/src/queryClient.ts:103
↓ 52 callersFunctioncreateQueryController
( host: ReactiveControllerHost, options: Accessor< CreateQueryOptions<TQueryFnData, TError, TData, TQu
packages/lit-query/src/createQueryController.ts:348
↓ 51 callersMethodadd
* Adds a query to the cache. * @internal * @param query - The query to add. If a query with the same hash is already cached, nothing * happen
packages/query-core/src/queryCache.ts:208
↓ 50 callersFunctionuseMutation
( options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, queryClient?: QueryClient, )
packages/react-query/src/useMutation.ts:187
↓ 49 callersMethodgetMutationCache
* Returns the mutation cache this client is connected to. * @returns The {@link MutationCache} instance. * @example * ```ts * import { Que
packages/query-core/src/queryClient.ts:881
↓ 48 callersFunctionrender
(component: Type<unknown>)
packages/angular-query/src/__tests__/pending-tasks-ssr.zoneful.test.ts:94
↓ 44 callersFunctioninjectQuery
( optionsFn: () => CreateQueryOptions, )
packages/angular-query/src/inject-query.ts:177
↓ 44 callersMethodtoString
(val: any)
packages/angular-query/src/__tests__/inject-queries.test.ts:246
↓ 43 callersMethodupdate
* Returns the result to expose, tracked through the observer when it uses * property tracking. * @param observer - The observer the result comes
packages/lit-query/src/queryObserverResultTracker.ts:30
↓ 41 callersMethodgetCurrentResult
* Returns the most recently computed `QueryObserverResult` for the * observed query. This is a point-in-time read; to be notified of updates * a
packages/query-core/src/queryObserver.ts:330
↓ 39 callersFunctionqueryOptions
(options: unknown)
packages/react-query/src/queryOptions.ts:251
↓ 39 callersFunctionreject
(value: any)
packages/query-core/src/retryer.ts:198
↓ 38 callersMethodcancelQueries
* Cancels outgoing fetches for queries matching the given filters. Most useful when performing * optimistic updates, since any outgoing refetch tha
packages/query-core/src/queryClient.ts:462
↓ 38 callersFunctioncloneDeepUnref
( obj: MaybeRefDeep<T>, unrefGetters = false, )
packages/vue-query/src/utils.ts:113
↓ 38 callersFunctiondehydrate
( client: QueryClient, options: DehydrateOptions = {}, )
packages/query-core/src/hydration.ts:245
↓ 38 callersFunctionprovideTanStackQuery
( queryClientFactory: () => QueryClient, ...features: ReadonlyArray<QueryFeature> )
packages/angular-query/src/providers.ts:126
↓ 37 callersFunctionqueryOptions
(options: unknown)
packages/vue-query/src/queryOptions.ts:430
↓ 36 callersMethodcancelQueries
( filters: MaybeRefDeep<QueryFilters> = {}, options: MaybeRefDeep<CancelOptions> = {}, )
packages/vue-query/src/queryClient.ts:250
↓ 35 callersMethodbuild
* Returns the existing `Query` instance for the given options' `queryKey`/`queryHash`, or * builds and adds a new one to the cache if none exists y
packages/query-core/src/queryCache.ts:169
↓ 35 callersMethodsetOptions
* Replaces the query's options and applies their `gcTime`. If the query has no data yet, it gets * the `initialData` from the new options, if any.
packages/query-core/src/query.ts:353
↓ 31 callersMethodgetQueryState
( queryKey: MaybeRefDeep<QueryKey>, )
packages/vue-query/src/queryClient.ts:222
↓ 31 callersMethodsetQueryData
* Synchronous way to immediately update a query's cached data. If the updater (or the value * passed) resolves to `undefined`, the cache is left un
packages/query-core/src/queryClient.ts:286
↓ 30 callersMethoddefaultQueryOptions
* Called by framework adapters (e.g. inside `useQuery`) to resolve the options passed by the * caller into their final, defaulted form: merging the
packages/query-core/src/queryClient.ts:1058
↓ 30 callersFunctionhydrate
( client: QueryClient, dehydratedState: Partial<DehydratedState>, options?: HydrateOptions, )
packages/query-core/src/hydration.ts:306
↓ 30 callersFunctionqueryOptions
(options: unknown)
packages/solid-query/src/queryOptions.ts:156
↓ 30 callersFunctionsignal
()
packages/query-core/src/__tests__/streamedQuery.test.tsx:553
↓ 29 callersMethoddestroy
* Clears the query's garbage collection timeout and silently cancels any * in-flight fetch. Called by `QueryCache` when the query is removed from
packages/query-core/src/query.ts:441
↓ 29 callersFunctionqueryOptions
(options: unknown)
packages/preact-query/src/queryOptions.ts:251
↓ 29 callersMethodsetQueryDefaults
* Sets default options for queries whose query key partially matches the given `queryKey`. * * If several registered query defaults match a give
packages/query-core/src/queryClient.ts:938
↓ 28 callersMethodgetAll
* Returns all queries within the cache. * @returns Every query in the cache. * @example * ```ts * const queryCache = queryClient.getQueryC
packages/query-core/src/queryCache.ts:300
↓ 28 callersFunctionref
(initial: T)
packages/svelte-query/tests/utils.svelte.ts:1
↓ 28 callersMethodremove
* Destroys the given `Query` and removes it from the cache, notifying subscribers with a * `'removed'` event. A no-op if the query is no longer the
packages/query-core/src/queryCache.ts:235
↓ 27 callersFunctionuseQueryDevtoolsContext
()
packages/query-devtools/src/contexts/QueryDevtoolsContext.ts:25
↓ 27 callersFunctionuseSuspenseQuery
( options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient, )
packages/react-query/src/useSuspenseQuery.ts:73
↓ 26 callersMethodisMutating
( filters: MaybeRefDeep<Omit<MutationFilters, 'status'>> = {}, )
packages/vue-query/src/queryClient.ts:89
↓ 25 callersFunctionuseQueries
( { queries, ...options }: { /** * An array with query option objects, mostly identical t
packages/react-query/src/useQueries.ts:355
↓ 25 callersFunctionuseQueryClient
(queryClient?: QueryClient)
packages/preact-query/src/QueryClientProvider.tsx:21
↓ 24 callersMethodfindAll
* An even more advanced method that can be used to get existing query instances from the cache * that partially match a query key. If no queries ma
packages/query-core/src/queryCache.ts:350
↓ 24 callersFunctionqueryOptions
(options: unknown)
packages/svelte-query/src/queryOptions.ts:132
↓ 24 callersMethodstart
()
packages/angular-query/src/__tests__/upstream-issues.test.ts:158
↓ 23 callersFunctioncreateMutationController
( host: ReactiveControllerHost, options: Accessor< CreateMutationOptions<TData, TError, TVariables, TO
packages/lit-query/src/createMutationController.ts:326
↓ 23 callersFunctionqueryOptions
(options: unknown)
packages/lit-query/src/queryOptions.ts:137
↓ 22 callersFunctiondelay
(ms: number)
examples/lit/basic/src/services/todos/api.ts:13
↓ 22 callersMethodgetOptimisticResult
* Computes the result the observer would produce for the given (already-defaulted) options * right now, building the underlying `Query` if it doesn
packages/query-core/src/queryObserver.ts:281
↓ 22 callersMethodunmount
* The inverse of {@link QueryClient#mount} — called by a framework adapter's * `QueryClientProvider`-equivalent when it unmounts. Only tears down t
packages/query-core/src/queryClient.ts:126
↓ 21 callersMethodgetObserversCount
* Returns the number of observers currently subscribed to this query. * @returns The number of observers. * @example * ```ts * if (query.g
packages/query-core/src/query.ts:673
↓ 21 callersFunctionunsubscribe
()
packages/query-devtools/src/Devtools.tsx:574
↓ 20 callersFunctioninjectMutation
( optionsFn: () => CreateMutationOptions< TData, TError, TVariables, TOnMutateResult >, )
packages/angular-query/src/inject-mutation.ts:154
↓ 20 callersFunctionqueryOptions
(options: unknown)
packages/angular-query/src/query-options.ts:274
↓ 20 callersFunctionuseMutation
( options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, queryClient?: Accessor<QueryCli
packages/solid-query/src/useMutation.ts:170
↓ 20 callersFunctionuseQueryClient
(queryClient?: QueryClient)
packages/solid-query/src/QueryClientProvider.tsx:28
↓ 20 callersFunctionuseTheme
()
packages/query-devtools/src/contexts/ThemeContext.ts:12
↓ 19 callersMethodgetQueryData
* Imperative (non-reactive) way to retrieve data for a QueryKey. * Should only be used in callbacks or functions where reading the latest data is n
packages/query-core/src/queryClient.ts:188
↓ 19 callersMethodinfiniteQuery
( options: MaybeRefDeep< InfiniteQueryExecuteOptions< TQueryFnData, TError,
packages/vue-query/src/queryClient.ts:546
↓ 19 callersFunctionrefetch
(...args)
packages/vue-query/src/useBaseQuery.ts:186
↓ 19 callersMethodsetState
* Merges the given partial state directly into this query's state, notifying observers. Used * by persistence and broadcast plugins to restore a st
packages/query-core/src/query.ts:413
↓ 19 callersFunctionuseSuspenseQuery
( options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient, )
packages/preact-query/src/useSuspenseQuery.ts:92
↓ 18 callersMethodexecute
* Runs the mutation function for the given variables through a retryer, and * drives the mutation's state and lifecycle callbacks through to settle
packages/query-core/src/mutation.ts:301
↓ 18 callersMethodfetchNextPage
* Fetches the next page of the infinite query and returns a promise that * resolves with the resulting `InfiniteQueryObserverResult`. The page *
packages/query-core/src/infiniteQueryObserver.ts:165
↓ 18 callersMethodisFetching
( filters: MaybeRefDeep<Omit<QueryFilters, 'fetchStatus'>> = {}, )
packages/vue-query/src/queryClient.ts:83
↓ 18 callersFunctionmutate
( ...args: Parameters< MutateFunction<TData, TError, TVariables, TOnMutateResult> > )
packages/vue-query/src/useMutation.ts:268
↓ 18 callersFunctionrender
()
examples/vue/2.6-basic/src/main.ts:10
↓ 18 callersMethodrender
()
examples/lit/ssr/src/app.ts:101
↓ 18 callersFunctionwithDevtools
()
packages/angular-query-devtools/src/stub.ts:10
↓ 17 callersMethodfindAll
(filters: MaybeRefDeep<QueryFilters> = {})
packages/vue-query/src/queryCache.ts:27
↓ 17 callersMethodhasListeners
* Returns `true` while at least one listener is registered, `false` once they have all unsubscribed. * @returns `true` if at least one listener is
packages/query-core/src/subscribable.ts:46
↓ 16 callersFunctioncreateMissingQueryClientError
()
packages/lit-query/src/context.ts:81
↓ 16 callersMethodinvalidateQueries
* Marks queries matching the given filters as invalidated. Unlike * {@link QueryClient#removeQueries}, invalidated queries stay in the cache. *
packages/query-core/src/queryClient.ts:495
↓ 16 callersMethodrefetchQueries
* Refetches queries matching the given filters, regardless of whether they are stale. Without * filters, every query in the cache is refetched. Que
packages/query-core/src/queryClient.ts:540
↓ 16 callersMethodremoveQueries
* Removes queries from the cache that match the given filters. Unlike * {@link QueryClient#invalidateQueries} or {@link QueryClient#refetchQueries}
packages/query-core/src/queryClient.ts:398
↓ 16 callersFunctionrenderWithClient
( client: QueryClient, ui: React.ReactElement, )
packages/react-query/src/__tests__/utils.tsx:9
↓ 16 callersFunctionuseMutation
( options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, queryClient?: QueryClient, )
packages/preact-query/src/useMutation.ts:187
↓ 15 callersFunctionclient
()
packages/query-devtools/src/__tests__/contexts/QueryDevtoolsContext.test.tsx:27
↓ 15 callersMethodfetchQuery
* Fetches and caches a query, or returns its cached data if it isn't stale. Unlike in observers, * the fetch isn't retried unless `retry` is set.
packages/query-core/src/queryClient.ts:651
↓ 15 callersMethodgetQueryState
* Imperative (non-reactive) way to retrieve an existing query's state. If the query does not * exist, `undefined` is returned. * @param queryKey
packages/query-core/src/queryClient.ts:371
↓ 15 callersMethodisOnline
* `isOnline` can be used to get the current online state. * @returns `true` if online.
packages/query-core/src/onlineManager.ts:111
↓ 15 callersMethodnotify
* Notifies every cache listener of an event, in one batch. * @internal * @param event - The event passed to every listener.
packages/query-core/src/queryCache.ts:362
↓ 15 callersFunctionprovideAngularQueryChangeDetection
()
packages/angular-query/src/__tests__/test-utils.ts:19
↓ 15 callersMethodresetQueries
* Resets queries matching the given filters back to their initial state (e.g. any * `initialData`), notifying subscribers rather than removing them
packages/query-core/src/queryClient.ts:423
next →1–100 of 3,004, ranked by callers