@qiaopeng/tanstack-query-plus 0.5.8 → 0.5.10

package/dist/hooks/index.d.ts

@@ -1,10 +1,377 @@
-export { batchQueryUtils, calculateBatchStats, createBatchQueryConfig, useAutoRefreshBatchQueries, useBatchQueryPerformance, useCombinedQueries, useConditionalBatchQueries, useDashboardQueries, useDependentBatchQueries, useDynamicBatchQueries, useEnhancedQueries, useEnhancedSuspenseQueries, usePaginatedBatchQueries, useRetryBatchQueries } from "./batchQueries.js";
-export { useConditionalFocusRefetch, useFocusCallback, useFocusRefetch, type UseFocusRefetchOptions, useFocusState, usePageVisibility, usePauseFocus, type UsePauseFocusOptions, useSmartFocusManager } from "./useFocusManager.js";
-export { createCursorPaginationOptions, createInfiniteQueryOptions, createOffsetPaginationOptions, createPageNumberPaginationOptions, useEnhancedInfiniteQuery } from "./useInfiniteQuery.js";
-export { cancelQueriesBatch, invalidateQueriesBatch, type MutationDefaultsConfig, type MutationKey, setQueryDataBatch, setupMutationDefaults, useListMutation, useMutation } from "./useMutation.js";
-export { type HoverPrefetchOptions, type InViewPrefetchOptions, type PrefetchOptions, useBatchPrefetch, useConditionalPrefetch, useHoverPrefetch, useIdlePrefetch, usePeriodicPrefetch, usePredictivePrefetch, usePriorityPrefetch, useRoutePrefetch, useSmartPrefetch } from "./usePrefetch.js";
-export { skipToken, useEnhancedQuery, type EnhancedQueryOptions, type EnhancedQueryResult } from "./useQuery.js";
-export { createSuspenseInfiniteQuery, createSuspenseQuery, useEnhancedSuspenseInfiniteQuery, useEnhancedSuspenseQuery } from "./useSuspenseQuery.js";
-export { useDataGuardQueryConfig } from "./useDataGuardQuery.js";
-export { useDataGuardMutation, type DataGuardMutationOptions } from "./useDataGuardMutation.js";
-//# sourceMappingURL=index.d.ts.map
+import { UseQueryResult, UseSuspenseQueryResult, UseQueryOptions, QueryClient, DefaultError, UseSuspenseQueryOptions, QueryKey, UseInfiniteQueryOptions, QueryFunction, UseInfiniteQueryResult, UseMutationOptions, MutationFunction, UseMutationResult, QueryFunctionContext, UseSuspenseInfiniteQueryOptions, UseSuspenseInfiniteQueryResult, useMutationState as useMutationState$1, QueryFilters, MutationFilters } from '@tanstack/react-query';
+export { MutationFilters, MutationKey, skipToken } from '@tanstack/react-query';
+import { o as BatchErrorAggregate, n as BatchOperationReport, k as BatchQueryStats, l as BatchQueryConfig, p as BatchQueryOperations, s as EntityWithId, V as VersionedEntity, a as VersionedPaginatedResponse, c as DataGuardOptions } from '../persistence-tIrEb0pR.js';
+import { CursorPaginatedResponse, OffsetPaginatedResponse, PageNumberPaginatedResponse, MutationOptions } from '../types/index.js';
+import '../base-CHnwqfyz.js';
+import '../offline-DVPtgoAS.js';
+import 'react';
+import '@tanstack/react-query-persist-client';
+
+interface InternalBatchQueryOperations extends BatchQueryOperations {
+    _queryClient: QueryClient;
+    _queries: UseQueryOptions[];
+    _results: UseQueryResult[] | UseSuspenseQueryResult[];
+}
+declare function calculateBatchStats(results: UseQueryResult[] | UseSuspenseQueryResult[]): BatchQueryStats;
+declare function useEnhancedQueries(queries: UseQueryOptions[], config?: BatchQueryConfig): {
+    data: UseQueryResult<unknown, Error>[];
+    stats: BatchQueryStats;
+    operations: InternalBatchQueryOperations;
+    config: BatchQueryConfig<unknown, Error>;
+};
+declare function useEnhancedSuspenseQueries(queries: UseSuspenseQueryOptions[], config?: BatchQueryConfig): {
+    data: UseSuspenseQueryResult<unknown, Error>[];
+    stats: BatchQueryStats;
+    operations: InternalBatchQueryOperations;
+    config: BatchQueryConfig<unknown, Error>;
+};
+declare function createBatchQueryConfig(config?: Partial<BatchQueryConfig>): BatchQueryConfig;
+declare const batchQueryUtils: {
+    isAllLoading: (results: UseQueryResult[] | UseSuspenseQueryResult[]) => boolean;
+    isAllSuccess: (results: UseQueryResult[] | UseSuspenseQueryResult[]) => boolean;
+    hasError: (results: UseQueryResult[] | UseSuspenseQueryResult[]) => boolean;
+    hasStale: (results: UseQueryResult[] | UseSuspenseQueryResult[]) => boolean;
+    getAllErrors: (results: UseQueryResult[] | UseSuspenseQueryResult[]) => Error[];
+    getAllData: (results: UseQueryResult[] | UseSuspenseQueryResult[]) => unknown[];
+    isAllPending: (results: UseQueryResult[] | UseSuspenseQueryResult[]) => boolean;
+    isAnyFetching: (results: UseQueryResult[] | UseSuspenseQueryResult[]) => boolean;
+    getSuccessData: <T>(results: UseQueryResult<T>[]) => T[];
+    getFirstError: (results: UseQueryResult[] | UseSuspenseQueryResult[]) => Error | null;
+    createErrorAggregate: <TError = Error>(results: UseQueryResult[] | UseSuspenseQueryResult[], queries: UseQueryOptions[]) => BatchErrorAggregate<TError>;
+    createOperationReport: <TData = unknown, TError = Error>(results: UseQueryResult[] | UseSuspenseQueryResult[], queries: UseQueryOptions[], startTime: number, retryCount?: number) => BatchOperationReport<TData, TError>;
+};
+declare function useCombinedQueries<TCombinedResult = UseQueryResult[]>(options: {
+    queries: UseQueryOptions[];
+    combine?: (results: UseQueryResult[]) => TCombinedResult;
+}): TCombinedResult;
+declare function useDynamicBatchQueries<TItem, TData = unknown>(options: {
+    items: TItem[];
+    queryKeyPrefix: unknown[];
+    queryFn: (item: TItem) => Promise<TData>;
+    enabled?: boolean;
+    staleTime?: number;
+    gcTime?: number;
+    config?: BatchQueryConfig;
+}): {
+    data: UseQueryResult<unknown, Error>[];
+    stats: BatchQueryStats;
+    operations: InternalBatchQueryOperations;
+    config: BatchQueryConfig<unknown, Error>;
+};
+declare function useDependentBatchQueries<TPrimaryData>(options: {
+    primaryQuery: UseQueryOptions<TPrimaryData>;
+    dependentQueries: (data: TPrimaryData) => UseQueryOptions[];
+    config?: BatchQueryConfig;
+}): DependentBatchQueriesResult<TPrimaryData>;
+interface DependentBatchQueriesResult<TPrimaryData> {
+    primaryResult: UseQueryResult<TPrimaryData, DefaultError>;
+    results: UseQueryResult[];
+    stats: BatchQueryStats;
+    operations: InternalBatchQueryOperations;
+}
+declare function useAutoRefreshBatchQueries(options: {
+    queries: UseQueryOptions[];
+    refreshInterval?: number;
+    enabled?: boolean;
+    config?: BatchQueryConfig;
+}): {
+    data: UseQueryResult<unknown, Error>[];
+    stats: BatchQueryStats;
+    operations: InternalBatchQueryOperations;
+    config: BatchQueryConfig<unknown, Error>;
+};
+declare function useDashboardQueries<T extends Record<string, UseQueryOptions>>(queriesMap: T): {
+    data: { [K in keyof T]: T[K] extends UseQueryOptions<infer TData, Error, infer TData, readonly unknown[]> ? TData : unknown; };
+    results: UseQueryResult<unknown, Error>[];
+    stats: BatchQueryStats;
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+};
+declare function usePaginatedBatchQueries<TData = unknown>(options: {
+    pageNumbers: number[];
+    queryKeyPrefix: unknown[];
+    queryFn: (page: number) => Promise<TData>;
+    staleTime?: number;
+    config?: BatchQueryConfig;
+}): {
+    data: UseQueryResult<unknown, Error>[];
+    stats: BatchQueryStats;
+    operations: InternalBatchQueryOperations;
+    config: BatchQueryConfig<unknown, Error>;
+};
+declare function useConditionalBatchQueries(queries: (UseQueryOptions & {
+    enabled?: boolean;
+})[]): {
+    data: UseQueryResult<unknown, Error>[];
+    stats: BatchQueryStats;
+    operations: InternalBatchQueryOperations;
+    config: BatchQueryConfig<unknown, Error>;
+};
+declare function useRetryBatchQueries(options: {
+    queries: UseQueryOptions[];
+    retry?: number | ((failureCount: number, error: Error) => boolean);
+    retryDelay?: number | ((attemptIndex: number) => number);
+    config?: BatchQueryConfig;
+}): {
+    data: UseQueryResult<unknown, Error>[];
+    stats: BatchQueryStats;
+    operations: InternalBatchQueryOperations;
+    config: BatchQueryConfig<unknown, Error>;
+};
+declare function useBatchQueryPerformance(results: UseQueryResult[] | UseSuspenseQueryResult[]): {
+    avgFetchTime: number;
+    totalQueries: number;
+    activeQueries: number;
+    cachedQueries: number;
+    total: number;
+    loading: number;
+    success: number;
+    error: number;
+    stale: number;
+    successRate: number;
+    errorRate: number;
+};
+
+interface UseFocusRefetchOptions {
+    enabled?: boolean;
+    minInterval?: number;
+    queryKeys?: QueryKey[];
+}
+interface UsePauseFocusOptions {
+    autoPause?: boolean;
+    pauseWhen?: boolean;
+}
+declare function useFocusState(): boolean;
+declare function useFocusRefetch(options?: UseFocusRefetchOptions): void;
+declare function usePauseFocus(options?: UsePauseFocusOptions): {
+    pause: () => void;
+    resume: () => void;
+};
+declare function useSmartFocusManager(): {
+    pause: () => void;
+    resume: () => void;
+    getStats: () => {
+        isPaused: boolean;
+        pauseCount: number;
+        isFocused: boolean;
+    };
+    stats: {
+        isPaused: boolean;
+        pauseCount: number;
+        isFocused: boolean;
+    };
+};
+declare function useConditionalFocusRefetch(queryKey: QueryKey, condition: () => boolean, options?: {
+    minInterval?: number;
+    enabled?: boolean;
+}): void;
+declare function useFocusCallback(callback: () => void, options?: {
+    minInterval?: number;
+    enabled?: boolean;
+    queryKey?: QueryKey;
+}): void;
+declare function usePageVisibility(): boolean;
+
+declare function useEnhancedInfiniteQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UseInfiniteQueryResult<TData, TError>;
+declare function createInfiniteQueryOptions<TQueryFnData = unknown, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(config: {
+    queryKey: TQueryKey;
+    queryFn: QueryFunction<TQueryFnData, TQueryKey, TPageParam>;
+    initialPageParam: TPageParam;
+    getNextPageParam: (lastPage: TQueryFnData, allPages: TQueryFnData[], lastPageParam: TPageParam, allPageParams: TPageParam[]) => TPageParam | undefined | null;
+    getPreviousPageParam?: (firstPage: TQueryFnData, allPages: TQueryFnData[], firstPageParam: TPageParam, allPageParams: TPageParam[]) => TPageParam | undefined | null;
+    staleTime?: number;
+    gcTime?: number;
+    maxPages?: number;
+}): UseInfiniteQueryOptions<TQueryFnData, DefaultError, TQueryFnData, TQueryKey, TPageParam>;
+declare function createCursorPaginationOptions<T>(config: {
+    queryKey: QueryKey;
+    queryFn: (cursor: string | null) => Promise<CursorPaginatedResponse<T>>;
+    initialCursor?: string | null;
+    staleTime?: number;
+    gcTime?: number;
+    maxPages?: number;
+}): UseInfiniteQueryOptions<CursorPaginatedResponse<T>, DefaultError, CursorPaginatedResponse<T>, QueryKey, string | null>;
+declare function createOffsetPaginationOptions<T>(config: {
+    queryKey: QueryKey;
+    queryFn: (offset: number, limit: number) => Promise<OffsetPaginatedResponse<T>>;
+    limit?: number;
+    staleTime?: number;
+    gcTime?: number;
+    maxPages?: number;
+}): UseInfiniteQueryOptions<OffsetPaginatedResponse<T>, DefaultError, OffsetPaginatedResponse<T>, QueryKey, number>;
+declare function createPageNumberPaginationOptions<T>(config: {
+    queryKey: QueryKey;
+    queryFn: (page: number) => Promise<PageNumberPaginatedResponse<T>>;
+    staleTime?: number;
+    gcTime?: number;
+    maxPages?: number;
+}): UseInfiniteQueryOptions<PageNumberPaginatedResponse<T>, DefaultError, PageNumberPaginatedResponse<T>, QueryKey, number>;
+
+interface MutationDefaultsConfig {
+    [key: string]: UseMutationOptions<any, any, any, any>;
+}
+declare function useMutation<TData = unknown, TError = Error, TVariables = void, TContext = unknown>(options: MutationOptions<TData, TError, TVariables, TContext>): UseMutationResult<TData, TError, TVariables, TContext>;
+declare function setupMutationDefaults(queryClient: QueryClient, config: MutationDefaultsConfig): void;
+declare function useListMutation<T extends EntityWithId>(mutationFn: MutationFunction<T, {
+    operation: string;
+    data: Partial<T>;
+}>, queryKey: QueryKey, options?: UseMutationOptions<T, Error, {
+    operation: string;
+    data: Partial<T>;
+}> & {
+    mutationKey?: readonly unknown[];
+}): UseMutationResult<T, Error, {
+    operation: string;
+    data: Partial<T>;
+}, unknown>;
+
+interface PrefetchOptions {
+    delay?: number;
+    enabled?: boolean;
+    staleTime?: number;
+    minInterval?: number;
+}
+interface HoverPrefetchOptions extends PrefetchOptions {
+    hoverDelay?: number;
+}
+interface InViewPrefetchOptions extends PrefetchOptions {
+    threshold?: number;
+    rootMargin?: string;
+    triggerOnce?: boolean;
+}
+declare function useHoverPrefetch<TData = unknown>(queryKey: QueryKey, queryFn: QueryFunction<TData>, options?: HoverPrefetchOptions): {
+    onMouseEnter: () => void;
+    onMouseLeave: () => void;
+    onFocus: () => void;
+};
+declare function useRoutePrefetch(): <TData = unknown>(queryKey: QueryKey, queryFn: QueryFunction<TData>, options?: PrefetchOptions) => void;
+declare function useBatchPrefetch(): <TData = unknown>(queries: Array<{
+    queryKey: QueryKey;
+    queryFn: QueryFunction<TData>;
+    staleTime?: number;
+}>) => void;
+declare function useSmartPrefetch(): {
+    prefetch: <TData = unknown>(queryKey: QueryKey, queryFn: QueryFunction<TData>, options?: PrefetchOptions) => void;
+    shouldPrefetch: boolean;
+    clearPrefetchHistory: () => void;
+};
+declare function useConditionalPrefetch<TData = unknown>(queryKey: QueryKey, queryFn: QueryFunction<TData>, condition: boolean, options?: PrefetchOptions): void;
+declare function useIdlePrefetch<TData = unknown>(queryKey: QueryKey, queryFn: QueryFunction<TData>, options?: PrefetchOptions & {
+    timeout?: number;
+}): void;
+declare function usePeriodicPrefetch<TData = unknown>(queryKey: QueryKey, queryFn: QueryFunction<TData>, options?: PrefetchOptions & {
+    interval?: number;
+}): void;
+declare function usePredictivePrefetch(): {
+    recordInteraction: (action: string, target: string) => void;
+    getPredictions: () => string[];
+    prefetchPredicted: <TData = unknown>(getQueryConfig: (target: string) => {
+        queryKey: QueryKey;
+        queryFn: QueryFunction<TData>;
+    }) => void;
+    clearHistory: () => void;
+};
+declare function usePriorityPrefetch(): {
+    addPrefetchTask: <TData = unknown>(queryKey: QueryKey, queryFn: QueryFunction<TData>, priority?: "high" | "medium" | "low") => void;
+    processTasks: () => Promise<void>;
+    clearTasks: () => void;
+    taskCount: number;
+};
+
+interface EnhancedQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends UseQueryOptions<TQueryFnData, TError, TData, TQueryKey> {
+    /** Log errors to console in development */
+    logErrors?: boolean;
+    /** Callback when query takes longer than threshold */
+    onSlowQuery?: (duration: number, queryKey: TQueryKey) => void;
+    /** Threshold in ms to trigger onSlowQuery (default: 3000) */
+    slowQueryThreshold?: number;
+    /** Enable performance tracking */
+    trackPerformance?: boolean;
+}
+type EnhancedQueryResult<TData = unknown, TError = DefaultError> = UseQueryResult<TData, TError> & {
+    /** Number of times the query has been refetched */
+    refetchCount: number;
+    /** Last query duration in ms */
+    lastQueryDuration: number | null;
+};
+declare function useEnhancedQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: EnhancedQueryOptions<TQueryFnData, TError, TData, TQueryKey>): EnhancedQueryResult<TData, TError>;
+
+type InfiniteQueryFunction<TQueryFnData = unknown, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = (context: QueryFunctionContext<TQueryKey, TPageParam>) => Promise<TQueryFnData>;
+declare function createSuspenseQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TVariables = void>(getQueryKey: (variables: TVariables) => TQueryKey, queryFn: QueryFunction<TQueryFnData, TQueryKey>, options?: Omit<UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, "queryKey" | "queryFn">): (variables: TVariables) => UseSuspenseQueryResult<TData, TError>;
+declare function createSuspenseInfiniteQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown, TVariables = void>(getQueryKey: (variables: TVariables) => TQueryKey, queryFn: InfiniteQueryFunction<TQueryFnData, TQueryKey, TPageParam>, options: Omit<UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, "queryKey" | "queryFn"> & {
+    getNextPageParam: (lastPage: TQueryFnData, allPages: TQueryFnData[], lastPageParam: TPageParam, allPageParams: TPageParam[]) => TPageParam | undefined | null;
+    initialPageParam: TPageParam;
+}): (variables: TVariables) => UseSuspenseInfiniteQueryResult<TData, TError>;
+declare function useEnhancedSuspenseQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>): UseSuspenseQueryResult<TData, TError>;
+declare function useEnhancedSuspenseInfiniteQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UseSuspenseInfiniteQueryResult<TData, TError>;
+
+/**
+ * Hook: 创建带数据防护的查询配置
+ *
+ * 自动根据后端返回的数据选择最佳防护策略：
+ * 1. 如果有 version 字段 → 使用版本号比较（最可靠）
+ * 2. 如果有 updatedAt 字段 → 使用时间戳比较（次优）
+ * 3. 都没有 → 使用内容哈希比较（兜底）
+ *
+ * @example
+ * ```typescript
+ * const { data } = useEnhancedQuery(
+ *   useDataGuardQueryConfig(
+ *     ['products', 'list', { page: 1, pageSize: 20 }],
+ *     () => fetchProducts(1, 20),
+ *     {
+ *       maxDataAge: 5000,
+ *       onStaleDataDetected: (info) => {
+ *         console.warn('检测到旧数据', info)
+ *       }
+ *     }
+ *   )
+ * )
+ * ```
+ */
+declare function useDataGuardQueryConfig<T extends VersionedEntity>(queryKey: QueryKey, fetchFn: () => Promise<VersionedPaginatedResponse<T>>, options?: DataGuardOptions): Pick<UseQueryOptions<VersionedPaginatedResponse<T>>, "queryKey" | "queryFn">;
+
+interface DataGuardMutationOptions<TData, TError, TVariables, TContext> extends MutationOptions<TData, TError, TVariables, TContext> {
+    /** 冲突错误回调 */
+    onConflict?: (error: any) => void;
+}
+/**
+ * 带数据防护的 Mutation Hook
+ *
+ * 自动处理：
+ * 1. 乐观更新时递增版本号和更新时间戳
+ * 2. 标记最近更新的项
+ * 3. 成功后更新所有家族缓存的元数据
+ * 4. 冲突检测（409 错误）
+ * 5. 延迟清理更新标记
+ *
+ * @example
+ * ```typescript
+ * const mutation = useDataGuardMutation(
+ *   (updated) => api.updateProduct(updated.id, updated),
+ *   ['products', 'list', { page: 1, pageSize: 20 }],
+ *   {
+ *     optimistic: {
+ *       queryKey: ['products', 'list', { page: 1, pageSize: 20 }],
+ *       updater: (old, updated) => ({
+ *         ...old,
+ *         items: old?.items?.map(p => p.id === updated.id ? updated : p)
+ *       })
+ *     },
+ *     onConflict: (error) => {
+ *       toast.error('数据冲突，请刷新')
+ *     }
+ *   }
+ * )
+ * ```
+ */
+declare function useDataGuardMutation<TData extends VersionedEntity = VersionedEntity, TError = Error, TVariables extends VersionedEntity = VersionedEntity, TContext = unknown>(mutationFn: (data: TVariables) => Promise<TData>, queryKey: QueryKey, options?: DataGuardMutationOptions<TData, TError, TVariables, TContext>): UseMutationResult<TData, TError, TVariables, TContext>;
+
+type MutationStateOptions<TResult = unknown> = Parameters<typeof useMutationState$1<TResult>>[0];
+declare function useMutationState<TResult = unknown>(options?: MutationStateOptions<TResult>): Array<TResult>;
+
+declare function useIsFetching(filters?: QueryFilters): number;
+declare function useIsMutating(filters?: MutationFilters): number;
+
+export { type DataGuardMutationOptions, type EnhancedQueryOptions, type EnhancedQueryResult, type HoverPrefetchOptions, type InViewPrefetchOptions, type MutationDefaultsConfig, type MutationStateOptions, type PrefetchOptions, type UseFocusRefetchOptions, type UsePauseFocusOptions, batchQueryUtils, calculateBatchStats, createBatchQueryConfig, createCursorPaginationOptions, createInfiniteQueryOptions, createOffsetPaginationOptions, createPageNumberPaginationOptions, createSuspenseInfiniteQuery, createSuspenseQuery, setupMutationDefaults, useAutoRefreshBatchQueries, useBatchPrefetch, useBatchQueryPerformance, useCombinedQueries, useConditionalBatchQueries, useConditionalFocusRefetch, useConditionalPrefetch, useDashboardQueries, useDataGuardMutation, useDataGuardQueryConfig, useDependentBatchQueries, useDynamicBatchQueries, useEnhancedInfiniteQuery, useEnhancedQueries, useEnhancedQuery, useEnhancedSuspenseInfiniteQuery, useEnhancedSuspenseQueries, useEnhancedSuspenseQuery, useFocusCallback, useFocusRefetch, useFocusState, useHoverPrefetch, useIdlePrefetch, useIsFetching, useIsMutating, useListMutation, useMutation, useMutationState, usePageVisibility, usePaginatedBatchQueries, usePauseFocus, usePeriodicPrefetch, usePredictivePrefetch, usePriorityPrefetch, useRetryBatchQueries, useRoutePrefetch, useSmartFocusManager, useSmartPrefetch };

package/dist/hooks/index.js

@@ -1,9 +1,8 @@
-export { batchQueryUtils, calculateBatchStats, createBatchQueryConfig, useAutoRefreshBatchQueries, useBatchQueryPerformance, useCombinedQueries, useConditionalBatchQueries, useDashboardQueries, useDependentBatchQueries, useDynamicBatchQueries, useEnhancedQueries, useEnhancedSuspenseQueries, usePaginatedBatchQueries, useRetryBatchQueries } from "./batchQueries.js";
-export { useConditionalFocusRefetch, useFocusCallback, useFocusRefetch, useFocusState, usePageVisibility, usePauseFocus, useSmartFocusManager } from "./useFocusManager.js";
-export { createCursorPaginationOptions, createInfiniteQueryOptions, createOffsetPaginationOptions, createPageNumberPaginationOptions, useEnhancedInfiniteQuery } from "./useInfiniteQuery.js";
-export { cancelQueriesBatch, invalidateQueriesBatch, setQueryDataBatch, setupMutationDefaults, useListMutation, useMutation } from "./useMutation.js";
-export { useBatchPrefetch, useConditionalPrefetch, useHoverPrefetch, useIdlePrefetch, usePeriodicPrefetch, usePredictivePrefetch, usePriorityPrefetch, useRoutePrefetch, useSmartPrefetch } from "./usePrefetch.js";
-export { skipToken, useEnhancedQuery } from "./useQuery.js";
-export { createSuspenseInfiniteQuery, createSuspenseQuery, useEnhancedSuspenseInfiniteQuery, useEnhancedSuspenseQuery } from "./useSuspenseQuery.js";
-export { useDataGuardQueryConfig } from "./useDataGuardQuery.js";
-export { useDataGuardMutation } from "./useDataGuardMutation.js";
+export { batchQueryUtils, calculateBatchStats, createBatchQueryConfig, createCursorPaginationOptions, createInfiniteQueryOptions, createOffsetPaginationOptions, createPageNumberPaginationOptions, createSuspenseInfiniteQuery, createSuspenseQuery, setupMutationDefaults, skipToken, useAutoRefreshBatchQueries, useBatchPrefetch, useBatchQueryPerformance, useCombinedQueries, useConditionalBatchQueries, useConditionalFocusRefetch, useConditionalPrefetch, useDashboardQueries, useDataGuardMutation, useDataGuardQueryConfig, useDependentBatchQueries, useDynamicBatchQueries, useEnhancedInfiniteQuery, useEnhancedQueries, useEnhancedQuery, useEnhancedSuspenseInfiniteQuery, useEnhancedSuspenseQueries, useEnhancedSuspenseQuery, useFocusCallback, useFocusRefetch, useFocusState, useHoverPrefetch, useIdlePrefetch, useIsFetching, useIsMutating, useListMutation, useMutation, useMutationState, usePageVisibility, usePaginatedBatchQueries, usePauseFocus, usePeriodicPrefetch, usePredictivePrefetch, usePriorityPrefetch, useRetryBatchQueries, useRoutePrefetch, useSmartFocusManager, useSmartPrefetch } from '../chunk-JHDKUQSB.js';
+import '../chunk-HRO2DWKZ.js';
+import '../chunk-X3ZTSLBQ.js';
+import '../chunk-KC62H4VJ.js';
+import '../chunk-EXITP7QO.js';
+import '../chunk-JN2Y6RSY.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/hooks/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/hooks/useInViewPrefetch.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var chunk6MAYHLTE_cjs = require('../chunk-6MAYHLTE.cjs');
+require('../chunk-OFLCHKKE.cjs');
+var reactQuery = require('@tanstack/react-query');
+var react = require('react');
+var reactIntersectionObserver = require('react-intersection-observer');
+
+function useInViewPrefetch(queryKey, queryFn, options = {}) {
+  const queryClient = reactQuery.useQueryClient();
+  const { threshold = 0.1, rootMargin = "50px", triggerOnce = true, enabled = true, staleTime = chunk6MAYHLTE_cjs.DEFAULT_STALE_TIME } = options;
+  const [ref, inView] = reactIntersectionObserver.useInView({ threshold, rootMargin, triggerOnce });
+  const queryFnRef = react.useRef(queryFn);
+  react.useEffect(() => {
+    queryFnRef.current = queryFn;
+  }, [queryFn]);
+  const stableQueryKey = react.useRef(queryKey);
+  react.useEffect(() => {
+    if (JSON.stringify(stableQueryKey.current) !== JSON.stringify(queryKey)) {
+      stableQueryKey.current = queryKey;
+    }
+  }, [queryKey]);
+  react.useEffect(() => {
+    if (inView && enabled) {
+      queryClient.prefetchQuery({ queryKey: stableQueryKey.current, queryFn: queryFnRef.current, staleTime });
+    }
+  }, [inView, queryClient, enabled, staleTime]);
+  return ref;
+}
+
+exports.useInViewPrefetch = useInViewPrefetch;
+//# sourceMappingURL=useInViewPrefetch.cjs.map
+//# sourceMappingURL=useInViewPrefetch.cjs.map

package/dist/hooks/useInViewPrefetch.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/useInViewPrefetch.ts"],"names":["useQueryClient","DEFAULT_STALE_TIME","useInView","useRef","useEffect"],"mappings":";;;;;;;;AAQO,SAAS,iBAAA,CAAmC,QAAA,EAAoB,OAAA,EAA+B,OAAA,GAAiC,EAAC,EAAG;AACzI,EAAA,MAAM,cAAcA,yBAAA,EAAe;AACnC,EAAA,MAAM,EAAE,SAAA,GAAY,GAAA,EAAK,UAAA,GAAa,MAAA,EAAQ,WAAA,GAAc,IAAA,EAAM,OAAA,GAAU,IAAA,EAAM,SAAA,GAAYC,oCAAA,EAAmB,GAAI,OAAA;AACrH,EAAA,MAAM,CAAC,KAAK,MAAM,CAAA,GAAIC,oCAAU,EAAE,SAAA,EAAW,UAAA,EAAY,WAAA,EAAa,CAAA;AACtE,EAAA,MAAM,UAAA,GAAaC,aAAO,OAAO,CAAA;AACjC,EAAAC,eAAA,CAAU,MAAM;AAAE,IAAA,UAAA,CAAW,OAAA,GAAU,OAAA;AAAA,EAAS,CAAA,EAAG,CAAC,OAAO,CAAC,CAAA;AAC5D,EAAA,MAAM,cAAA,GAAiBD,aAAO,QAAQ,CAAA;AACtC,EAAAC,eAAA,CAAU,MAAM;AAAE,IAAA,IAAI,IAAA,CAAK,UAAU,cAAA,CAAe,OAAO,MAAM,IAAA,CAAK,SAAA,CAAU,QAAQ,CAAA,EAAG;AAAE,MAAA,cAAA,CAAe,OAAA,GAAU,QAAA;AAAA,IAAU;AAAA,EAAE,CAAA,EAAG,CAAC,QAAQ,CAAC,CAAA;AAC/I,EAAAA,eAAA,CAAU,MAAM;AACd,IAAA,IAAI,UAAU,OAAA,EAAS;AACrB,MAAA,WAAA,CAAY,aAAA,CAAc,EAAE,QAAA,EAAU,cAAA,CAAe,SAAS,OAAA,EAAS,UAAA,CAAW,OAAA,EAAS,SAAA,EAAW,CAAA;AAAA,IACxG;AAAA,EACF,GAAG,CAAC,MAAA,EAAQ,WAAA,EAAa,OAAA,EAAS,SAAS,CAAC,CAAA;AAC5C,EAAA,OAAO,GAAA;AACT","file":"useInViewPrefetch.cjs","sourcesContent":["import type { QueryFunction, QueryKey } from \"@tanstack/react-query\";\nimport { useQueryClient } from \"@tanstack/react-query\";\nimport { useEffect, useRef } from \"react\";\nimport { useInView } from \"react-intersection-observer\";\nimport { DEFAULT_STALE_TIME } from \"../core/config.js\";\n\nexport interface InViewPrefetchOptions { threshold?: number; rootMargin?: string; triggerOnce?: boolean; enabled?: boolean; staleTime?: number }\n\nexport function useInViewPrefetch<TData = unknown>(queryKey: QueryKey, queryFn: QueryFunction<TData>, options: InViewPrefetchOptions = {}) {\n  const queryClient = useQueryClient();\n  const { threshold = 0.1, rootMargin = \"50px\", triggerOnce = true, enabled = true, staleTime = DEFAULT_STALE_TIME } = options;\n  const [ref, inView] = useInView({ threshold, rootMargin, triggerOnce });\n  const queryFnRef = useRef(queryFn);\n  useEffect(() => { queryFnRef.current = queryFn; }, [queryFn]);\n  const stableQueryKey = useRef(queryKey);\n  useEffect(() => { if (JSON.stringify(stableQueryKey.current) !== JSON.stringify(queryKey)) { stableQueryKey.current = queryKey; } }, [queryKey]);\n  useEffect(() => {\n    if (inView && enabled) {\n      queryClient.prefetchQuery({ queryKey: stableQueryKey.current, queryFn: queryFnRef.current, staleTime });\n    }\n  }, [inView, queryClient, enabled, staleTime]);\n  return ref;\n}"]}

package/dist/hooks/useInViewPrefetch.d.cts

@@ -0,0 +1,12 @@
+import { QueryKey, QueryFunction } from '@tanstack/react-query';
+
+interface InViewPrefetchOptions {
+    threshold?: number;
+    rootMargin?: string;
+    triggerOnce?: boolean;
+    enabled?: boolean;
+    staleTime?: number;
+}
+declare function useInViewPrefetch<TData = unknown>(queryKey: QueryKey, queryFn: QueryFunction<TData>, options?: InViewPrefetchOptions): (node?: Element | null) => void;
+
+export { type InViewPrefetchOptions, useInViewPrefetch };

package/dist/hooks/useInViewPrefetch.d.ts

@@ -1,10 +1,12 @@
-import type { QueryFunction, QueryKey } from "@tanstack/react-query";
-export interface InViewPrefetchOptions {
+import { QueryKey, QueryFunction } from '@tanstack/react-query';
+
+interface InViewPrefetchOptions {
     threshold?: number;
     rootMargin?: string;
     triggerOnce?: boolean;
     enabled?: boolean;
     staleTime?: number;
 }
-export declare function useInViewPrefetch<TData = unknown>(queryKey: QueryKey, queryFn: QueryFunction<TData>, options?: InViewPrefetchOptions): (node?: Element | null) => void;
-//# sourceMappingURL=useInViewPrefetch.d.ts.map
+declare function useInViewPrefetch<TData = unknown>(queryKey: QueryKey, queryFn: QueryFunction<TData>, options?: InViewPrefetchOptions): (node?: Element | null) => void;
+
+export { type InViewPrefetchOptions, useInViewPrefetch };

package/dist/hooks/useInViewPrefetch.js

@@ -1,21 +1,31 @@
-import { useQueryClient } from "@tanstack/react-query";
-import { useEffect, useRef } from "react";
-import { useInView } from "react-intersection-observer";
-import { DEFAULT_STALE_TIME } from "../core/config.js";
-export function useInViewPrefetch(queryKey, queryFn, options = {}) {
-    const queryClient = useQueryClient();
-    const { threshold = 0.1, rootMargin = "50px", triggerOnce = true, enabled = true, staleTime = DEFAULT_STALE_TIME } = options;
-    const [ref, inView] = useInView({ threshold, rootMargin, triggerOnce });
-    const queryFnRef = useRef(queryFn);
-    useEffect(() => { queryFnRef.current = queryFn; }, [queryFn]);
-    const stableQueryKey = useRef(queryKey);
-    useEffect(() => { if (JSON.stringify(stableQueryKey.current) !== JSON.stringify(queryKey)) {
-        stableQueryKey.current = queryKey;
-    } }, [queryKey]);
-    useEffect(() => {
-        if (inView && enabled) {
-            queryClient.prefetchQuery({ queryKey: stableQueryKey.current, queryFn: queryFnRef.current, staleTime });
-        }
-    }, [inView, queryClient, enabled, staleTime]);
-    return ref;
+import { DEFAULT_STALE_TIME } from '../chunk-EXITP7QO.js';
+import '../chunk-JN2Y6RSY.js';
+import { useQueryClient } from '@tanstack/react-query';
+import { useRef, useEffect } from 'react';
+import { useInView } from 'react-intersection-observer';
+
+function useInViewPrefetch(queryKey, queryFn, options = {}) {
+  const queryClient = useQueryClient();
+  const { threshold = 0.1, rootMargin = "50px", triggerOnce = true, enabled = true, staleTime = DEFAULT_STALE_TIME } = options;
+  const [ref, inView] = useInView({ threshold, rootMargin, triggerOnce });
+  const queryFnRef = useRef(queryFn);
+  useEffect(() => {
+    queryFnRef.current = queryFn;
+  }, [queryFn]);
+  const stableQueryKey = useRef(queryKey);
+  useEffect(() => {
+    if (JSON.stringify(stableQueryKey.current) !== JSON.stringify(queryKey)) {
+      stableQueryKey.current = queryKey;
+    }
+  }, [queryKey]);
+  useEffect(() => {
+    if (inView && enabled) {
+      queryClient.prefetchQuery({ queryKey: stableQueryKey.current, queryFn: queryFnRef.current, staleTime });
+    }
+  }, [inView, queryClient, enabled, staleTime]);
+  return ref;
 }
+
+export { useInViewPrefetch };
+//# sourceMappingURL=useInViewPrefetch.js.map
+//# sourceMappingURL=useInViewPrefetch.js.map

package/dist/hooks/useInViewPrefetch.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/useInViewPrefetch.ts"],"names":[],"mappings":";;;;;;AAQO,SAAS,iBAAA,CAAmC,QAAA,EAAoB,OAAA,EAA+B,OAAA,GAAiC,EAAC,EAAG;AACzI,EAAA,MAAM,cAAc,cAAA,EAAe;AACnC,EAAA,MAAM,EAAE,SAAA,GAAY,GAAA,EAAK,UAAA,GAAa,MAAA,EAAQ,WAAA,GAAc,IAAA,EAAM,OAAA,GAAU,IAAA,EAAM,SAAA,GAAY,kBAAA,EAAmB,GAAI,OAAA;AACrH,EAAA,MAAM,CAAC,KAAK,MAAM,CAAA,GAAI,UAAU,EAAE,SAAA,EAAW,UAAA,EAAY,WAAA,EAAa,CAAA;AACtE,EAAA,MAAM,UAAA,GAAa,OAAO,OAAO,CAAA;AACjC,EAAA,SAAA,CAAU,MAAM;AAAE,IAAA,UAAA,CAAW,OAAA,GAAU,OAAA;AAAA,EAAS,CAAA,EAAG,CAAC,OAAO,CAAC,CAAA;AAC5D,EAAA,MAAM,cAAA,GAAiB,OAAO,QAAQ,CAAA;AACtC,EAAA,SAAA,CAAU,MAAM;AAAE,IAAA,IAAI,IAAA,CAAK,UAAU,cAAA,CAAe,OAAO,MAAM,IAAA,CAAK,SAAA,CAAU,QAAQ,CAAA,EAAG;AAAE,MAAA,cAAA,CAAe,OAAA,GAAU,QAAA;AAAA,IAAU;AAAA,EAAE,CAAA,EAAG,CAAC,QAAQ,CAAC,CAAA;AAC/I,EAAA,SAAA,CAAU,MAAM;AACd,IAAA,IAAI,UAAU,OAAA,EAAS;AACrB,MAAA,WAAA,CAAY,aAAA,CAAc,EAAE,QAAA,EAAU,cAAA,CAAe,SAAS,OAAA,EAAS,UAAA,CAAW,OAAA,EAAS,SAAA,EAAW,CAAA;AAAA,IACxG;AAAA,EACF,GAAG,CAAC,MAAA,EAAQ,WAAA,EAAa,OAAA,EAAS,SAAS,CAAC,CAAA;AAC5C,EAAA,OAAO,GAAA;AACT","file":"useInViewPrefetch.js","sourcesContent":["import type { QueryFunction, QueryKey } from \"@tanstack/react-query\";\nimport { useQueryClient } from \"@tanstack/react-query\";\nimport { useEffect, useRef } from \"react\";\nimport { useInView } from \"react-intersection-observer\";\nimport { DEFAULT_STALE_TIME } from \"../core/config.js\";\n\nexport interface InViewPrefetchOptions { threshold?: number; rootMargin?: string; triggerOnce?: boolean; enabled?: boolean; staleTime?: number }\n\nexport function useInViewPrefetch<TData = unknown>(queryKey: QueryKey, queryFn: QueryFunction<TData>, options: InViewPrefetchOptions = {}) {\n  const queryClient = useQueryClient();\n  const { threshold = 0.1, rootMargin = \"50px\", triggerOnce = true, enabled = true, staleTime = DEFAULT_STALE_TIME } = options;\n  const [ref, inView] = useInView({ threshold, rootMargin, triggerOnce });\n  const queryFnRef = useRef(queryFn);\n  useEffect(() => { queryFnRef.current = queryFn; }, [queryFn]);\n  const stableQueryKey = useRef(queryKey);\n  useEffect(() => { if (JSON.stringify(stableQueryKey.current) !== JSON.stringify(queryKey)) { stableQueryKey.current = queryKey; } }, [queryKey]);\n  useEffect(() => {\n    if (inView && enabled) {\n      queryClient.prefetchQuery({ queryKey: stableQueryKey.current, queryFn: queryFnRef.current, staleTime });\n    }\n  }, [inView, queryClient, enabled, staleTime]);\n  return ref;\n}"]}