@tanstack/react-query-persist-client 4.2.1 → 4.3.0-beta.3

package/build/types/packages/query-core/src/queryCache.d.ts

@@ -1,64 +0,0 @@
-import { QueryFilters } from './utils';
-import { Action, Query, QueryState } from './query';
-import type { QueryKey, QueryOptions } from './types';
-import type { QueryClient } from './queryClient';
-import { Subscribable } from './subscribable';
-import { QueryObserver } from './queryObserver';
-interface QueryCacheConfig {
-    onError?: (error: unknown, query: Query<unknown, unknown, unknown>) => void;
-    onSuccess?: (data: unknown, query: Query<unknown, unknown, unknown>) => void;
-}
-interface NotifyEventQueryAdded {
-    type: 'added';
-    query: Query<any, any, any, any>;
-}
-interface NotifyEventQueryRemoved {
-    type: 'removed';
-    query: Query<any, any, any, any>;
-}
-interface NotifyEventQueryUpdated {
-    type: 'updated';
-    query: Query<any, any, any, any>;
-    action: Action<any, any>;
-}
-interface NotifyEventQueryObserverAdded {
-    type: 'observerAdded';
-    query: Query<any, any, any, any>;
-    observer: QueryObserver<any, any, any, any, any>;
-}
-interface NotifyEventQueryObserverRemoved {
-    type: 'observerRemoved';
-    query: Query<any, any, any, any>;
-    observer: QueryObserver<any, any, any, any, any>;
-}
-interface NotifyEventQueryObserverResultsUpdated {
-    type: 'observerResultsUpdated';
-    query: Query<any, any, any, any>;
-}
-interface NotifyEventQueryObserverOptionsUpdated {
-    type: 'observerOptionsUpdated';
-    query: Query<any, any, any, any>;
-    observer: QueryObserver<any, any, any, any, any>;
-}
-declare type QueryCacheNotifyEvent = NotifyEventQueryAdded | NotifyEventQueryRemoved | NotifyEventQueryUpdated | NotifyEventQueryObserverAdded | NotifyEventQueryObserverRemoved | NotifyEventQueryObserverResultsUpdated | NotifyEventQueryObserverOptionsUpdated;
-declare type QueryCacheListener = (event: QueryCacheNotifyEvent) => void;
-export declare class QueryCache extends Subscribable<QueryCacheListener> {
-    config: QueryCacheConfig;
-    private queries;
-    private queriesMap;
-    constructor(config?: QueryCacheConfig);
-    build<TQueryFnData, TError, TData, TQueryKey extends QueryKey>(client: QueryClient, options: QueryOptions<TQueryFnData, TError, TData, TQueryKey>, state?: QueryState<TData, TError>): Query<TQueryFnData, TError, TData, TQueryKey>;
-    add(query: Query<any, any, any, any>): void;
-    remove(query: Query<any, any, any, any>): void;
-    clear(): void;
-    get<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueyKey extends QueryKey = QueryKey>(queryHash: string): Query<TQueryFnData, TError, TData, TQueyKey> | undefined;
-    getAll(): Query[];
-    find<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData>(arg1: QueryKey, arg2?: QueryFilters): Query<TQueryFnData, TError, TData> | undefined;
-    findAll(queryKey?: QueryKey, filters?: QueryFilters): Query[];
-    findAll(filters?: QueryFilters): Query[];
-    findAll(arg1?: QueryKey | QueryFilters, arg2?: QueryFilters): Query[];
-    notify(event: QueryCacheNotifyEvent): void;
-    onFocus(): void;
-    onOnline(): void;
-}
-export {};

package/build/types/packages/query-core/src/queryClient.d.ts

@@ -1,65 +0,0 @@
-import { QueryFilters, Updater, MutationFilters } from './utils';
-import type { QueryClientConfig, DefaultOptions, FetchInfiniteQueryOptions, FetchQueryOptions, InfiniteData, InvalidateOptions, InvalidateQueryFilters, MutationKey, MutationObserverOptions, MutationOptions, QueryFunction, QueryKey, QueryObserverOptions, RefetchOptions, RefetchQueryFilters, ResetOptions, ResetQueryFilters, SetDataOptions } from './types';
-import type { QueryState } from './query';
-import { QueryCache } from './queryCache';
-import { MutationCache } from './mutationCache';
-import { CancelOptions, DefaultedQueryObserverOptions } from './types';
-import { Logger } from './logger';
-export declare class QueryClient {
-    private queryCache;
-    private mutationCache;
-    private logger;
-    private defaultOptions;
-    private queryDefaults;
-    private mutationDefaults;
-    private unsubscribeFocus?;
-    private unsubscribeOnline?;
-    constructor(config?: QueryClientConfig);
-    mount(): void;
-    unmount(): void;
-    isFetching(filters?: QueryFilters): number;
-    isFetching(queryKey?: QueryKey, filters?: QueryFilters): number;
-    isMutating(filters?: MutationFilters): number;
-    getQueryData<TData = unknown>(queryKey: QueryKey, filters?: QueryFilters): TData | undefined;
-    getQueriesData<TData = unknown>(queryKey: QueryKey): [QueryKey, TData][];
-    getQueriesData<TData = unknown>(filters: QueryFilters): [QueryKey, TData][];
-    setQueryData<TData>(queryKey: QueryKey, updater: Updater<TData | undefined, TData | undefined>, options?: SetDataOptions): TData | undefined;
-    setQueriesData<TData>(queryKey: QueryKey, updater: Updater<TData | undefined, TData | undefined>, options?: SetDataOptions): [QueryKey, TData | undefined][];
-    setQueriesData<TData>(filters: QueryFilters, updater: Updater<TData | undefined, TData | undefined>, options?: SetDataOptions): [QueryKey, TData | undefined][];
-    getQueryState<TData = unknown, TError = undefined>(queryKey: QueryKey, filters?: QueryFilters): QueryState<TData, TError> | undefined;
-    removeQueries(filters?: QueryFilters): void;
-    removeQueries(queryKey?: QueryKey, filters?: QueryFilters): void;
-    resetQueries<TPageData = unknown>(filters?: ResetQueryFilters<TPageData>, options?: ResetOptions): Promise<void>;
-    resetQueries<TPageData = unknown>(queryKey?: QueryKey, filters?: ResetQueryFilters<TPageData>, options?: ResetOptions): Promise<void>;
-    cancelQueries(filters?: QueryFilters, options?: CancelOptions): Promise<void>;
-    cancelQueries(queryKey?: QueryKey, filters?: QueryFilters, options?: CancelOptions): Promise<void>;
-    invalidateQueries<TPageData = unknown>(filters?: InvalidateQueryFilters<TPageData>, options?: InvalidateOptions): Promise<void>;
-    invalidateQueries<TPageData = unknown>(queryKey?: QueryKey, filters?: InvalidateQueryFilters<TPageData>, options?: InvalidateOptions): Promise<void>;
-    refetchQueries<TPageData = unknown>(filters?: RefetchQueryFilters<TPageData>, options?: RefetchOptions): Promise<void>;
-    refetchQueries<TPageData = unknown>(queryKey?: QueryKey, filters?: RefetchQueryFilters<TPageData>, options?: RefetchOptions): Promise<void>;
-    fetchQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<TData>;
-    fetchQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<TData>;
-    fetchQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, queryFn: QueryFunction<TQueryFnData, TQueryKey>, options?: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<TData>;
-    prefetchQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<void>;
-    prefetchQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<void>;
-    prefetchQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, queryFn: QueryFunction<TQueryFnData, TQueryKey>, options?: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<void>;
-    fetchInfiniteQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<InfiniteData<TData>>;
-    fetchInfiniteQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<InfiniteData<TData>>;
-    fetchInfiniteQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, queryFn: QueryFunction<TQueryFnData, TQueryKey>, options?: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<InfiniteData<TData>>;
-    prefetchInfiniteQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<void>;
-    prefetchInfiniteQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<void>;
-    prefetchInfiniteQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, queryFn: QueryFunction<TQueryFnData, TQueryKey>, options?: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<void>;
-    resumePausedMutations(): Promise<void>;
-    getQueryCache(): QueryCache;
-    getMutationCache(): MutationCache;
-    getLogger(): Logger;
-    getDefaultOptions(): DefaultOptions;
-    setDefaultOptions(options: DefaultOptions): void;
-    setQueryDefaults(queryKey: QueryKey, options: QueryObserverOptions<unknown, any, any, any>): void;
-    getQueryDefaults(queryKey?: QueryKey): QueryObserverOptions<any, any, any, any, any> | undefined;
-    setMutationDefaults(mutationKey: MutationKey, options: MutationObserverOptions<any, any, any, any>): void;
-    getMutationDefaults(mutationKey?: MutationKey): MutationObserverOptions<any, any, any, any> | undefined;
-    defaultQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options?: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> | DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>;
-    defaultMutationOptions<T extends MutationOptions<any, any, any, any>>(options?: T): T;
-    clear(): void;
-}

package/build/types/packages/query-core/src/queryObserver.d.ts

@@ -1,61 +0,0 @@
-import { DefaultedQueryObserverOptions, RefetchPageFilters } from './types';
-import type { QueryKey, QueryObserverOptions, QueryObserverResult, RefetchOptions } from './types';
-import type { Query, Action, FetchOptions } from './query';
-import type { QueryClient } from './queryClient';
-import { Subscribable } from './subscribable';
-declare type QueryObserverListener<TData, TError> = (result: QueryObserverResult<TData, TError>) => void;
-export interface NotifyOptions {
-    cache?: boolean;
-    listeners?: boolean;
-    onError?: boolean;
-    onSuccess?: boolean;
-}
-export interface ObserverFetchOptions extends FetchOptions {
-    throwOnError?: boolean;
-}
-export declare class QueryObserver<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends Subscribable<QueryObserverListener<TData, TError>> {
-    options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>;
-    private client;
-    private currentQuery;
-    private currentQueryInitialState;
-    private currentResult;
-    private currentResultState?;
-    private currentResultOptions?;
-    private previousQueryResult?;
-    private selectError;
-    private selectFn?;
-    private selectResult?;
-    private staleTimeoutId?;
-    private refetchIntervalId?;
-    private currentRefetchInterval?;
-    private trackedProps;
-    constructor(client: QueryClient, options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>);
-    protected bindMethods(): void;
-    protected onSubscribe(): void;
-    protected onUnsubscribe(): void;
-    shouldFetchOnReconnect(): boolean;
-    shouldFetchOnWindowFocus(): boolean;
-    destroy(): void;
-    setOptions(options?: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, notifyOptions?: NotifyOptions): void;
-    getOptimisticResult(options: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): QueryObserverResult<TData, TError>;
-    getCurrentResult(): QueryObserverResult<TData, TError>;
-    trackResult(result: QueryObserverResult<TData, TError>): QueryObserverResult<TData, TError>;
-    getCurrentQuery(): Query<TQueryFnData, TError, TQueryData, TQueryKey>;
-    remove(): void;
-    refetch<TPageData>({ refetchPage, ...options }?: RefetchOptions & RefetchPageFilters<TPageData>): Promise<QueryObserverResult<TData, TError>>;
-    fetchOptimistic(options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): Promise<QueryObserverResult<TData, TError>>;
-    protected fetch(fetchOptions: ObserverFetchOptions): Promise<QueryObserverResult<TData, TError>>;
-    private executeFetch;
-    private updateStaleTimeout;
-    private computeRefetchInterval;
-    private updateRefetchInterval;
-    private updateTimers;
-    private clearStaleTimeout;
-    private clearRefetchInterval;
-    protected createResult(query: Query<TQueryFnData, TError, TQueryData, TQueryKey>, options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): QueryObserverResult<TData, TError>;
-    updateResult(notifyOptions?: NotifyOptions): void;
-    private updateQuery;
-    onQueryUpdate(action: Action<TData, TError>): void;
-    private notify;
-}
-export {};

package/build/types/packages/query-core/src/removable.d.ts

@@ -1,9 +0,0 @@
-export declare abstract class Removable {
-    cacheTime: number;
-    private gcTimeout?;
-    destroy(): void;
-    protected scheduleGc(): void;
-    protected updateCacheTime(newCacheTime: number | undefined): void;
-    protected clearGcTimeout(): void;
-    protected abstract optionalRemove(): void;
-}

package/build/types/packages/query-core/src/retryer.d.ts

@@ -1,33 +0,0 @@
-import { CancelOptions, NetworkMode } from './types';
-interface RetryerConfig<TData = unknown, TError = unknown> {
-    fn: () => TData | Promise<TData>;
-    abort?: () => void;
-    onError?: (error: TError) => void;
-    onSuccess?: (data: TData) => void;
-    onFail?: (failureCount: number, error: TError) => void;
-    onPause?: () => void;
-    onContinue?: () => void;
-    retry?: RetryValue<TError>;
-    retryDelay?: RetryDelayValue<TError>;
-    networkMode: NetworkMode | undefined;
-}
-export interface Retryer<TData = unknown> {
-    promise: Promise<TData>;
-    cancel: (cancelOptions?: CancelOptions) => void;
-    continue: () => void;
-    cancelRetry: () => void;
-    continueRetry: () => void;
-}
-export declare type RetryValue<TError> = boolean | number | ShouldRetryFunction<TError>;
-declare type ShouldRetryFunction<TError> = (failureCount: number, error: TError) => boolean;
-export declare type RetryDelayValue<TError> = number | RetryDelayFunction<TError>;
-declare type RetryDelayFunction<TError = unknown> = (failureCount: number, error: TError) => number;
-export declare function canFetch(networkMode: NetworkMode | undefined): boolean;
-export declare class CancelledError {
-    revert?: boolean;
-    silent?: boolean;
-    constructor(options?: CancelOptions);
-}
-export declare function isCancelledError(value: any): value is CancelledError;
-export declare function createRetryer<TData = unknown, TError = unknown>(config: RetryerConfig<TData, TError>): Retryer<TData>;
-export {};

package/build/types/packages/query-core/src/subscribable.d.ts

@@ -1,10 +0,0 @@
-declare type Listener = () => void;
-export declare class Subscribable<TListener extends Function = Listener> {
-    protected listeners: TListener[];
-    constructor();
-    subscribe(listener: TListener): () => void;
-    hasListeners(): boolean;
-    protected onSubscribe(): void;
-    protected onUnsubscribe(): void;
-}
-export {};