@hz52410/uni-query 1.0.1

package/dist/queryCache.d.ts

@@ -0,0 +1,8 @@
+import { QueryCache as QC } from './query-core/queryCache';
+import { DefaultError, Query, QueryFilters, WithRequired } from './query-core';
+import { MaybeRefDeep } from './types';
+
+export declare class QueryCache extends QC {
+    find<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData>(filters: MaybeRefDeep<WithRequired<QueryFilters, 'queryKey'>>): Query<TQueryFnData, TError, TData> | undefined;
+    findAll(filters?: MaybeRefDeep<QueryFilters>): Array<Query>;
+}

package/dist/queryClient.d.ts

@@ -0,0 +1,37 @@
+import { QueryClient as QC } from './query-core/queryClient';
+import { UseQueryOptions } from './useQuery';
+import { MaybeRefDeep, NoUnknown, QueryClientConfig } from './types';
+import { CancelOptions, DefaultError, DefaultOptions, EnsureQueryDataOptions, FetchInfiniteQueryOptions, FetchQueryOptions, InferDataFromTag, InferErrorFromTag, InfiniteData, InvalidateOptions, InvalidateQueryFilters, MutationFilters, MutationKey, MutationObserverOptions, NoInfer, OmitKeyof, QueryFilters, QueryKey, QueryObserverOptions, QueryState, RefetchOptions, RefetchQueryFilters, ResetOptions, SetDataOptions, Updater } from './query-core';
+
+export declare class QueryClient extends QC {
+    constructor(config?: QueryClientConfig);
+    isFetching(filters?: MaybeRefDeep<QueryFilters>): number;
+    isMutating(filters?: MaybeRefDeep<MutationFilters>): number;
+    getQueryData<TData = unknown, TTaggedQueryKey extends QueryKey = QueryKey>(queryKey: TTaggedQueryKey): InferDataFromTag<TData, TTaggedQueryKey> | undefined;
+    getQueryData<TData = unknown>(queryKey: MaybeRefDeep<QueryKey>): TData | undefined;
+    ensureQueryData<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: EnsureQueryDataOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<TData>;
+    ensureQueryData<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: MaybeRefDeep<EnsureQueryDataOptions<TQueryFnData, TError, TData, TQueryKey>>): Promise<TData>;
+    getQueriesData<TData = unknown>(filters: MaybeRefDeep<QueryFilters>): Array<[QueryKey, TData | undefined]>;
+    setQueryData<TQueryFnData = unknown, TTaggedQueryKey extends QueryKey = QueryKey, TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>>(queryKey: TTaggedQueryKey, updater: Updater<NoInfer<TInferredQueryFnData> | undefined, NoInfer<TInferredQueryFnData> | undefined>, options?: MaybeRefDeep<SetDataOptions>): NoInfer<TInferredQueryFnData> | undefined;
+    setQueryData<TQueryFnData, TData = NoUnknown<TQueryFnData>>(queryKey: MaybeRefDeep<QueryKey>, updater: Updater<NoInfer<TData> | undefined, NoInfer<TData> | undefined>, options?: MaybeRefDeep<SetDataOptions>): NoInfer<TData> | undefined;
+    setQueriesData<TData>(filters: MaybeRefDeep<QueryFilters>, updater: Updater<TData | undefined, TData | undefined>, options?: MaybeRefDeep<SetDataOptions>): Array<[QueryKey, TData | undefined]>;
+    getQueryState<TData = unknown, TError = DefaultError>(queryKey: MaybeRefDeep<QueryKey>): QueryState<TData, TError> | undefined;
+    removeQueries<TQueryFnData = unknown, TError = DefaultError, TTaggedQueryKey extends QueryKey = QueryKey, TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>, TInferredError = InferErrorFromTag<TError, TTaggedQueryKey>>(filters?: QueryFilters): void;
+    resetQueries<TQueryFnData = unknown, TError = DefaultError, TTaggedQueryKey extends QueryKey = QueryKey, TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>, TInferredError = InferErrorFromTag<TError, TTaggedQueryKey>>(filters?: QueryFilters, options?: MaybeRefDeep<ResetOptions>): Promise<void>;
+    cancelQueries<TQueryFnData = unknown, TError = DefaultError, TTaggedQueryKey extends QueryKey = QueryKey, TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>, TInferredError = InferErrorFromTag<TError, TTaggedQueryKey>>(filters?: QueryFilters, options?: MaybeRefDeep<CancelOptions>): Promise<void>;
+    invalidateQueries<TQueryFnData = unknown, TError = DefaultError, TTaggedQueryKey extends QueryKey = QueryKey, TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>, TInferredError = InferErrorFromTag<TError, TTaggedQueryKey>>(filters?: InvalidateQueryFilters, options?: MaybeRefDeep<InvalidateOptions>): Promise<void>;
+    refetchQueries<TQueryFnData = unknown, TError = DefaultError, TTaggedQueryKey extends QueryKey = QueryKey, TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>, TInferredError = InferErrorFromTag<TError, TTaggedQueryKey>>(filters?: RefetchQueryFilters, options?: MaybeRefDeep<RefetchOptions>): Promise<void>;
+    fetchQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<TData>;
+    fetchQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never>(options: MaybeRefDeep<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>;
+    prefetchQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: MaybeRefDeep<FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>>): Promise<void>;
+    fetchInfiniteQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): Promise<InfiniteData<TData, TPageParam>>;
+    fetchInfiniteQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: MaybeRefDeep<FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>): Promise<InfiniteData<TData, TPageParam>>;
+    prefetchInfiniteQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): Promise<void>;
+    prefetchInfiniteQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: MaybeRefDeep<FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>): Promise<void>;
+    setDefaultOptions(options: MaybeRefDeep<DefaultOptions>): void;
+    setQueryDefaults<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData>(queryKey: MaybeRefDeep<QueryKey>, options: MaybeRefDeep<Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryData>, 'queryKey'>>): void;
+    getQueryDefaults(queryKey: MaybeRefDeep<QueryKey>): OmitKeyof<QueryObserverOptions<any, any, any, any, any>, 'queryKey'>;
+    setMutationDefaults<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(mutationKey: MaybeRefDeep<MutationKey>, options: MaybeRefDeep<MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>>): void;
+    getMutationDefaults(mutationKey: MaybeRefDeep<MutationKey>): MutationObserverOptions<any, any, any, any>;
+}

package/dist/queryOptions.d.ts

@@ -0,0 +1,9 @@
+import { DataTag, DefaultError, QueryKey } from './query-core';
+import { DefinedInitialQueryOptions, UndefinedInitialQueryOptions } from './useQuery';
+
+export declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>): DefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+    queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
+};
+export declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>): UndefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+    queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
+};

package/dist/types.d.ts

@@ -0,0 +1,33 @@
+import { DefaultError, DehydrateOptions, HydrateOptions, MutationCache, MutationObserverOptions, OmitKeyof, QueryCache, QueryObserverOptions } from './query-core';
+import { ComputedRef, Ref, UnwrapRef } from 'vue';
+
+type Primitive = string | number | boolean | bigint | symbol | undefined | null;
+type UnwrapLeaf = Primitive | Function | Date | Error | RegExp | Map<any, any> | WeakMap<any, any> | Set<any> | WeakSet<any>;
+export type MaybeRef<T> = Ref<T> | ComputedRef<T> | T;
+export type MaybeRefOrGetter<T> = MaybeRef<T> | (() => T);
+export type MaybeRefDeep<T> = MaybeRef<T extends Function ? T : T extends object ? {
+    [Property in keyof T]: MaybeRefDeep<T[Property]>;
+} : T>;
+export type NoUnknown<T> = Equal<unknown, T> extends true ? never : T;
+export type Equal<TTargetA, TTargetB> = (<T>() => T extends TTargetA ? 1 : 2) extends <T>() => T extends TTargetB ? 1 : 2 ? true : false;
+export type DeepUnwrapRef<T> = T extends UnwrapLeaf ? T : T extends Ref<infer U> ? DeepUnwrapRef<U> : T extends {} ? {
+    [Property in keyof T]: DeepUnwrapRef<T[Property]>;
+} : UnwrapRef<T>;
+export type ShallowOption = {
+    /**
+     * Return data in a shallow ref object (it is `false` by default). It can be set to `true` to return data in a shallow ref object, which can improve performance if your data does not need to be deeply reactive.
+     */
+    shallow?: boolean;
+};
+export interface DefaultOptions<TError = DefaultError> {
+    queries?: OmitKeyof<QueryObserverOptions<unknown, TError>, 'queryKey'> & ShallowOption;
+    mutations?: MutationObserverOptions<unknown, TError, unknown, unknown> & ShallowOption;
+    hydrate?: HydrateOptions['defaultOptions'];
+    dehydrate?: DehydrateOptions;
+}
+export interface QueryClientConfig {
+    queryCache?: QueryCache;
+    mutationCache?: MutationCache;
+    defaultOptions?: DefaultOptions;
+}
+export {};

package/dist/useBaseQuery.d.ts

@@ -0,0 +1,15 @@
+import { Ref } from 'vue';
+import { QueryKey, QueryObserver, QueryObserverResult } from './query-core';
+import { QueryClient } from './queryClient';
+import { UseQueryOptions } from './useQuery';
+import { UseInfiniteQueryOptions } from './useInfiniteQuery';
+import { MaybeRefOrGetter } from './types';
+
+export type UseBaseQueryReturnType<TData, TError, TResult = QueryObserverResult<TData, TError>> = {
+    [K in keyof TResult]: K extends 'fetchNextPage' | 'fetchPreviousPage' | 'refetch' ? TResult[K] : Ref<Readonly<TResult>[K]>;
+} & {
+    suspense: () => Promise<TResult>;
+};
+type UseQueryOptionsGeneric<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> | UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>;
+export declare function useBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey, TPageParam>(Observer: typeof QueryObserver, options: MaybeRefOrGetter<UseQueryOptionsGeneric<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>>, queryClient?: QueryClient): UseBaseQueryReturnType<TData, TError>;
+export {};

package/dist/useInfiniteQuery.d.ts

@@ -0,0 +1,13 @@
+import { DefinedInitialDataInfiniteOptions, UndefinedInitialDataInfiniteOptions } from './infiniteQueryOptions';
+import { DefaultError, InfiniteData, InfiniteQueryObserverOptions, InfiniteQueryObserverResult, QueryKey } from './query-core';
+import { UseBaseQueryReturnType } from './useBaseQuery';
+import { DeepUnwrapRef, MaybeRef, MaybeRefDeep, MaybeRefOrGetter, ShallowOption } from './types';
+import { QueryClient } from './queryClient';
+
+export type UseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = MaybeRef<{
+    [Property in keyof InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey, TPageParam>]: Property extends 'enabled' ? MaybeRefOrGetter<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, DeepUnwrapRef<TQueryKey>, TPageParam>[Property]> : MaybeRefDeep<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, DeepUnwrapRef<TQueryKey>, TPageParam>[Property]>;
+} & ShallowOption>;
+export type UseInfiniteQueryReturnType<TData, TError> = UseBaseQueryReturnType<TData, TError, InfiniteQueryObserverResult<TData, TError>>;
+export declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: MaybeRefOrGetter<DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>, queryClient?: QueryClient): UseInfiniteQueryReturnType<TData, TError>;
+export declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: MaybeRefOrGetter<UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>, queryClient?: QueryClient): UseInfiniteQueryReturnType<TData, TError>;
+export declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: MaybeRefOrGetter<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>, queryClient?: QueryClient): UseInfiniteQueryReturnType<TData, TError>;

package/dist/useIsFetching.d.ts

@@ -0,0 +1,7 @@
+import { Ref } from 'vue';
+import { QueryFilters as QF } from './query-core';
+import { MaybeRefDeep } from './types';
+import { QueryClient } from './queryClient';
+
+export type QueryFilters = MaybeRefDeep<QF> | (() => MaybeRefDeep<QF>);
+export declare function useIsFetching(fetchingFilters?: QueryFilters, queryClient?: QueryClient): Ref<number>;

package/dist/useMutation.d.ts

@@ -0,0 +1,16 @@
+import { ToRefs } from 'vue';
+import { DefaultError, DistributiveOmit, MutateFunction, MutationObserverOptions, MutationObserverResult } from './query-core';
+import { MaybeRefDeep, ShallowOption } from './types';
+import { QueryClient } from './queryClient';
+
+type MutationResult<TData, TError, TVariables, TOnMutateResult> = DistributiveOmit<MutationObserverResult<TData, TError, TVariables, TOnMutateResult>, 'mutate' | 'reset'>;
+type UseMutationOptionsBase<TData, TError, TVariables, TOnMutateResult> = MutationObserverOptions<TData, TError, TVariables, TOnMutateResult> & ShallowOption;
+export type UseMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = MaybeRefDeep<UseMutationOptionsBase<TData, TError, TVariables, TOnMutateResult>> | (() => MaybeRefDeep<UseMutationOptionsBase<TData, TError, TVariables, TOnMutateResult>>);
+type MutateSyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = (...options: Parameters<MutateFunction<TData, TError, TVariables, TOnMutateResult>>) => void;
+export type UseMutationReturnType<TData, TError, TVariables, TOnMutateResult, TResult = MutationResult<TData, TError, TVariables, TOnMutateResult>> = ToRefs<Readonly<TResult>> & {
+    mutate: MutateSyncFunction<TData, TError, TVariables, TOnMutateResult>;
+    mutateAsync: MutateFunction<TData, TError, TVariables, TOnMutateResult>;
+    reset: MutationObserverResult<TData, TError, TVariables, TOnMutateResult>['reset'];
+};
+export declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(mutationOptions: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, queryClient?: QueryClient): UseMutationReturnType<TData, TError, TVariables, TOnMutateResult>;
+export {};

package/dist/useMutationState.d.ts

@@ -0,0 +1,12 @@
+import { Ref } from 'vue';
+import { MutationFilters as MF, Mutation, MutationState } from './query-core';
+import { QueryClient } from './queryClient';
+import { MaybeRefDeep } from './types';
+
+export type MutationFilters = MaybeRefDeep<MF>;
+export declare function useIsMutating(filters?: MutationFilters | (() => MutationFilters), queryClient?: QueryClient): Ref<number>;
+export type MutationStateOptions<TResult = MutationState> = {
+    filters?: MutationFilters;
+    select?: (mutation: Mutation) => TResult;
+};
+export declare function useMutationState<TResult = MutationState>(options?: MutationStateOptions<TResult> | (() => MutationStateOptions<TResult>), queryClient?: QueryClient): Readonly<Ref<Array<TResult>>>;

package/dist/useQueries.d.ts

@@ -0,0 +1,84 @@
+import { Ref } from 'vue';
+import { DefaultError, DefinedQueryObserverResult, QueryFunction, QueryKey, QueryObserverResult, ThrowOnError } from './query-core';
+import { UseQueryOptions } from './useQuery';
+import { QueryClient } from './queryClient';
+import { DeepUnwrapRef, MaybeRefDeep, ShallowOption } from './types';
+
+type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>;
+type MAXIMUM_DEPTH = 20;
+type SkipTokenForUseQueries = symbol;
+type GetUseQueryOptionsForUseQueries<T> = T extends UseQueryOptions ? DeepUnwrapRef<T> : T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+    data: infer TData;
+} ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+} ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends {
+    data: infer TData;
+    error?: infer TError;
+} ? UseQueryOptionsForUseQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryOptionsForUseQueries<TQueryFnData> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> | SkipTokenForUseQueries;
+    select?: (data: any) => infer TData;
+    throwOnError?: ThrowOnError<infer TError, any>;
+} ? UseQueryOptionsForUseQueries<TQueryFnData, unknown extends TError ? DefaultError : TError, unknown extends TData ? TQueryFnData : TData, TQueryKey> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> | SkipTokenForUseQueries;
+    throwOnError?: ThrowOnError<infer TError, any>;
+} ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TQueryFnData, TQueryKey> : UseQueryOptionsForUseQueries;
+type GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {
+    initialData?: infer TInitialData;
+} ? unknown extends TInitialData ? QueryObserverResult<TData, TError> : TInitialData extends TData ? DefinedQueryObserverResult<TData, TError> : TInitialData extends () => infer TInitialDataResult ? unknown extends TInitialDataResult ? QueryObserverResult<TData, TError> : TInitialDataResult extends TData ? DefinedQueryObserverResult<TData, TError> : QueryObserverResult<TData, TError> : QueryObserverResult<TData, TError> : QueryObserverResult<TData, TError>;
+type GetUseQueryResult<T> = T extends UseQueryOptions<infer TQueryFnData, infer TError, infer TData, any, any> ? GetDefinedOrUndefinedQueryResult<T, undefined extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : T extends {
+    queryFnData: any;
+    error?: infer TError;
+    data: infer TData;
+} ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+} ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends {
+    data: infer TData;
+    error?: infer TError;
+} ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [any, infer TError, infer TData] ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [infer TQueryFnData, infer TError] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends [infer TQueryFnData] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, any> | SkipTokenForUseQueries;
+    select?: (data: any) => infer TData;
+    throwOnError?: ThrowOnError<infer TError, any>;
+} ? GetDefinedOrUndefinedQueryResult<T, unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, any> | SkipTokenForUseQueries;
+    throwOnError?: ThrowOnError<infer TError, any>;
+} ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, unknown extends TError ? DefaultError : TError> : QueryObserverResult;
+/**
+ * UseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
+ */
+export type UseQueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryOptionsForUseQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseQueryOptionsForUseQueries<Head>] : T extends [infer Head, ...infer Tails] ? UseQueriesOptions<[
+    ...Tails
+], [
+    ...TResults,
+    GetUseQueryOptionsForUseQueries<Head>
+], [
+    ...TDepth,
+    1
+]> : ReadonlyArray<unknown> extends T ? T : T extends Array<UseQueryOptionsForUseQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<UseQueryOptionsForUseQueries>;
+/**
+ * UseQueriesResults reducer recursively maps type param to results
+ */
+export type UseQueriesResults<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<QueryObserverResult> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseQueryResult<Head>] : T extends [infer Head, ...infer Tails] ? UseQueriesResults<[
+    ...Tails
+], [
+    ...TResults,
+    GetUseQueryResult<Head>
+], [
+    ...TDepth,
+    1
+]> : {
+    [K in keyof T]: GetUseQueryResult<T[K]>;
+};
+type UseQueriesOptionsArg<T extends Array<any>> = readonly [
+    ...UseQueriesOptions<T>
+];
+export declare function useQueries<T extends Array<any>, TCombinedResult = UseQueriesResults<T>>({ queries, ...options }: ShallowOption & {
+    queries: (() => MaybeRefDeep<UseQueriesOptionsArg<T>>) | MaybeRefDeep<UseQueriesOptionsArg<T>> | MaybeRefDeep<Array<{
+        [K in keyof T]: GetUseQueryOptionsForUseQueries<T[K]>;
+    }[keyof T]>>;
+    combine?: (result: UseQueriesResults<T>) => TCombinedResult;
+}, queryClient?: QueryClient): Readonly<Ref<TCombinedResult>>;
+export {};

package/dist/useQuery.d.ts

@@ -0,0 +1,19 @@
+import { DefaultError, DefinedQueryObserverResult, Enabled, InitialDataFunction, NonUndefinedGuard, QueryKey, QueryObserverOptions } from './query-core';
+import { UseBaseQueryReturnType } from './useBaseQuery';
+import { DeepUnwrapRef, MaybeRef, MaybeRefDeep, MaybeRefOrGetter, ShallowOption } from './types';
+import { QueryClient } from './queryClient';
+
+export type UseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = MaybeRef<{
+    [Property in keyof QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>]: Property extends 'enabled' ? MaybeRefOrGetter<boolean | undefined> | (() => Enabled<TQueryFnData, TError, TQueryData, DeepUnwrapRef<TQueryKey>>) : MaybeRefDeep<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, DeepUnwrapRef<TQueryKey>>[Property]>;
+} & ShallowOption>;
+export type UndefinedInitialQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey> & {
+    initialData?: undefined | InitialDataFunction<NonUndefinedGuard<TQueryFnData>> | NonUndefinedGuard<TQueryFnData>;
+};
+export type DefinedInitialQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey> & {
+    initialData: NonUndefinedGuard<TQueryFnData> | (() => NonUndefinedGuard<TQueryFnData>);
+};
+export type UseQueryReturnType<TData, TError> = UseBaseQueryReturnType<TData, TError>;
+export type UseQueryDefinedReturnType<TData, TError> = UseBaseQueryReturnType<TData, TError, DefinedQueryObserverResult<TData, TError>>;
+export declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryDefinedReturnType<TData, TError>;
+export declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryReturnType<TData, TError>;
+export declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: MaybeRefOrGetter<UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>>, queryClient?: QueryClient): UseQueryReturnType<TData, TError>;

package/dist/useQueryClient.d.ts

@@ -0,0 +1,3 @@
+import { QueryClient } from './queryClient';
+
+export declare function useQueryClient(id?: string): QueryClient;

package/dist/utils.d.ts

@@ -0,0 +1,7 @@
+import { MaybeRefDeep } from './types';
+
+export declare const VUE_QUERY_CLIENT = "VUE_QUERY_CLIENT";
+export declare function getClientKey(key?: string): string;
+export declare function updateState(state: Record<string, any>, update: Record<string, any>): void;
+export declare function cloneDeep<T>(value: MaybeRefDeep<T>, customize?: (val: MaybeRefDeep<T>, key: string, level: number) => T | undefined): T;
+export declare function cloneDeepUnref<T>(obj: MaybeRefDeep<T>, unrefGetters?: boolean): T;

package/dist/vueQueryPlugin.d.ts

@@ -0,0 +1,20 @@
+import { App } from 'vue';
+import { QueryClient } from './queryClient';
+import { QueryClientConfig } from './types';
+
+interface CommonOptions {
+    enableDevtoolsV6Plugin?: boolean;
+    queryClientKey?: string;
+    refetchOnShow?: boolean;
+}
+interface ConfigOptions extends CommonOptions {
+    queryClientConfig?: QueryClientConfig;
+}
+interface ClientOptions extends CommonOptions {
+    queryClient?: QueryClient;
+}
+export type VueQueryPluginOptions = ConfigOptions | ClientOptions;
+export declare const VueQueryPlugin: {
+    install: (app: App, options?: VueQueryPluginOptions) => void;
+};
+export {};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@hz52410/uni-query",
+  "version": "1.0.1",
+  "description": "一个专为 uni-app 生态设计的轻量级数据获取库",
+  "main": "./dist/index.cjs.js",
+  "module": "./dist/index.esm.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.esm.js",
+      "require": "./dist/index.cjs.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "vite build",
+    "dev": "vite build --watch",
+    "type-check": "tsc --noEmit",
+    "prepublishOnly": "npm run build",
+    "prepublish:check": "npm run build && npm run type-check && npm pack --dry-run",
+    "publish:dry-run": "npm run prepublish:check",
+    "publish": "npm publish --access public"
+  },
+  "keywords": [
+    "uni-app",
+    "vue",
+    "query",
+    "react-query",
+    "vue-query",
+    "data-fetching",
+    "cache",
+    "wechat-miniprogram"
+  ],
+  "author": "",
+  "license": "MIT",
+  "peerDependencies": {
+    "vue": "^3.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.6",
+    "typescript": "^5.3.3",
+    "vite": "^5.0.0",
+    "vite-plugin-dts": "^3.6.0",
+    "vue": "^3.3.13"
+  },
+  "repository": {
+    "type": "git",
+    "url": ""
+  }
+}