@hz52410/uni-query 1.0.1

package/dist/infiniteQueryOptions.d.ts

@@ -0,0 +1,15 @@
+import { DataTag, DefaultError, InfiniteData, NonUndefinedGuard, QueryKey } from './query-core';
+import { UseInfiniteQueryOptions } from './useInfiniteQuery';
+
+export type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+    initialData?: undefined;
+};
+export type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+    initialData: NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> | (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>);
+};
+export declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+    queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
+};
+export declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+    queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
+};

package/dist/mutationCache.d.ts

@@ -0,0 +1,8 @@
+import { MutationCache as MC } from './query-core/mutationCache';
+import { DefaultError, Mutation, MutationFilters } from './query-core';
+import { MaybeRefDeep } from './types';
+
+export declare class MutationCache extends MC {
+    find<TData = unknown, TError = DefaultError, TVariables = any, TOnMutateResult = unknown>(filters: MaybeRefDeep<MutationFilters>): Mutation<TData, TError, TVariables, TOnMutateResult> | undefined;
+    findAll(filters?: MaybeRefDeep<MutationFilters>): Array<Mutation>;
+}

package/dist/query-core/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * query-core - 本地实现
+ */
+export * from './types';
+export { QueryCache } from './queryCache';
+export { MutationCache } from './mutationCache';
+export { QueryClient } from './queryClient';
+export { QueryObserver } from './queryObserver';
+export { MutationObserver } from './mutationObserver';
+export { InfiniteQueryObserver } from './infiniteQueryObserver';
+export { QueriesObserver } from './queriesObserver';
+export { hashQueryKey, shouldThrowError } from './utils';

package/dist/query-core/infiniteQueryObserver.d.ts

@@ -0,0 +1,31 @@
+import { QueryObserver } from './queryObserver';
+import { QueryKey, InfiniteData, InfiniteQueryObserverResult, DefaultError, DefaultedQueryObserverOptions } from './types';
+
+export declare class InfiniteQueryObserver<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends QueryObserver<TQueryFnData, TError, TData, TQueryData, TQueryKey> {
+    private infiniteOptions;
+    constructor(client: any, options: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> & {
+        initialPageParam: TPageParam;
+        getNextPageParam: (lastPage: TQueryFnData, allPages: TQueryFnData[]) => TPageParam | undefined;
+        getPreviousPageParam?: (firstPage: TQueryFnData, allPages: TQueryFnData[]) => TPageParam | undefined;
+    });
+    /**
+     * 获取下一页
+     */
+    fetchNextPage(options?: any): Promise<InfiniteQueryObserverResult<TData, TError>>;
+    /**
+     * 获取上一页
+     */
+    fetchPreviousPage(options?: any): Promise<InfiniteQueryObserverResult<TData, TError>>;
+    /**
+     * 获取当前结果（覆盖父类方法）
+     */
+    getCurrentResult(): InfiniteQueryObserverResult<TData, TError>;
+    /**
+     * 判断是否有下一页
+     */
+    private hasNextPage;
+    /**
+     * 判断是否有上一页
+     */
+    private hasPreviousPage;
+}

package/dist/query-core/mutationCache.d.ts

@@ -0,0 +1,43 @@
+import { Mutation, MutationFilters, DefaultError } from './types';
+
+export declare class MutationCache {
+    private mutations;
+    private mutationId;
+    constructor();
+    /**
+     * 添加 Mutation
+     */
+    add(mutation: Mutation): void;
+    /**
+     * 移除 Mutation
+     */
+    remove(mutation: Mutation): void;
+    /**
+     * 查找 Mutation
+     */
+    find<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(filters: MutationFilters): Mutation<TData, TError, TVariables, TContext> | undefined;
+    /**
+     * 查找所有匹配的 Mutation
+     */
+    findAll(filters?: MutationFilters): Array<Mutation>;
+    /**
+     * 清除所有 Mutation
+     */
+    clear(): void;
+    /**
+     * 订阅缓存变化
+     */
+    subscribe(listener: () => void): () => void;
+    /**
+     * 生成 Mutation ID
+     */
+    generateMutationId(): number;
+    /**
+     * 匹配 Mutation
+     */
+    private matchMutation;
+    /**
+     * 匹配键
+     */
+    private matchKeys;
+}

package/dist/query-core/mutationObserver.d.ts

@@ -0,0 +1,43 @@
+import { QueryClient } from './queryClient';
+import { MutationObserverOptions, MutationObserverResult, DefaultError } from './types';
+
+export declare class MutationObserver<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> {
+    private client;
+    private options;
+    private mutation;
+    private subscribers;
+    private currentResult;
+    constructor(client: QueryClient, options: MutationObserverOptions<TData, TError, TVariables, TContext>);
+    /**
+     * 订阅结果变化
+     */
+    subscribe(callback: (result: MutationObserverResult<TData, TError, TVariables, TContext>) => void): () => void;
+    /**
+     * 获取当前结果
+     */
+    getCurrentResult(): MutationObserverResult<TData, TError, TVariables, TContext>;
+    /**
+     * 设置选项
+     */
+    setOptions(options: MutationObserverOptions<TData, TError, TVariables, TContext>): void;
+    /**
+     * 执行 Mutation
+     */
+    mutate(variables: TVariables, options?: any): Promise<TData>;
+    /**
+     * 创建 Mutation
+     */
+    private createMutation;
+    /**
+     * 创建初始结果
+     */
+    private createInitialResult;
+    /**
+     * 创建结果对象
+     */
+    private createResult;
+    /**
+     * 更新结果并通知订阅者
+     */
+    private updateResult;
+}

package/dist/query-core/queriesObserver.d.ts

@@ -0,0 +1,27 @@
+import { QueryClient } from './queryClient';
+import { QueryObserverOptions, QueryObserverResult, QueriesObserverOptions } from './types';
+
+export declare class QueriesObserver<TCombinedResult = unknown> {
+    private client;
+    private options;
+    private observers;
+    private subscribers;
+    private currentResult;
+    constructor(client: QueryClient, queries: Array<QueryObserverOptions<any, any, any, any, any>>, options?: QueriesObserverOptions<TCombinedResult>);
+    /**
+     * 订阅结果变化
+     */
+    subscribe(callback: (result: TCombinedResult) => void): () => void;
+    /**
+     * 获取乐观结果
+     */
+    getOptimisticResult(queries: Array<QueryObserverOptions<any, any, any, any, any>>, combine?: (result: Array<QueryObserverResult>) => TCombinedResult): [Array<QueryObserverResult>, (result: Array<QueryObserverResult>) => TCombinedResult];
+    /**
+     * 设置查询
+     */
+    setQueries(queries: Array<QueryObserverOptions<any, any, any, any, any>>, options?: QueriesObserverOptions<TCombinedResult>): void;
+    /**
+     * 获取组合结果
+     */
+    private getCombinedResult;
+}

package/dist/query-core/queryCache.d.ts

@@ -0,0 +1,40 @@
+import { Query, QueryFilters, QueryKey, DefaultError } from './types';
+
+export declare class QueryCache {
+    private queries;
+    constructor();
+    /**
+     * 添加查询
+     */
+    add(query: Query): void;
+    /**
+     * 移除查询
+     */
+    remove(query: Query): void;
+    /**
+     * 查找查询
+     */
+    find<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData>(filters: QueryFilters & {
+        queryKey: QueryKey;
+    }): Query<TQueryFnData, TError, TData> | undefined;
+    /**
+     * 查找所有匹配的查询
+     */
+    findAll(filters?: QueryFilters): Array<Query>;
+    /**
+     * 清除所有查询
+     */
+    clear(): void;
+    /**
+     * 订阅缓存变化
+     */
+    subscribe(listener: () => void): () => void;
+    /**
+     * 生成查询哈希
+     */
+    private hashQueryKey;
+    /**
+     * 匹配查询
+     */
+    private matchQuery;
+}

package/dist/query-core/queryClient.d.ts

@@ -0,0 +1,133 @@
+import { QueryCache } from './queryCache';
+import { MutationCache } from './mutationCache';
+import { QueryKey, MutationKey, Query, QueryFilters, MutationFilters, DefaultError, DefaultOptions, QueryObserverOptions, MutationObserverOptions, FetchQueryOptions, EnsureQueryDataOptions, FetchInfiniteQueryOptions, InfiniteData, InvalidateQueryFilters, RefetchQueryFilters, RefetchOptions, CancelOptions, ResetOptions, SetDataOptions, Updater, QueryState, Mutation } from './types';
+
+export interface QueryClientConfig {
+    queryCache?: QueryCache;
+    mutationCache?: MutationCache;
+    defaultOptions?: DefaultOptions;
+}
+export declare class QueryClient {
+    queryCache: QueryCache;
+    mutationCache: MutationCache;
+    defaultOptions: DefaultOptions;
+    constructor(config?: QueryClientConfig);
+    /**
+     * 挂载（uni-app 不需要特殊处理）
+     */
+    mount(): void;
+    /**
+     * 卸载
+     */
+    unmount(): void;
+    /**
+     * 获取查询数据
+     */
+    getQueryData<TData = unknown>(queryKey: QueryKey): TData | undefined;
+    /**
+     * 设置查询数据
+     */
+    setQueryData<TData>(queryKey: QueryKey, updater: Updater<TData | undefined, TData | undefined>, options?: SetDataOptions): TData | undefined;
+    /**
+     * 设置多个查询数据
+     */
+    setQueriesData<TData>(filters: QueryFilters, updater: Updater<TData | undefined, TData | undefined>, options?: SetDataOptions): Array<[QueryKey, TData | undefined]>;
+    /**
+     * 获取查询状态
+     */
+    getQueryState<TData = unknown, TError = DefaultError>(queryKey: QueryKey): QueryState<TData, TError> | undefined;
+    /**
+     * 获取多个查询数据
+     */
+    getQueriesData<TData = unknown>(filters: QueryFilters): Array<[QueryKey, TData | undefined]>;
+    /**
+     * 获取查询
+     */
+    getQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData>(queryKey: QueryKey): Query<TQueryFnData, TError, TData> | undefined;
+    /**
+     * 获取所有查询
+     */
+    getQueries(filters?: QueryFilters): Array<Query>;
+    /**
+     * 获取所有 Mutations
+     */
+    getMutations(filters?: MutationFilters): Array<Mutation>;
+    /**
+     * 判断是否正在获取
+     */
+    isFetching(filters?: QueryFilters): number;
+    /**
+     * 判断是否正在执行 Mutation
+     */
+    isMutating(filters?: MutationFilters): number;
+    /**
+     * 获取默认查询选项
+     */
+    defaultQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> & {
+        _defaulted: true;
+    };
+    /**
+     * 获取默认 Mutation 选项
+     */
+    defaultMutationOptions<TData, TError, TVariables, TContext>(options: MutationObserverOptions<TData, TError, TVariables, TContext>): MutationObserverOptions<TData, TError, TVariables, TContext>;
+    /**
+     * 设置默认选项
+     */
+    setDefaultOptions(options: DefaultOptions): void;
+    /**
+     * 设置查询默认值
+     */
+    setQueryDefaults<TQueryFnData, TError, TData, TQueryData>(queryKey: QueryKey, options: Omit<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData>, 'queryKey'>): void;
+    /**
+     * 获取查询默认值
+     */
+    getQueryDefaults(queryKey: QueryKey): Omit<QueryObserverOptions<any, any, any, any, any>, 'queryKey'>;
+    /**
+     * 设置 Mutation 默认值
+     */
+    setMutationDefaults<TData, TError, TVariables, TContext>(mutationKey: MutationKey, options: MutationObserverOptions<TData, TError, TVariables, TContext>): void;
+    /**
+     * 获取 Mutation 默认值
+     */
+    getMutationDefaults(mutationKey: MutationKey): MutationObserverOptions<any, any, any, any>;
+    /**
+     * 获取查询数据（确保存在）
+     */
+    ensureQueryData<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: EnsureQueryDataOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<TData>;
+    /**
+     * 获取查询
+     */
+    fetchQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<TData>;
+    /**
+     * 预取查询
+     */
+    prefetchQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<void>;
+    /**
+     * 获取无限查询
+     */
+    fetchInfiniteQuery<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): Promise<InfiniteData<TData, TPageParam>>;
+    /**
+     * 预取无限查询
+     */
+    prefetchInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): Promise<void>;
+    /**
+     * 移除查询
+     */
+    removeQueries(filters?: QueryFilters): void;
+    /**
+     * 重置查询
+     */
+    resetQueries(filters?: QueryFilters, options?: ResetOptions): Promise<void>;
+    /**
+     * 取消查询
+     */
+    cancelQueries(filters?: QueryFilters, options?: CancelOptions): Promise<void>;
+    /**
+     * 使查询失效
+     */
+    invalidateQueries(filters?: InvalidateQueryFilters, options?: any): Promise<void>;
+    /**
+     * 重新获取查询
+     */
+    refetchQueries(filters?: RefetchQueryFilters, options?: RefetchOptions): Promise<void>;
+}

package/dist/query-core/queryObserver.d.ts

@@ -0,0 +1,67 @@
+import { QueryClient } from './queryClient';
+import { QueryKey, Query, QueryObserverResult, DefaultError, DefaultedQueryObserverOptions } from './types';
+
+export declare class QueryObserver<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> {
+    private client;
+    private options;
+    private query;
+    private subscribers;
+    private currentResult;
+    constructor(client: QueryClient, options: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>);
+    /**
+     * 创建查询对象
+     */
+    private createQuery;
+    /**
+     * 判断是否应该获取数据
+     */
+    private shouldFetch;
+    /**
+     * 订阅结果变化
+     */
+    subscribe(callback: (result: QueryObserverResult<TData, TError>) => void): () => void;
+    /**
+     * 获取当前结果
+     */
+    getCurrentResult(): QueryObserverResult<TData, TError>;
+    /**
+     * 获取乐观结果
+     */
+    getOptimisticResult(options: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): QueryObserverResult<TData, TError>;
+    /**
+     * 获取当前查询
+     */
+    getCurrentQuery(): Query<TQueryFnData, TError, TData> | undefined;
+    /**
+     * 设置选项
+     */
+    setOptions(options: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): void;
+    /**
+     * 获取乐观结果（用于 suspense）
+     */
+    fetchOptimistic(options: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): Promise<QueryObserverResult<TData, TError>>;
+    /**
+     * 获取数据
+     */
+    fetch(): Promise<QueryObserverResult<TData, TError>>;
+    /**
+     * 创建结果对象
+     */
+    private createResult;
+    /**
+     * 创建初始状态
+     */
+    private createInitialState;
+    /**
+     * 判断是否过期
+     */
+    private isStale;
+    /**
+     * 更新结果并通知订阅者
+     */
+    private updateResult;
+    /**
+     * 重新获取
+     */
+    refetch(options?: any): Promise<QueryObserverResult<TData, TError>>;
+}

package/dist/query-core/types.d.ts

@@ -0,0 +1,236 @@
+/**
+ * query-core 基础类型定义
+ */
+export type QueryKey = readonly unknown[];
+export type MutationKey = readonly unknown[];
+export type DefaultError = Error;
+export type QueryStatus = 'pending' | 'error' | 'success';
+export type FetchStatus = 'fetching' | 'paused' | 'idle';
+export interface QueryState<TData = unknown, TError = DefaultError> {
+    data: TData | undefined;
+    dataUpdatedAt: number;
+    error: TError | null;
+    errorUpdatedAt: number;
+    errorUpdateCount: number;
+    failureCount: number;
+    failureReason: TError | null;
+    fetchFailureCount: number;
+    fetchFailureReason: TError | null;
+    fetchMeta: any;
+    isInvalidated: boolean;
+    status: QueryStatus;
+    fetchStatus: FetchStatus;
+}
+export interface QueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> {
+    queryKey: TQueryKey;
+    queryFn: (context: {
+        queryKey: TQueryKey;
+        signal?: AbortSignal;
+        meta?: any;
+    }) => Promise<TQueryFnData>;
+    enabled?: boolean;
+    staleTime?: number;
+    gcTime?: number;
+    retry?: number | boolean | ((failureCount: number, error: TError) => boolean);
+    retryDelay?: number | ((attemptIndex: number) => number);
+    refetchOnMount?: boolean | 'always';
+    refetchOnWindowFocus?: boolean;
+    refetchInterval?: number | false;
+    refetchIntervalInBackground?: boolean;
+    select?: (data: TQueryFnData) => TData;
+    placeholderData?: TData | (() => TData | undefined);
+    initialData?: TData | (() => TData | undefined);
+    initialDataUpdatedAt?: number | (() => number | undefined);
+    meta?: any;
+    _defaulted?: boolean;
+    _optimisticResults?: 'optimistic' | 'isRestoring';
+}
+export interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends QueryOptions<TQueryFnData, TError, TData, TQueryKey> {
+    notifyOnChangeProps?: Array<keyof QueryObserverResult<TData, TError>> | 'all';
+    throwOnError?: boolean | ((error: TError, query: Query<TQueryFnData, TError>) => boolean);
+}
+export interface QueryObserverResult<TData = unknown, TError = DefaultError> {
+    data: TData | undefined;
+    dataUpdatedAt: number;
+    error: TError | null;
+    errorUpdatedAt: number;
+    errorUpdateCount: number;
+    failureCount: number;
+    failureReason: TError | null;
+    fetchFailureCount: number;
+    fetchFailureReason: TError | null;
+    fetchStatus: FetchStatus;
+    isError: boolean;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isLoading: boolean;
+    isLoadingError: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isRefetchError: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isSuccess: boolean;
+    refetch: (options?: RefetchOptions) => Promise<QueryObserverResult<TData, TError>>;
+    status: QueryStatus;
+}
+export interface DefinedQueryObserverResult<TData = unknown, TError = DefaultError> extends QueryObserverResult<TData, TError> {
+    data: TData;
+    status: 'success';
+}
+export interface Query<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData> {
+    queryKey: QueryKey;
+    queryHash: string;
+    state: QueryState<TData, TError>;
+    options: QueryOptions<TQueryFnData, TError, TData>;
+}
+export interface MutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> {
+    mutationFn: (variables: TVariables) => Promise<TData>;
+    mutationKey?: MutationKey;
+    onMutate?: (variables: TVariables) => Promise<TContext> | TContext;
+    onSuccess?: (data: TData, variables: TVariables, context?: TContext) => void | Promise<void>;
+    onError?: (error: TError, variables: TVariables, context?: TContext) => void | Promise<void>;
+    onSettled?: (data: TData | undefined, error: TError | null, variables: TVariables, context?: TContext) => void | Promise<void>;
+    retry?: number | boolean | ((failureCount: number, error: TError) => boolean);
+    retryDelay?: number | ((attemptIndex: number) => number);
+    gcTime?: number;
+    meta?: any;
+}
+export interface MutationObserverOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends MutationOptions<TData, TError, TVariables, TContext> {
+    throwOnError?: boolean | ((error: TError, variables: TVariables) => boolean);
+}
+export interface MutationObserverResult<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> {
+    data: TData | undefined;
+    error: TError | null;
+    failureCount: number;
+    failureReason: TError | null;
+    isError: boolean;
+    isIdle: boolean;
+    isPaused: boolean;
+    isLoading: boolean;
+    isSuccess: boolean;
+    mutate: (variables: TVariables, options?: any) => void;
+    mutateAsync: (variables: TVariables, options?: any) => Promise<TData>;
+    reset: () => void;
+    status: 'idle' | 'loading' | 'error' | 'success';
+    variables: TVariables | undefined;
+    context: TContext | undefined;
+}
+export type MutationState = MutationObserverResult;
+export interface Mutation<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> {
+    mutationId: number;
+    options: MutationObserverOptions<TData, TError, TVariables, TContext>;
+    state: MutationObserverResult<TData, TError, TVariables, TContext>;
+}
+export interface InfiniteData<TData = unknown, TPageParam = unknown> {
+    pages: TData[];
+    pageParams: TPageParam[];
+}
+export interface InfiniteQueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {
+    initialPageParam: TPageParam;
+    getNextPageParam: (lastPage: TQueryFnData, allPages: TQueryFnData[]) => TPageParam | undefined;
+    getPreviousPageParam?: (firstPage: TQueryFnData, allPages: TQueryFnData[]) => TPageParam | undefined;
+    maxPages?: number;
+}
+export interface InfiniteQueryObserverResult<TData = unknown, TError = DefaultError> extends QueryObserverResult<TData, TError> {
+    fetchNextPage: (options?: FetchNextPageOptions) => Promise<InfiniteQueryObserverResult<TData, TError>>;
+    fetchPreviousPage: (options?: FetchPreviousPageOptions) => Promise<InfiniteQueryObserverResult<TData, TError>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+}
+export interface FetchNextPageOptions extends RefetchOptions {
+}
+export interface FetchPreviousPageOptions extends RefetchOptions {
+}
+export interface RefetchOptions {
+    cancelRefetch?: boolean;
+    throwOnError?: boolean;
+}
+export interface QueryFilters {
+    queryKey?: QueryKey;
+    exact?: boolean;
+    predicate?: (query: Query) => boolean;
+    type?: 'active' | 'inactive' | 'all';
+    stale?: boolean;
+    fetchStatus?: FetchStatus;
+}
+export interface MutationFilters {
+    mutationKey?: MutationKey;
+    exact?: boolean;
+    predicate?: (mutation: Mutation) => boolean;
+    status?: 'pending' | 'error' | 'success' | 'idle';
+}
+export interface InvalidateQueryFilters extends QueryFilters {
+    refetchType?: 'active' | 'inactive' | 'all' | 'none';
+}
+export interface RefetchQueryFilters extends QueryFilters {
+    type?: 'active' | 'inactive' | 'all';
+}
+export interface CancelOptions {
+    revert?: boolean;
+}
+export interface ResetOptions {
+    queryFilters?: QueryFilters;
+    mutationFilters?: MutationFilters;
+}
+export interface SetDataOptions {
+    updatedAt?: number;
+}
+export type Updater<TInput, TOutput> = TOutput | ((input: TInput) => TOutput);
+export interface FetchQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends QueryOptions<TQueryFnData, TError, TData, TQueryKey> {
+}
+export interface EnsureQueryDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey> {
+}
+export interface FetchInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey, TPageParam> {
+}
+export interface InvalidateOptions {
+    refetchType?: 'active' | 'inactive' | 'all' | 'none';
+}
+export interface DefaultOptions<TError = DefaultError> {
+    queries?: Omit<QueryObserverOptions<unknown, TError>, 'queryKey'>;
+    mutations?: MutationObserverOptions<unknown, TError, unknown, unknown>;
+}
+export interface DehydrateOptions {
+    shouldDehydrateQuery?: (query: Query) => boolean;
+    shouldDehydrateMutation?: (mutation: Mutation) => boolean;
+}
+export interface HydrateOptions {
+    defaultOptions?: DefaultOptions;
+}
+export type QueryFunction<TQueryFnData = unknown, TQueryKey extends QueryKey = QueryKey> = (context: {
+    queryKey: TQueryKey;
+    signal?: AbortSignal;
+    meta?: any;
+}) => Promise<TQueryFnData>;
+export type DataTag<TQueryKey extends QueryKey, TData, TError> = TQueryKey & {
+    __queryKey: TQueryKey;
+    __queryData: TData;
+    __queryError: TError;
+};
+export type InferDataFromTag<TData, TTaggedQueryKey extends QueryKey> = TTaggedQueryKey extends DataTag<any, infer TInferredData, any> ? TInferredData : TData;
+export type InferErrorFromTag<TError, TTaggedQueryKey extends QueryKey> = TTaggedQueryKey extends DataTag<any, any, infer TInferredError> ? TInferredError : TError;
+export type NoInfer<T> = [T][T extends any ? 0 : never];
+export type OmitKeyof<T, K extends keyof T> = Omit<T, K>;
+export type WithRequired<T, K extends keyof T> = T & Required<Pick<T, K>>;
+export type NonUndefinedGuard<T> = T extends undefined ? never : T;
+export type Enabled<TQueryFnData, TError, TQueryData, TQueryKey> = boolean;
+export type InitialDataFunction<TQueryFnData> = () => TQueryFnData;
+export type ThrowOnError<TError = DefaultError, TQuery = any> = boolean | ((error: TError, query: TQuery) => boolean);
+export type DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey> = QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> & {
+    _defaulted: true;
+};
+export interface QueriesObserverOptions<TCombinedResult = unknown> {
+    queries: Array<QueryObserverOptions>;
+    combine?: (result: Array<QueryObserverResult>) => TCombinedResult;
+}
+export type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
+export type MutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = (variables: TVariables, options?: MutateOptions<TData, TError, TVariables, TContext>) => Promise<TData>;
+export interface MutateOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> {
+    onSuccess?: (data: TData, variables: TVariables, context?: TContext) => void | Promise<void>;
+    onError?: (error: TError, variables: TVariables, context?: TContext) => void | Promise<void>;
+    onSettled?: (data: TData | undefined, error: TError | null, variables: TVariables, context?: TContext) => void | Promise<void>;
+}

package/dist/query-core/utils.d.ts

@@ -0,0 +1,10 @@
+import { QueryKey } from './types';
+
+/**
+ * 生成查询键的哈希
+ */
+export declare function hashQueryKey(queryKey: QueryKey): string;
+/**
+ * 判断是否应该抛出错误
+ */
+export declare function shouldThrowError<TError>(throwOnError: boolean | ((error: TError, query: any) => boolean) | undefined, params: [error: TError, query: any]): boolean;