@tanstack/query-core 4.24.10 → 5.0.0-alpha.1

package/build/lib/subscribable.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"subscribable.mjs","sources":["../../src/subscribable.ts"],"sourcesContent":["type Listener = () => void\n\nexport class Subscribable<TListener extends Function = Listener> {\n  protected listeners: TListener[]\n\n  constructor() {\n    this.listeners = []\n    this.subscribe = this.subscribe.bind(this)\n  }\n\n  subscribe(listener: TListener): () => void {\n    this.listeners.push(listener as TListener)\n\n    this.onSubscribe()\n\n    return () => {\n      this.listeners = this.listeners.filter((x) => x !== listener)\n      this.onUnsubscribe()\n    }\n  }\n\n  hasListeners(): boolean {\n    return this.listeners.length > 0\n  }\n\n  protected onSubscribe(): void {\n    // Do nothing\n  }\n\n  protected onUnsubscribe(): void {\n    // Do nothing\n  }\n}\n"],"names":["Subscribable","constructor","listeners","subscribe","bind","listener","push","onSubscribe","filter","x","onUnsubscribe","hasListeners","length"],"mappings":"AAEO,MAAMA,YAAN,CAA0D;AAG/DC,EAAAA,WAAW,GAAG;IACZ,IAAKC,CAAAA,SAAL,GAAiB,EAAjB,CAAA;IACA,IAAKC,CAAAA,SAAL,GAAiB,IAAKA,CAAAA,SAAL,CAAeC,IAAf,CAAoB,IAApB,CAAjB,CAAA;AACD,GAAA;;EAEDD,SAAS,CAACE,QAAD,EAAkC;AACzC,IAAA,IAAA,CAAKH,SAAL,CAAeI,IAAf,CAAoBD,QAApB,CAAA,CAAA;AAEA,IAAA,IAAA,CAAKE,WAAL,EAAA,CAAA;AAEA,IAAA,OAAO,MAAM;AACX,MAAA,IAAA,CAAKL,SAAL,GAAiB,IAAKA,CAAAA,SAAL,CAAeM,MAAf,CAAuBC,CAAD,IAAOA,CAAC,KAAKJ,QAAnC,CAAjB,CAAA;AACA,MAAA,IAAA,CAAKK,aAAL,EAAA,CAAA;KAFF,CAAA;AAID,GAAA;;AAEDC,EAAAA,YAAY,GAAY;AACtB,IAAA,OAAO,IAAKT,CAAAA,SAAL,CAAeU,MAAf,GAAwB,CAA/B,CAAA;AACD,GAAA;;AAESL,EAAAA,WAAW,GAAS;AAE7B,GAAA;;AAESG,EAAAA,aAAa,GAAS;AAE/B,GAAA;;AA7B8D;;;;"}
+{"version":3,"file":"subscribable.mjs","sources":["../../src/subscribable.ts"],"sourcesContent":["type Listener = () => void\n\nexport class Subscribable<TListener extends Function = Listener> {\n  protected listeners: TListener[]\n\n  constructor() {\n    this.listeners = []\n    this.subscribe = this.subscribe.bind(this)\n  }\n\n  subscribe(listener: TListener): () => void {\n    this.listeners.push(listener)\n\n    this.onSubscribe()\n\n    return () => {\n      this.listeners = this.listeners.filter((x) => x !== listener)\n      this.onUnsubscribe()\n    }\n  }\n\n  hasListeners(): boolean {\n    return this.listeners.length > 0\n  }\n\n  protected onSubscribe(): void {\n    // Do nothing\n  }\n\n  protected onUnsubscribe(): void {\n    // Do nothing\n  }\n}\n"],"names":["Subscribable","constructor","listeners","subscribe","bind","listener","push","onSubscribe","filter","x","onUnsubscribe","hasListeners","length"],"mappings":"AAEO,MAAMA,YAAY,CAAwC;AAG/DC,EAAAA,WAAW,GAAG;IACZ,IAAI,CAACC,SAAS,GAAG,EAAE,CAAA;IACnB,IAAI,CAACC,SAAS,GAAG,IAAI,CAACA,SAAS,CAACC,IAAI,CAAC,IAAI,CAAC,CAAA;AAC5C,GAAA;EAEAD,SAAS,CAACE,QAAmB,EAAc;AACzC,IAAA,IAAI,CAACH,SAAS,CAACI,IAAI,CAACD,QAAQ,CAAC,CAAA;IAE7B,IAAI,CAACE,WAAW,EAAE,CAAA;AAElB,IAAA,OAAO,MAAM;AACX,MAAA,IAAI,CAACL,SAAS,GAAG,IAAI,CAACA,SAAS,CAACM,MAAM,CAAEC,CAAC,IAAKA,CAAC,KAAKJ,QAAQ,CAAC,CAAA;MAC7D,IAAI,CAACK,aAAa,EAAE,CAAA;KACrB,CAAA;AACH,GAAA;AAEAC,EAAAA,YAAY,GAAY;AACtB,IAAA,OAAO,IAAI,CAACT,SAAS,CAACU,MAAM,GAAG,CAAC,CAAA;AAClC,GAAA;AAEUL,EAAAA,WAAW,GAAS;AAC5B;AAAA,GAAA;AAGQG,EAAAA,aAAa,GAAS;AAC9B;AAAA,GAAA;AAEJ;;;;"}

package/build/lib/tests/utils.d.ts

@@ -3,13 +3,8 @@
 import type { MutationOptions, QueryClientConfig } from '@tanstack/query-core';
 import { QueryClient } from '@tanstack/query-core';
 export declare function createQueryClient(config?: QueryClientConfig): QueryClient;
-export declare function mockVisibilityState(value: DocumentVisibilityState): jest.SpyInstance<DocumentVisibilityState, []>;
-export declare function mockNavigatorOnLine(value: boolean): jest.SpyInstance<boolean, []>;
-export declare const mockLogger: {
-    log: jest.Mock<any, any>;
-    warn: jest.Mock<any, any>;
-    error: jest.Mock<any, any>;
-};
+export declare function mockVisibilityState(value: DocumentVisibilityState): jest.SpyInstance<DocumentVisibilityState, [], any>;
+export declare function mockNavigatorOnLine(value: boolean): jest.SpyInstance<boolean, [], any>;
 export declare function queryKey(): Array<string>;
 export declare function sleep(timeout: number): Promise<void>;
 export declare function setActTimeout(fn: () => void, ms?: number): NodeJS.Timeout;
@@ -17,9 +12,5 @@ export declare function setActTimeout(fn: () => void, ms?: number): NodeJS.Timeo
  * Assert the parameter is of a specific type.
  */
 export declare const expectType: <T>(_: T) => void;
-/**
- * Assert the parameter is not typed as `any`
- */
-export declare const expectTypeNotAny: <T>(_: 0 extends 1 & T ? never : T) => void;
-export declare const executeMutation: (queryClient: QueryClient, options: MutationOptions<any, any, any, any>) => Promise<unknown>;
+export declare const executeMutation: <TVariables>(queryClient: QueryClient, options: MutationOptions<any, any, TVariables, any>, variables: TVariables) => Promise<any>;
 export declare function setIsServer(isServer: boolean): () => void;

package/build/lib/types.d.ts

@@ -4,20 +4,30 @@ import type { RetryValue, RetryDelayValue } from './retryer';
 import type { QueryFilters, QueryTypeFilter } from './utils';
 import type { QueryCache } from './queryCache';
 import type { MutationCache } from './mutationCache';
-import type { Logger } from './logger';
+export interface Register {
+}
+export declare type RegisteredError = Register extends {
+    defaultError: infer TError;
+} ? TError : Error;
 export declare type QueryKey = readonly unknown[];
-export declare type QueryFunction<T = unknown, TQueryKey extends QueryKey = QueryKey> = (context: QueryFunctionContext<TQueryKey>) => T | Promise<T>;
-export interface QueryFunctionContext<TQueryKey extends QueryKey = QueryKey, TPageParam = any> {
+export declare type QueryFunction<T = unknown, TQueryKey extends QueryKey = QueryKey, TPageParam = never> = (context: QueryFunctionContext<TQueryKey, TPageParam>) => T | Promise<T>;
+export declare type QueryFunctionContext<TQueryKey extends QueryKey = QueryKey, TPageParam = never> = [TPageParam] extends [never] ? {
     queryKey: TQueryKey;
-    signal?: AbortSignal;
-    pageParam?: TPageParam;
+    signal: AbortSignal;
     meta: QueryMeta | undefined;
-}
+} : {
+    queryKey: TQueryKey;
+    signal: AbortSignal;
+    pageParam: TPageParam;
+    meta: QueryMeta | undefined;
+};
 export declare type InitialDataFunction<T> = () => T | undefined;
-export declare type PlaceholderDataFunction<TResult> = () => TResult | undefined;
+declare type NonFunctionGuard<T> = T extends Function ? never : T;
+export declare type PlaceholderDataFunction<TQueryData> = (previousData: TQueryData | undefined) => TQueryData | undefined;
+export declare type QueriesPlaceholderDataFunction<TQueryData> = () => TQueryData | undefined;
 export declare type QueryKeyHashFunction<TQueryKey extends QueryKey> = (queryKey: TQueryKey) => string;
-export declare type GetPreviousPageParamFunction<TQueryFnData = unknown> = (firstPage: TQueryFnData, allPages: TQueryFnData[]) => unknown;
-export declare type GetNextPageParamFunction<TQueryFnData = unknown> = (lastPage: TQueryFnData, allPages: TQueryFnData[]) => unknown;
+export declare type GetPreviousPageParamFunction<TPageParam, TQueryFnData = unknown> = (firstPage: TQueryFnData, allPages: TQueryFnData[]) => TPageParam | undefined;
+export declare type GetNextPageParamFunction<TPageParam, TQueryFnData = unknown> = (lastPage: TQueryFnData, allPages: TQueryFnData[]) => TPageParam | undefined;
 export interface InfiniteData<TData> {
     pages: TData[];
     pageParams: unknown[];
@@ -26,7 +36,7 @@ export interface QueryMeta {
     [index: string]: unknown;
 }
 export declare type NetworkMode = 'online' | 'always' | 'offlineFirst';
-export interface QueryOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> {
+export interface QueryOptions<TQueryFnData = unknown, TError = RegisteredError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> {
     /**
      * If `false`, failed queries will not retry by default.
      * If `true`, failed queries will retry infinitely., failureCount: num
@@ -36,40 +46,48 @@ export interface QueryOptions<TQueryFnData = unknown, TError = unknown, TData =
     retry?: RetryValue<TError>;
     retryDelay?: RetryDelayValue<TError>;
     networkMode?: NetworkMode;
-    cacheTime?: number;
-    isDataEqual?: (oldData: TData | undefined, newData: TData) => boolean;
-    queryFn?: QueryFunction<TQueryFnData, TQueryKey>;
+    gcTime?: number;
+    queryFn?: QueryFunction<TQueryFnData, TQueryKey, TPageParam>;
     queryHash?: string;
     queryKey?: TQueryKey;
     queryKeyHashFn?: QueryKeyHashFunction<TQueryKey>;
     initialData?: TData | InitialDataFunction<TData>;
     initialDataUpdatedAt?: number | (() => number | undefined);
-    behavior?: QueryBehavior<TQueryFnData, TError, TData>;
+    behavior?: QueryBehavior<TQueryFnData, TError, TData, TQueryKey>;
     /**
      * Set this to `false` to disable structural sharing between query results.
      * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom structural sharing logic.
      * Defaults to `true`.
      */
     structuralSharing?: boolean | ((oldData: TData | undefined, newData: TData) => TData);
+    _defaulted?: boolean;
+    /**
+     * Additional payload to be stored on each query.
+     * Use this property to pass information that can be used in other places.
+     */
+    meta?: QueryMeta;
+    /**
+     * Maximum number of pages to store in the data of an infinite query.
+     */
+    maxPages?: number;
+}
+export interface DefaultPageParam<TPageParam = unknown> {
+    defaultPageParam: TPageParam;
+}
+export interface InfiniteQueryPageParamsOptions<TQueryFnData = unknown, TPageParam = unknown> extends DefaultPageParam<TPageParam> {
     /**
      * This function can be set to automatically get the previous cursor for infinite queries.
      * The result will also be used to determine the value of `hasPreviousPage`.
      */
-    getPreviousPageParam?: GetPreviousPageParamFunction<TQueryFnData>;
+    getPreviousPageParam?: GetPreviousPageParamFunction<TPageParam, TQueryFnData>;
     /**
      * This function can be set to automatically get the next cursor for infinite queries.
      * The result will also be used to determine the value of `hasNextPage`.
      */
-    getNextPageParam?: GetNextPageParamFunction<TQueryFnData>;
-    _defaulted?: boolean;
-    /**
-     * Additional payload to be stored on each query.
-     * Use this property to pass information that can be used in other places.
-     */
-    meta?: QueryMeta;
+    getNextPageParam: GetNextPageParamFunction<TPageParam, TQueryFnData>;
 }
-export declare type UseErrorBoundary<TQueryFnData, TError, TQueryData, TQueryKey extends QueryKey> = boolean | ((error: TError, query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => boolean);
-export interface QueryObserverOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends QueryOptions<TQueryFnData, TError, TQueryData, TQueryKey> {
+export declare type ThrowErrors<TQueryFnData, TError, TQueryData, TQueryKey extends QueryKey> = boolean | ((error: TError, query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => boolean);
+export interface QueryObserverOptions<TQueryFnData = unknown, TError = RegisteredError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends QueryOptions<TQueryFnData, TError, TQueryData, TQueryKey, TPageParam> {
     /**
      * Set this to `false` to disable automatic refetching when the query mounts or changes query keys.
      * To refetch the query, use the `refetch` method returned from the `useQuery` instance.
@@ -147,57 +165,47 @@ export interface QueryObserverOptions<TQueryFnData = unknown, TError = unknown,
      * If set to a function, it will be passed the error and the query, and it should return a boolean indicating whether to show the error in an error boundary (`true`) or return the error as state (`false`).
      * Defaults to `false`.
      */
-    useErrorBoundary?: UseErrorBoundary<TQueryFnData, TError, TQueryData, TQueryKey>;
+    throwErrors?: ThrowErrors<TQueryFnData, TError, TQueryData, TQueryKey>;
     /**
      * This option can be used to transform or select a part of the data returned by the query function.
      */
     select?: (data: TQueryData) => TData;
     /**
-     * If set to `true`, the query will suspend when `status === 'loading'`
+     * If set to `true`, the query will suspend when `status === 'pending'`
      * and throw errors when `status === 'error'`.
      * Defaults to `false`.
      */
     suspense?: boolean;
-    /**
-     * Set this to `true` to keep the previous `data` when fetching based on a new query key.
-     * Defaults to `false`.
-     */
-    keepPreviousData?: boolean;
     /**
      * If set, this value will be used as the placeholder data for this particular query observer while the query is still in the `loading` data and no initialData has been provided.
      */
-    placeholderData?: TQueryData | PlaceholderDataFunction<TQueryData>;
+    placeholderData?: NonFunctionGuard<TQueryData> | PlaceholderDataFunction<NonFunctionGuard<TQueryData>>;
     _optimisticResults?: 'optimistic' | 'isRestoring';
 }
 export declare type WithRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
-export declare type DefaultedQueryObserverOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = WithRequired<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'useErrorBoundary' | 'refetchOnReconnect'>;
-export interface InfiniteQueryObserverOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends QueryObserverOptions<TQueryFnData, TError, InfiniteData<TData>, InfiniteData<TQueryData>, TQueryKey> {
+export declare type DefaultedQueryObserverOptions<TQueryFnData = unknown, TError = RegisteredError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = WithRequired<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'throwErrors' | 'refetchOnReconnect'>;
+export interface InfiniteQueryObserverOptions<TQueryFnData = unknown, TError = RegisteredError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends QueryObserverOptions<TQueryFnData, TError, TData, InfiniteData<TQueryData>, TQueryKey, TPageParam>, InfiniteQueryPageParamsOptions<TQueryFnData, TPageParam> {
 }
-export declare type DefaultedInfiniteQueryObserverOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = WithRequired<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'useErrorBoundary' | 'refetchOnReconnect'>;
-export interface FetchQueryOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends QueryOptions<TQueryFnData, TError, TData, TQueryKey> {
+export declare type DefaultedInfiniteQueryObserverOptions<TQueryFnData = unknown, TError = RegisteredError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = WithRequired<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'throwErrors' | 'refetchOnReconnect'>;
+export interface FetchQueryOptions<TQueryFnData = unknown, TError = RegisteredError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends WithRequired<QueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryKey'> {
     /**
      * The time in milliseconds after data is considered stale.
      * If the data is fresh it will be returned from the cache.
      */
     staleTime?: number;
 }
-export interface FetchInfiniteQueryOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends FetchQueryOptions<TQueryFnData, TError, InfiniteData<TData>, TQueryKey> {
+export interface FetchInfiniteQueryOptions<TQueryFnData = unknown, TError = RegisteredError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends FetchQueryOptions<TQueryFnData, TError, InfiniteData<TData>, TQueryKey, TPageParam>, DefaultPageParam<TPageParam> {
 }
 export interface ResultOptions {
     throwOnError?: boolean;
 }
-export interface RefetchPageFilters<TPageData = unknown> {
-    refetchPage?: (lastPage: TPageData, index: number, allPages: TPageData[]) => boolean;
-}
 export interface RefetchOptions extends ResultOptions {
     cancelRefetch?: boolean;
 }
-export interface InvalidateQueryFilters<TPageData = unknown> extends QueryFilters, RefetchPageFilters<TPageData> {
+export interface InvalidateQueryFilters extends QueryFilters {
     refetchType?: QueryTypeFilter | 'none';
 }
-export interface RefetchQueryFilters<TPageData = unknown> extends QueryFilters, RefetchPageFilters<TPageData> {
-}
-export interface ResetQueryFilters<TPageData = unknown> extends QueryFilters, RefetchPageFilters<TPageData> {
+export interface RefetchQueryFilters extends QueryFilters {
 }
 export interface InvalidateOptions extends RefetchOptions {
 }
@@ -205,15 +213,13 @@ export interface ResetOptions extends RefetchOptions {
 }
 export interface FetchNextPageOptions extends ResultOptions {
     cancelRefetch?: boolean;
-    pageParam?: unknown;
 }
 export interface FetchPreviousPageOptions extends ResultOptions {
     cancelRefetch?: boolean;
-    pageParam?: unknown;
 }
-export declare type QueryStatus = 'loading' | 'error' | 'success';
+export declare type QueryStatus = 'pending' | 'error' | 'success';
 export declare type FetchStatus = 'fetching' | 'paused' | 'idle';
-export interface QueryObserverBaseResult<TData = unknown, TError = unknown> {
+export interface QueryObserverBaseResult<TData = unknown, TError = RegisteredError> {
     data: TData | undefined;
     dataUpdatedAt: number;
     error: TError | null;
@@ -226,121 +232,123 @@ export interface QueryObserverBaseResult<TData = unknown, TError = unknown> {
     isFetchedAfterMount: boolean;
     isFetching: boolean;
     isLoading: boolean;
+    isPending: boolean;
     isLoadingError: boolean;
+    /**
+     * @deprecated isInitialLoading is being deprecated in favor of isLoading
+     * and will be removed in the next major version.
+     */
     isInitialLoading: boolean;
     isPaused: boolean;
     isPlaceholderData: boolean;
-    isPreviousData: boolean;
     isRefetchError: boolean;
     isRefetching: boolean;
     isStale: boolean;
     isSuccess: boolean;
-    refetch: <TPageData>(options?: RefetchOptions & RefetchQueryFilters<TPageData>) => Promise<QueryObserverResult<TData, TError>>;
-    remove: () => void;
+    refetch: (options?: RefetchOptions) => Promise<QueryObserverResult<TData, TError>>;
     status: QueryStatus;
     fetchStatus: FetchStatus;
 }
-export interface QueryObserverLoadingResult<TData = unknown, TError = unknown> extends QueryObserverBaseResult<TData, TError> {
+export interface QueryObserverLoadingResult<TData = unknown, TError = RegisteredError> extends QueryObserverBaseResult<TData, TError> {
     data: undefined;
     error: null;
     isError: false;
-    isLoading: true;
+    isPending: true;
     isLoadingError: false;
     isRefetchError: false;
     isSuccess: false;
-    status: 'loading';
+    status: 'pending';
 }
-export interface QueryObserverLoadingErrorResult<TData = unknown, TError = unknown> extends QueryObserverBaseResult<TData, TError> {
+export interface QueryObserverLoadingErrorResult<TData = unknown, TError = RegisteredError> extends QueryObserverBaseResult<TData, TError> {
     data: undefined;
     error: TError;
     isError: true;
-    isLoading: false;
+    isPending: false;
     isLoadingError: true;
     isRefetchError: false;
     isSuccess: false;
     status: 'error';
 }
-export interface QueryObserverRefetchErrorResult<TData = unknown, TError = unknown> extends QueryObserverBaseResult<TData, TError> {
+export interface QueryObserverRefetchErrorResult<TData = unknown, TError = RegisteredError> extends QueryObserverBaseResult<TData, TError> {
     data: TData;
     error: TError;
     isError: true;
-    isLoading: false;
+    isPending: false;
     isLoadingError: false;
     isRefetchError: true;
     isSuccess: false;
     status: 'error';
 }
-export interface QueryObserverSuccessResult<TData = unknown, TError = unknown> extends QueryObserverBaseResult<TData, TError> {
+export interface QueryObserverSuccessResult<TData = unknown, TError = RegisteredError> extends QueryObserverBaseResult<TData, TError> {
     data: TData;
     error: null;
     isError: false;
-    isLoading: false;
+    isPending: false;
     isLoadingError: false;
     isRefetchError: false;
     isSuccess: true;
     status: 'success';
 }
-export declare type DefinedQueryObserverResult<TData = unknown, TError = unknown> = QueryObserverRefetchErrorResult<TData, TError> | QueryObserverSuccessResult<TData, TError>;
-export declare type QueryObserverResult<TData = unknown, TError = unknown> = DefinedQueryObserverResult<TData, TError> | QueryObserverLoadingErrorResult<TData, TError> | QueryObserverLoadingResult<TData, TError>;
-export interface InfiniteQueryObserverBaseResult<TData = unknown, TError = unknown> extends QueryObserverBaseResult<InfiniteData<TData>, TError> {
+export declare type DefinedQueryObserverResult<TData = unknown, TError = RegisteredError> = QueryObserverRefetchErrorResult<TData, TError> | QueryObserverSuccessResult<TData, TError>;
+export declare type QueryObserverResult<TData = unknown, TError = RegisteredError> = DefinedQueryObserverResult<TData, TError> | QueryObserverLoadingErrorResult<TData, TError> | QueryObserverLoadingResult<TData, TError>;
+export interface InfiniteQueryObserverBaseResult<TData = unknown, TError = RegisteredError> extends QueryObserverBaseResult<TData, TError> {
     fetchNextPage: (options?: FetchNextPageOptions) => Promise<InfiniteQueryObserverResult<TData, TError>>;
     fetchPreviousPage: (options?: FetchPreviousPageOptions) => Promise<InfiniteQueryObserverResult<TData, TError>>;
-    hasNextPage?: boolean;
-    hasPreviousPage?: boolean;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
     isFetchingNextPage: boolean;
     isFetchingPreviousPage: boolean;
 }
-export interface InfiniteQueryObserverLoadingResult<TData = unknown, TError = unknown> extends InfiniteQueryObserverBaseResult<TData, TError> {
+export interface InfiniteQueryObserverLoadingResult<TData = unknown, TError = RegisteredError> extends InfiniteQueryObserverBaseResult<TData, TError> {
     data: undefined;
     error: null;
     isError: false;
-    isLoading: true;
+    isPending: true;
     isLoadingError: false;
     isRefetchError: false;
     isSuccess: false;
-    status: 'loading';
+    status: 'pending';
 }
-export interface InfiniteQueryObserverLoadingErrorResult<TData = unknown, TError = unknown> extends InfiniteQueryObserverBaseResult<TData, TError> {
+export interface InfiniteQueryObserverLoadingErrorResult<TData = unknown, TError = RegisteredError> extends InfiniteQueryObserverBaseResult<TData, TError> {
     data: undefined;
     error: TError;
     isError: true;
-    isLoading: false;
+    isPending: false;
     isLoadingError: true;
     isRefetchError: false;
     isSuccess: false;
     status: 'error';
 }
-export interface InfiniteQueryObserverRefetchErrorResult<TData = unknown, TError = unknown> extends InfiniteQueryObserverBaseResult<TData, TError> {
-    data: InfiniteData<TData>;
+export interface InfiniteQueryObserverRefetchErrorResult<TData = unknown, TError = RegisteredError> extends InfiniteQueryObserverBaseResult<TData, TError> {
+    data: TData;
     error: TError;
     isError: true;
-    isLoading: false;
+    isPending: false;
     isLoadingError: false;
     isRefetchError: true;
     isSuccess: false;
     status: 'error';
 }
-export interface InfiniteQueryObserverSuccessResult<TData = unknown, TError = unknown> extends InfiniteQueryObserverBaseResult<TData, TError> {
-    data: InfiniteData<TData>;
+export interface InfiniteQueryObserverSuccessResult<TData = unknown, TError = RegisteredError> extends InfiniteQueryObserverBaseResult<TData, TError> {
+    data: TData;
     error: null;
     isError: false;
-    isLoading: false;
+    isPending: false;
     isLoadingError: false;
     isRefetchError: false;
     isSuccess: true;
     status: 'success';
 }
-export declare type InfiniteQueryObserverResult<TData = unknown, TError = unknown> = InfiniteQueryObserverLoadingErrorResult<TData, TError> | InfiniteQueryObserverLoadingResult<TData, TError> | InfiniteQueryObserverRefetchErrorResult<TData, TError> | InfiniteQueryObserverSuccessResult<TData, TError>;
+export declare type InfiniteQueryObserverResult<TData = unknown, TError = RegisteredError> = InfiniteQueryObserverLoadingErrorResult<TData, TError> | InfiniteQueryObserverLoadingResult<TData, TError> | InfiniteQueryObserverRefetchErrorResult<TData, TError> | InfiniteQueryObserverSuccessResult<TData, TError>;
 export declare type MutationKey = readonly unknown[];
-export declare type MutationStatus = 'idle' | 'loading' | 'success' | 'error';
+export declare type MutationStatus = 'idle' | 'pending' | 'success' | 'error';
 export interface MutationMeta {
     [index: string]: unknown;
 }
 export declare type MutationFunction<TData = unknown, TVariables = unknown> = (variables: TVariables) => Promise<TData>;
-export interface MutationOptions<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> {
+export interface MutationOptions<TData = unknown, TError = RegisteredError, TVariables = void, TContext = unknown> {
     mutationFn?: MutationFunction<TData, TVariables>;
     mutationKey?: MutationKey;
-    variables?: TVariables;
     onMutate?: (variables: TVariables) => Promise<TContext | undefined> | TContext | undefined;
     onSuccess?: (data: TData, variables: TVariables, context: TContext | undefined) => Promise<unknown> | unknown;
     onError?: (error: TError, variables: TVariables, context: TContext | undefined) => Promise<unknown> | unknown;
@@ -348,71 +356,74 @@ export interface MutationOptions<TData = unknown, TError = unknown, TVariables =
     retry?: RetryValue<TError>;
     retryDelay?: RetryDelayValue<TError>;
     networkMode?: NetworkMode;
-    cacheTime?: number;
+    gcTime?: number;
     _defaulted?: boolean;
     meta?: MutationMeta;
 }
-export interface MutationObserverOptions<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> extends MutationOptions<TData, TError, TVariables, TContext> {
-    useErrorBoundary?: boolean | ((error: TError) => boolean);
+export interface MutationObserverOptions<TData = unknown, TError = RegisteredError, TVariables = void, TContext = unknown> extends MutationOptions<TData, TError, TVariables, TContext> {
+    throwErrors?: boolean | ((error: TError) => boolean);
 }
-export interface MutateOptions<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> {
+export interface MutateOptions<TData = unknown, TError = RegisteredError, TVariables = void, TContext = unknown> {
     onSuccess?: (data: TData, variables: TVariables, context: TContext) => void;
     onError?: (error: TError, variables: TVariables, context: TContext | undefined) => void;
     onSettled?: (data: TData | undefined, error: TError | null, variables: TVariables, context: TContext | undefined) => void;
 }
-export declare type MutateFunction<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> = (variables: TVariables, options?: MutateOptions<TData, TError, TVariables, TContext>) => Promise<TData>;
-export interface MutationObserverBaseResult<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> extends MutationState<TData, TError, TVariables, TContext> {
+export declare type MutateFunction<TData = unknown, TError = RegisteredError, TVariables = void, TContext = unknown> = (variables: TVariables, options?: MutateOptions<TData, TError, TVariables, TContext>) => Promise<TData>;
+export interface MutationObserverBaseResult<TData = unknown, TError = RegisteredError, TVariables = void, TContext = unknown> extends MutationState<TData, TError, TVariables, TContext> {
     isError: boolean;
     isIdle: boolean;
-    isLoading: boolean;
+    isPending: boolean;
     isSuccess: boolean;
     mutate: MutateFunction<TData, TError, TVariables, TContext>;
     reset: () => void;
 }
-export interface MutationObserverIdleResult<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TContext> {
+export interface MutationObserverIdleResult<TData = unknown, TError = RegisteredError, TVariables = void, TContext = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TContext> {
     data: undefined;
+    variables: undefined;
     error: null;
     isError: false;
     isIdle: true;
-    isLoading: false;
+    isPending: false;
     isSuccess: false;
     status: 'idle';
 }
-export interface MutationObserverLoadingResult<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TContext> {
+export interface MutationObserverLoadingResult<TData = unknown, TError = RegisteredError, TVariables = void, TContext = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TContext> {
     data: undefined;
+    variables: TVariables;
     error: null;
     isError: false;
     isIdle: false;
-    isLoading: true;
+    isPending: true;
     isSuccess: false;
-    status: 'loading';
+    status: 'pending';
 }
-export interface MutationObserverErrorResult<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TContext> {
+export interface MutationObserverErrorResult<TData = unknown, TError = RegisteredError, TVariables = void, TContext = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TContext> {
     data: undefined;
     error: TError;
+    variables: TVariables;
     isError: true;
     isIdle: false;
-    isLoading: false;
+    isPending: false;
     isSuccess: false;
     status: 'error';
 }
-export interface MutationObserverSuccessResult<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TContext> {
+export interface MutationObserverSuccessResult<TData = unknown, TError = RegisteredError, TVariables = void, TContext = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TContext> {
     data: TData;
     error: null;
+    variables: TVariables;
     isError: false;
     isIdle: false;
-    isLoading: false;
+    isPending: false;
     isSuccess: true;
     status: 'success';
 }
-export declare type MutationObserverResult<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> = MutationObserverIdleResult<TData, TError, TVariables, TContext> | MutationObserverLoadingResult<TData, TError, TVariables, TContext> | MutationObserverErrorResult<TData, TError, TVariables, TContext> | MutationObserverSuccessResult<TData, TError, TVariables, TContext>;
+export declare type MutationObserverResult<TData = unknown, TError = RegisteredError, TVariables = void, TContext = unknown> = MutationObserverIdleResult<TData, TError, TVariables, TContext> | MutationObserverLoadingResult<TData, TError, TVariables, TContext> | MutationObserverErrorResult<TData, TError, TVariables, TContext> | MutationObserverSuccessResult<TData, TError, TVariables, TContext>;
 export interface QueryClientConfig {
     queryCache?: QueryCache;
     mutationCache?: MutationCache;
-    logger?: Logger;
     defaultOptions?: DefaultOptions;
 }
-export interface DefaultOptions<TError = unknown> {
+export interface DefaultOptions<TError = RegisteredError> {
     queries?: QueryObserverOptions<unknown, TError>;
     mutations?: MutationObserverOptions<unknown, TError, unknown, unknown>;
 }
@@ -427,3 +438,4 @@ export declare type NotifyEventType = 'added' | 'removed' | 'updated' | 'observe
 export interface NotifyEvent {
     type: NotifyEventType;
 }
+export {};

package/build/lib/utils.d.ts

@@ -1,6 +1,6 @@
 import type { Mutation } from './mutation';
 import type { Query } from './query';
-import type { FetchStatus, MutationFunction, MutationKey, MutationOptions, QueryFunction, QueryKey, QueryOptions } from './types';
+import type { FetchStatus, MutationKey, MutationStatus, QueryKey, QueryOptions } from './types';
 export interface QueryFilters {
     /**
      * Filter to active queries, inactive queries or all queries
@@ -41,9 +41,9 @@ export interface MutationFilters {
      */
     mutationKey?: MutationKey;
     /**
-     * Include or exclude fetching mutations
+     * Filter by mutation status
      */
-    fetching?: boolean;
+    status?: MutationStatus;
 }
 export declare type DataUpdateFunction<TInput, TOutput> = (input: TInput) => TOutput;
 export declare type Updater<TInput, TOutput> = TOutput | DataUpdateFunction<TInput, TOutput>;
@@ -52,29 +52,19 @@ export declare const isServer: boolean;
 export declare function noop(): undefined;
 export declare function functionalUpdate<TInput, TOutput>(updater: Updater<TInput, TOutput>, input: TInput): TOutput;
 export declare function isValidTimeout(value: unknown): value is number;
-export declare function difference<T>(array1: T[], array2: T[]): T[];
-export declare function replaceAt<T>(array: T[], index: number, value: T): T[];
 export declare function timeUntilStale(updatedAt: number, staleTime?: number): number;
-export declare function parseQueryArgs<TOptions extends QueryOptions<any, any, any, TQueryKey>, TQueryKey extends QueryKey = QueryKey>(arg1: TQueryKey | TOptions, arg2?: QueryFunction<any, TQueryKey> | TOptions, arg3?: TOptions): TOptions;
-export declare function parseMutationArgs<TOptions extends MutationOptions<any, any, any, any>>(arg1: MutationKey | MutationFunction<any, any> | TOptions, arg2?: MutationFunction<any, any> | TOptions, arg3?: TOptions): TOptions;
-export declare function parseFilterArgs<TFilters extends QueryFilters, TOptions = unknown>(arg1?: QueryKey | TFilters, arg2?: TFilters | TOptions, arg3?: TOptions): [TFilters, TOptions | undefined];
-export declare function parseMutationFilterArgs<TFilters extends MutationFilters, TOptions = unknown>(arg1?: QueryKey | TFilters, arg2?: TFilters | TOptions, arg3?: TOptions): [TFilters, TOptions | undefined];
 export declare function matchQuery(filters: QueryFilters, query: Query<any, any, any, any>): boolean;
 export declare function matchMutation(filters: MutationFilters, mutation: Mutation<any, any>): boolean;
 export declare function hashQueryKeyByOptions<TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: QueryOptions<any, any, any, TQueryKey>): string;
 /**
- * Default query keys hash function.
+ * Default query & mutation keys hash function.
  * Hashes the value into a stable hash.
  */
-export declare function hashQueryKey(queryKey: QueryKey): string;
+export declare function hashKey(queryKey: QueryKey | MutationKey): string;
 /**
  * Checks if key `b` partially matches with key `a`.
  */
 export declare function partialMatchKey(a: QueryKey, b: QueryKey): boolean;
-/**
- * Checks if `b` partially matches with `a`.
- */
-export declare function partialDeepEqual(a: any, b: any): boolean;
 /**
  * This function returns `a` if `b` is deeply equal.
  * If not, it will replace any deeply equal children of `b` with those of `a`.
@@ -87,13 +77,13 @@ export declare function replaceEqualDeep<T>(a: unknown, b: T): T;
 export declare function shallowEqualObjects<T>(a: T, b: T): boolean;
 export declare function isPlainArray(value: unknown): boolean;
 export declare function isPlainObject(o: any): o is Object;
-export declare function isQueryKey(value: unknown): value is QueryKey;
-export declare function isError(value: any): value is Error;
 export declare function sleep(timeout: number): Promise<void>;
 /**
  * Schedules a microtask.
  * This can be useful to schedule state updates after rendering.
  */
 export declare function scheduleMicrotask(callback: () => void): void;
-export declare function getAbortController(): AbortController | undefined;
 export declare function replaceData<TData, TOptions extends QueryOptions<any, any, any, any>>(prevData: TData | undefined, data: TData, options: TOptions): TData;
+export declare function keepPreviousData<T>(previousData: T | undefined): T | undefined;
+export declare function addToEnd<T>(items: T[], item: T, max?: number): T[];
+export declare function addToStart<T>(items: T[], item: T, max?: number): T[];