@qiaopeng/tanstack-query-plus 0.1.0

package/dist/hooks/batchQueries.js

@@ -0,0 +1,301 @@
+import { useQueries, useQuery, useQueryClient, useSuspenseQueries } from "@tanstack/react-query";
+import { useEffect, useMemo, useRef } from "react";
+function createErrorAggregate(results, queries) {
+    const errors = [];
+    const errorsByType = new Map();
+    results.forEach((result, index) => {
+        if (result.isError && result.error) {
+            const error = result.error;
+            const queryKey = queries[index]?.queryKey;
+            errors.push({ index, error, queryKey });
+            const errorType = error instanceof Error ? error.constructor.name : "Unknown";
+            if (!errorsByType.has(errorType)) {
+                errorsByType.set(errorType, []);
+            }
+            errorsByType.get(errorType).push(error);
+        }
+    });
+    const firstError = errors.length > 0 ? errors[0].error : null;
+    const lastError = errors.length > 0 ? errors[errors.length - 1].error : null;
+    const errorSummary = errors.length === 0 ? "No errors" : errors.length === 1 ? `1 error: ${firstError instanceof Error ? firstError.message : String(firstError)}` : `${errors.length} errors: ${Array.from(errorsByType.entries()).map(([type, errs]) => `${type}(${errs.length})`).join(", ")}`;
+    return { totalErrors: errors.length, errors, errorsByType, firstError, lastError, errorSummary };
+}
+function createOperationReport(results, queries, startTime, retryCount = 0) {
+    const total = results.length;
+    const successResults = [];
+    const failureErrors = [];
+    results.forEach((result, index) => {
+        if (result.isSuccess && result.data !== undefined) {
+            successResults.push({ index, data: result.data });
+        }
+        else if (result.isError && result.error) {
+            failureErrors.push({ index, error: result.error, queryKey: queries[index]?.queryKey });
+        }
+    });
+    const successful = successResults.length;
+    const failed = failureErrors.length;
+    const isFullSuccess = successful === total && failed === 0;
+    const isFullFailure = failed === total && successful === 0;
+    const isPartialSuccess = successful > 0 && failed > 0;
+    return { total, successful, failed, successResults, failureErrors, isPartialSuccess, isFullSuccess, isFullFailure, duration: Date.now() - startTime, retryCount };
+}
+async function executeBatchOperationWithRetry(operation, retryConfig) {
+    const maxRetries = retryConfig?.maxRetries ?? 0;
+    const retryDelay = retryConfig?.retryDelay ?? 1000;
+    const shouldRetry = retryConfig?.shouldRetry;
+    let retryCount = 0;
+    let results = await operation();
+    if (maxRetries === 0) {
+        return { results, retryCount };
+    }
+    while (retryCount < maxRetries) {
+        const hasFailures = results.some((r) => r.status === "rejected");
+        if (!hasFailures)
+            break;
+        if (shouldRetry) {
+            const firstError = results.find((r) => r.status === "rejected");
+            if (firstError && firstError.status === "rejected") {
+                const error = firstError.reason instanceof Error ? firstError.reason : new Error(String(firstError.reason));
+                if (!shouldRetry(error, retryCount + 1)) {
+                    break;
+                }
+            }
+        }
+        const delay = typeof retryDelay === "function" ? retryDelay(retryCount) : retryDelay;
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        retryCount++;
+        results = await operation();
+    }
+    return { results, retryCount };
+}
+export function calculateBatchStats(results) {
+    const total = results.length;
+    const loading = results.filter((result) => result.isLoading).length;
+    const success = results.filter((result) => result.isSuccess).length;
+    const error = results.filter((result) => result.isError).length;
+    const stale = results.filter((result) => result.isStale).length;
+    return { total, loading, success, error, stale, successRate: total > 0 ? (success / total) * 100 : 0, errorRate: total > 0 ? (error / total) * 100 : 0 };
+}
+export function useEnhancedQueries(queries, config = {}) {
+    const queryClient = useQueryClient();
+    const { results, stats } = useQueries({ queries, combine: (results) => ({ results, stats: calculateBatchStats(results) }) });
+    const retryCountRef = useRef(0);
+    const operations = {
+        _queryClient: queryClient,
+        _queries: queries,
+        _results: results,
+        refetchAll: async () => {
+            const operation = () => {
+                const promises = queries.map((query) => queryClient.refetchQueries({ queryKey: query.queryKey, exact: true }));
+                return Promise.allSettled(promises);
+            };
+            const { results: settledResults, retryCount } = await executeBatchOperationWithRetry(operation, config.retryConfig);
+            retryCountRef.current = retryCount;
+            if (config.enablePartialSuccess) {
+                const report = operations.getOperationReport();
+                if (report.isPartialSuccess && config.onPartialSuccess) {
+                    config.onPartialSuccess(report);
+                }
+            }
+            return settledResults;
+        },
+        invalidateAll: async () => {
+            const operation = () => {
+                const promises = queries.map((query) => queryClient.invalidateQueries({ queryKey: query.queryKey, exact: true }));
+                return Promise.allSettled(promises);
+            };
+            const { results: settledResults, retryCount } = await executeBatchOperationWithRetry(operation, config.retryConfig);
+            retryCountRef.current = retryCount;
+            return settledResults;
+        },
+        cancelAll: async () => {
+            const promises = queries.map((query) => queryClient.cancelQueries({ queryKey: query.queryKey, exact: true }));
+            return Promise.allSettled(promises);
+        },
+        resetAll: async () => {
+            const operation = () => {
+                const promises = queries.map((query) => queryClient.resetQueries({ queryKey: query.queryKey, exact: true }));
+                return Promise.allSettled(promises);
+            };
+            const { results: settledResults, retryCount } = await executeBatchOperationWithRetry(operation, config.retryConfig);
+            retryCountRef.current = retryCount;
+            return settledResults;
+        },
+        removeAll: () => {
+            queries.forEach((query) => { queryClient.removeQueries({ queryKey: query.queryKey, exact: true }); });
+        },
+        retryFailed: async () => {
+            const failedIndices = results.map((result, index) => (result.isError ? index : -1)).filter((index) => index !== -1);
+            if (failedIndices.length === 0) {
+                return createOperationReport(results, queries, 0, 0);
+            }
+            const retryPromises = failedIndices.map((index) => {
+                const query = queries[index];
+                return queryClient.refetchQueries({ queryKey: query.queryKey, exact: true });
+            });
+            await Promise.allSettled(retryPromises);
+            retryCountRef.current++;
+            return operations.getOperationReport();
+        },
+        getErrorAggregate: () => { return createErrorAggregate(results, queries); },
+        getOperationReport: () => { return createOperationReport(results, queries, 0, retryCountRef.current); }
+    };
+    return { data: results, stats, operations, config };
+}
+export function useEnhancedSuspenseQueries(queries, config = {}) {
+    const queryClient = useQueryClient();
+    const { results, stats } = useSuspenseQueries({ queries, combine: (results) => ({ results, stats: calculateBatchStats(results) }) });
+    const retryCountRef = useRef(0);
+    const operations = {
+        _queryClient: queryClient,
+        _queries: queries,
+        _results: results,
+        refetchAll: async () => {
+            const operation = () => {
+                const promises = queries.map((query) => queryClient.refetchQueries({ queryKey: query.queryKey, exact: true }));
+                return Promise.allSettled(promises);
+            };
+            const { results: settledResults, retryCount } = await executeBatchOperationWithRetry(operation, config.retryConfig);
+            retryCountRef.current = retryCount;
+            if (config.enablePartialSuccess) {
+                const report = operations.getOperationReport();
+                if (report.isPartialSuccess && config.onPartialSuccess) {
+                    config.onPartialSuccess(report);
+                }
+            }
+            return settledResults;
+        },
+        invalidateAll: async () => {
+            const operation = () => {
+                const promises = queries.map((query) => queryClient.invalidateQueries({ queryKey: query.queryKey, exact: true }));
+                return Promise.allSettled(promises);
+            };
+            const { results: settledResults, retryCount } = await executeBatchOperationWithRetry(operation, config.retryConfig);
+            retryCountRef.current = retryCount;
+            return settledResults;
+        },
+        cancelAll: async () => {
+            const promises = queries.map((query) => queryClient.cancelQueries({ queryKey: query.queryKey, exact: true }));
+            return Promise.allSettled(promises);
+        },
+        resetAll: async () => {
+            const operation = () => {
+                const promises = queries.map((query) => queryClient.resetQueries({ queryKey: query.queryKey, exact: true }));
+                return Promise.allSettled(promises);
+            };
+            const { results: settledResults, retryCount } = await executeBatchOperationWithRetry(operation, config.retryConfig);
+            retryCountRef.current = retryCount;
+            return settledResults;
+        },
+        removeAll: () => {
+            queries.forEach((query) => { queryClient.removeQueries({ queryKey: query.queryKey, exact: true }); });
+        },
+        retryFailed: async () => {
+            const failedIndices = results.map((result, index) => (result.isError ? index : -1)).filter((index) => index !== -1);
+            if (failedIndices.length === 0) {
+                return createOperationReport(results, queries, 0, 0);
+            }
+            const retryPromises = failedIndices.map((index) => {
+                const query = queries[index];
+                return queryClient.refetchQueries({ queryKey: query.queryKey, exact: true });
+            });
+            await Promise.allSettled(retryPromises);
+            retryCountRef.current++;
+            return operations.getOperationReport();
+        },
+        getErrorAggregate: () => { return createErrorAggregate(results, queries); },
+        getOperationReport: () => { return createOperationReport(results, queries, 0, retryCountRef.current); }
+    };
+    return { data: results, stats, operations, config };
+}
+export function createBatchQueryConfig(config = {}) {
+    return { enableStats: true, enableBatchOperations: true, autoRefreshInterval: undefined, onBatchSuccess: undefined, onBatchError: undefined, onBatchSettled: undefined, enablePartialSuccess: false, onPartialSuccess: undefined, retryConfig: undefined, ...config };
+}
+export const batchQueryUtils = {
+    isAllLoading: (results) => results.every((result) => result.isLoading),
+    isAllSuccess: (results) => results.every((result) => result.isSuccess),
+    hasError: (results) => results.some((result) => result.isError),
+    hasStale: (results) => results.some((result) => result.isStale),
+    getAllErrors: (results) => results.filter((result) => result.isError).map((result) => result.error).filter((error) => error instanceof Error),
+    getAllData: (results) => results.filter((result) => result.isSuccess).map((result) => result.data),
+    isAllPending: (results) => results.every((result) => result.isPending),
+    isAnyFetching: (results) => results.some((result) => result.isFetching),
+    getSuccessData: (results) => results.filter((result) => result.isSuccess && result.data !== undefined).map((result) => result.data),
+    getFirstError: (results) => { const errorResult = results.find((result) => result.isError); return errorResult?.error instanceof Error ? errorResult.error : null; },
+    createErrorAggregate: (results, queries) => createErrorAggregate(results, queries),
+    createOperationReport: (results, queries, startTime, retryCount = 0) => createOperationReport(results, queries, startTime, retryCount)
+};
+export function useCombinedQueries(options) {
+    return useQueries(options);
+}
+export function useDynamicBatchQueries(options) {
+    const { items, queryKeyPrefix, queryFn, enabled = true, staleTime, gcTime, config = {} } = options;
+    const queries = useMemo(() => {
+        if (!enabled || items.length === 0)
+            return [];
+        return items.map((item) => ({ queryKey: [...queryKeyPrefix, item], queryFn: () => queryFn(item), staleTime, gcTime, enabled }));
+    }, [items, queryKeyPrefix, queryFn, enabled, staleTime, gcTime]);
+    return useEnhancedQueries(queries, config);
+}
+export function useDependentBatchQueries(options) {
+    const { primaryQuery, dependentQueries, config = {} } = options;
+    const primaryResult = useQuery(primaryQuery);
+    const queries = useMemo(() => {
+        try {
+            if (!primaryResult.data) {
+                return [];
+            }
+            return dependentQueries(primaryResult.data);
+        }
+        catch {
+            return [];
+        }
+    }, [primaryResult.data, dependentQueries]);
+    const enhancedQueriesResult = useEnhancedQueries(queries, config);
+    return { primaryResult, results: enhancedQueriesResult.data, stats: enhancedQueriesResult.stats, operations: enhancedQueriesResult.operations };
+}
+export function useAutoRefreshBatchQueries(options) {
+    const { queries, refreshInterval = 30000, enabled = true, config = {} } = options;
+    const result = useEnhancedQueries(queries, config);
+    useEffect(() => {
+        if (!enabled || !refreshInterval || !result.operations)
+            return;
+        const intervalId = setInterval(() => { result.operations?.refetchAll(); }, refreshInterval);
+        return () => clearInterval(intervalId);
+    }, [enabled, refreshInterval, result.operations]);
+    return result;
+}
+export function useDashboardQueries(queriesMap) {
+    const queries = useMemo(() => { return Object.values(queriesMap); }, [queriesMap]);
+    const { results, combinedData, stats } = useQueries({ queries, combine: (results) => {
+            const keys = Object.keys(queriesMap);
+            const data = {};
+            keys.forEach((key, index) => { data[key] = results[index].data; });
+            return { results, combinedData: data, stats: calculateBatchStats(results) };
+        } });
+    const isLoading = results.some((r) => r.isLoading);
+    const isError = results.some((r) => r.isError);
+    const isSuccess = results.every((r) => r.isSuccess);
+    return { data: combinedData, results, stats, isLoading, isError, isSuccess };
+}
+export function usePaginatedBatchQueries(options) {
+    const { pageNumbers, queryKeyPrefix, queryFn, staleTime, config } = options;
+    return useDynamicBatchQueries({ items: pageNumbers, queryKeyPrefix, queryFn, staleTime, config });
+}
+export function useConditionalBatchQueries(queries) {
+    const enabledQueries = useMemo(() => { return queries.filter((q) => q.enabled !== false); }, [queries]);
+    return useEnhancedQueries(enabledQueries);
+}
+export function useRetryBatchQueries(options) {
+    const { queries, retry, retryDelay, config } = options;
+    const queriesWithRetry = useMemo(() => { return queries.map((query) => ({ ...query, retry: query.retry ?? retry, retryDelay: query.retryDelay ?? retryDelay })); }, [queries, retry, retryDelay]);
+    return useEnhancedQueries(queriesWithRetry, config);
+}
+export function useBatchQueryPerformance(results) {
+    return useMemo(() => {
+        const stats = calculateBatchStats(results);
+        const fetchTimes = results.filter((r) => r.dataUpdatedAt > 0).map((r) => r.dataUpdatedAt);
+        const avgFetchTime = fetchTimes.length > 0 ? fetchTimes.reduce((a, b) => a + b, 0) / fetchTimes.length : 0;
+        return { ...stats, avgFetchTime, totalQueries: results.length, activeQueries: results.filter((r) => r.isFetching).length, cachedQueries: results.filter((r) => !r.isStale).length };
+    }, [results]);
+}

package/dist/hooks/index.d.ts

@@ -0,0 +1,8 @@
+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, createOffsetPaginationOptions, createPageNumberPaginationOptions, useEnhancedInfiniteQuery } from "./useInfiniteQuery.js";
+export { cancelQueriesBatch, invalidateQueriesBatch, type MutationDefaultsConfig, type MutationKey, setQueryDataBatch, setupMutationDefaults, useBatchMutation, useConditionalOptimisticMutation, useListMutation, useMutation } from "./useMutation.js";
+export { type HoverPrefetchOptions, type InViewPrefetchOptions, type PrefetchOptions, useBatchPrefetch, useConditionalPrefetch, useHoverPrefetch, useIdlePrefetch, useInViewPrefetch, usePeriodicPrefetch, usePredictivePrefetch, usePriorityPrefetch, useRoutePrefetch, useSmartPrefetch } from "./usePrefetch.js";
+export { skipToken, useEnhancedQuery } from "./useQuery.js";
+export { createSuspenseInfiniteQuery, createSuspenseQuery, useEnhancedSuspenseInfiniteQuery, useEnhancedSuspenseQuery } from "./useSuspenseQuery.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,sBAAsB,EACtB,0BAA0B,EAC1B,wBAAwB,EACxB,kBAAkB,EAClB,0BAA0B,EAC1B,mBAAmB,EACnB,wBAAwB,EACxB,sBAAsB,EACtB,kBAAkB,EAClB,0BAA0B,EAC1B,wBAAwB,EACxB,oBAAoB,EACrB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,0BAA0B,EAC1B,gBAAgB,EAChB,eAAe,EACf,KAAK,sBAAsB,EAC3B,aAAa,EACb,iBAAiB,EACjB,aAAa,EACb,KAAK,oBAAoB,EACzB,oBAAoB,EACrB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,6BAA6B,EAAE,6BAA6B,EAAE,iCAAiC,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAClK,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EACtB,KAAK,sBAAsB,EAC3B,KAAK,WAAW,EAChB,iBAAiB,EACjB,qBAAqB,EACrB,gBAAgB,EAChB,gCAAgC,EAChC,eAAe,EACf,WAAW,EACZ,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,eAAe,EACpB,gBAAgB,EAChB,sBAAsB,EACtB,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EACjB,mBAAmB,EACnB,qBAAqB,EACrB,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAC5D,OAAO,EAAE,2BAA2B,EAAE,mBAAmB,EAAE,gCAAgC,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/hooks/index.js

@@ -0,0 +1,7 @@
+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, createOffsetPaginationOptions, createPageNumberPaginationOptions, useEnhancedInfiniteQuery } from "./useInfiniteQuery.js";
+export { cancelQueriesBatch, invalidateQueriesBatch, setQueryDataBatch, setupMutationDefaults, useBatchMutation, useConditionalOptimisticMutation, useListMutation, useMutation } from "./useMutation.js";
+export { useBatchPrefetch, useConditionalPrefetch, useHoverPrefetch, useIdlePrefetch, useInViewPrefetch, usePeriodicPrefetch, usePredictivePrefetch, usePriorityPrefetch, useRoutePrefetch, useSmartPrefetch } from "./usePrefetch.js";
+export { skipToken, useEnhancedQuery } from "./useQuery.js";
+export { createSuspenseInfiniteQuery, createSuspenseQuery, useEnhancedSuspenseInfiniteQuery, useEnhancedSuspenseQuery } from "./useSuspenseQuery.js";

package/dist/hooks/useFocusManager.d.ts

@@ -0,0 +1,41 @@
+import type { QueryKey } from "@tanstack/react-query";
+export interface UseFocusRefetchOptions {
+    enabled?: boolean;
+    minInterval?: number;
+    queryKeys?: QueryKey[];
+}
+export interface UsePauseFocusOptions {
+    autoPause?: boolean;
+    pauseWhen?: boolean;
+}
+export declare function useFocusState(): boolean;
+export declare function useFocusRefetch(options?: UseFocusRefetchOptions): void;
+export declare function usePauseFocus(options?: UsePauseFocusOptions): {
+    pause: () => void;
+    resume: () => void;
+};
+export declare function useSmartFocusManager(): {
+    pause: () => void;
+    resume: () => void;
+    getStats: () => {
+        isPaused: boolean;
+        pauseCount: number;
+        isFocused: boolean;
+    };
+    stats: {
+        isPaused: boolean;
+        pauseCount: number;
+        isFocused: boolean;
+    };
+};
+export declare function useConditionalFocusRefetch(queryKey: QueryKey, condition: () => boolean, options?: {
+    minInterval?: number;
+    enabled?: boolean;
+}): void;
+export declare function useFocusCallback(callback: () => void, options?: {
+    minInterval?: number;
+    enabled?: boolean;
+    queryKey?: QueryKey;
+}): void;
+export declare function usePageVisibility(): boolean;
+//# sourceMappingURL=useFocusManager.d.ts.map

package/dist/hooks/useFocusManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFocusManager.d.ts","sourceRoot":"","sources":["../../src/hooks/useFocusManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAKtD,MAAM,WAAW,sBAAsB;IAAG,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAA;CAAE;AAC3G,MAAM,WAAW,oBAAoB;IAAG,SAAS,CAAC,EAAE,OAAO,CAAC;IAAC,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE;AAElF,wBAAgB,aAAa,IAAI,OAAO,CAOvC;AAED,wBAAgB,eAAe,CAAC,OAAO,GAAE,sBAA2B,QAkBnE;AAED,wBAAgB,aAAa,CAAC,OAAO,GAAE,oBAAyB;;;EAW/D;AAED,wBAAgB,oBAAoB;;;;;;;;;;;;;EAMnC;AAED,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,OAAO,EAAE,OAAO,GAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAO,QAkBjJ;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,OAAO,GAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,QAAQ,CAAA;CAAO,QAyBpI;AAED,wBAAgB,iBAAiB,IAAI,OAAO,CAO3C"}

package/dist/hooks/useFocusManager.js

@@ -0,0 +1,109 @@
+import { useQueryClient } from "@tanstack/react-query";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { focusManager, getSmartFocusManager, pauseFocusManager, resumeFocusManager } from "../core/focusManager.js";
+export function useFocusState() {
+    const [focused, setFocused] = useState(focusManager.isFocused());
+    useEffect(() => {
+        const unsubscribe = focusManager.subscribe((isFocused) => { setFocused(isFocused); });
+        return unsubscribe;
+    }, []);
+    return focused;
+}
+export function useFocusRefetch(options = {}) {
+    const queryClient = useQueryClient();
+    const { enabled = true, minInterval = 5000, queryKeys = [] } = options;
+    const smartManager = getSmartFocusManager();
+    const queryKeysJson = JSON.stringify(queryKeys);
+    const stableQueryKeys = useMemo(() => queryKeys, [queryKeysJson]);
+    useEffect(() => {
+        if (!enabled || stableQueryKeys.length === 0)
+            return;
+        const unsubscribe = focusManager.subscribe((isFocused) => {
+            if (!isFocused)
+                return;
+            stableQueryKeys.forEach((queryKey) => {
+                if (smartManager.shouldRefetch(queryKey, minInterval)) {
+                    queryClient.invalidateQueries({ queryKey });
+                }
+            });
+        });
+        return unsubscribe;
+    }, [queryClient, enabled, minInterval, stableQueryKeys, smartManager]);
+}
+export function usePauseFocus(options = {}) {
+    const { autoPause = false, pauseWhen = false } = options;
+    useEffect(() => {
+        if (autoPause || pauseWhen) {
+            pauseFocusManager();
+            return () => { resumeFocusManager(); };
+        }
+    }, [autoPause, pauseWhen]);
+    const pause = useCallback(() => { pauseFocusManager(); }, []);
+    const resume = useCallback(() => { resumeFocusManager(); }, []);
+    return { pause, resume };
+}
+export function useSmartFocusManager() {
+    const manager = getSmartFocusManager();
+    const pause = useCallback(() => { manager.pause(); }, [manager]);
+    const resume = useCallback(() => { manager.resume(); }, [manager]);
+    const getStats = useCallback(() => { return manager.getStats(); }, [manager]);
+    return { pause, resume, getStats, stats: manager.getStats() };
+}
+export function useConditionalFocusRefetch(queryKey, condition, options = {}) {
+    const queryClient = useQueryClient();
+    const { minInterval = 5000, enabled = true } = options;
+    const smartManager = getSmartFocusManager();
+    const queryKeyJson = JSON.stringify(queryKey);
+    const stableQueryKey = useMemo(() => queryKey, [queryKeyJson]);
+    const conditionRef = useRef(condition);
+    useEffect(() => { conditionRef.current = condition; }, [condition]);
+    useEffect(() => {
+        if (!enabled)
+            return;
+        const unsubscribe = focusManager.subscribe((isFocused) => {
+            if (!isFocused || !conditionRef.current())
+                return;
+            if (smartManager.shouldRefetch(stableQueryKey, minInterval)) {
+                queryClient.invalidateQueries({ queryKey: stableQueryKey });
+            }
+        });
+        return unsubscribe;
+    }, [queryClient, stableQueryKey, minInterval, enabled, smartManager]);
+}
+export function useFocusCallback(callback, options = {}) {
+    const { minInterval = 0, enabled = true, queryKey } = options;
+    const lastCallTime = useRef(0);
+    const smartManager = getSmartFocusManager();
+    const queryKeyJson = JSON.stringify(queryKey);
+    const stableQueryKey = useMemo(() => queryKey, [queryKeyJson]);
+    const callbackRef = useRef(callback);
+    useEffect(() => { callbackRef.current = callback; }, [callback]);
+    useEffect(() => {
+        if (!enabled)
+            return;
+        const unsubscribe = focusManager.subscribe((isFocused) => {
+            if (!isFocused)
+                return;
+            if (stableQueryKey !== undefined) {
+                if (smartManager.shouldRefetch(stableQueryKey, minInterval)) {
+                    callbackRef.current();
+                }
+                return;
+            }
+            const now = Date.now();
+            if (minInterval > 0 && now - lastCallTime.current < minInterval)
+                return;
+            lastCallTime.current = now;
+            callbackRef.current();
+        });
+        return unsubscribe;
+    }, [minInterval, enabled, stableQueryKey, smartManager]);
+}
+export function usePageVisibility() {
+    const [isVisible, setIsVisible] = useState(typeof document !== "undefined" ? !document.hidden : true);
+    useEffect(() => {
+        const unsubscribe = focusManager.subscribe((isFocused) => { setIsVisible(isFocused); });
+        return unsubscribe;
+    }, []);
+    return isVisible;
+}

package/dist/hooks/useInfiniteQuery.d.ts

@@ -0,0 +1,58 @@
+import type { QueryFunction, QueryKey, UseInfiniteQueryOptions, UseInfiniteQueryResult } from "@tanstack/react-query";
+import type { CursorPaginatedResponse, OffsetPaginatedResponse, PageNumberPaginatedResponse } from "../types/infinite";
+export declare function useEnhancedInfiniteQuery<TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UseInfiniteQueryResult<TData, TError>;
+export 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;
+}): import("@tanstack/query-core").OmitKeyof<UseInfiniteQueryOptions<TQueryFnData, Error, import("@tanstack/query-core").InfiniteData<TQueryFnData, unknown>, TQueryKey, TPageParam>, "queryFn"> & {
+    queryFn?: QueryFunction<TQueryFnData, TQueryKey, TPageParam> | undefined;
+} & {
+    queryKey: import("@tanstack/query-core").DataTag<TQueryKey, import("@tanstack/query-core").InfiniteData<TQueryFnData, unknown>, Error>;
+};
+export declare function createCursorPaginationOptions<T>(config: {
+    queryKey: QueryKey;
+    queryFn: (cursor: string | null) => Promise<CursorPaginatedResponse<T>>;
+    initialCursor?: string | null;
+    staleTime?: number;
+    gcTime?: number;
+}): import("@tanstack/query-core").OmitKeyof<UseInfiniteQueryOptions<CursorPaginatedResponse<T>, Error, import("@tanstack/query-core").InfiniteData<CursorPaginatedResponse<T>, unknown>, readonly unknown[], string | null>, "queryFn"> & {
+    queryFn?: QueryFunction<CursorPaginatedResponse<T>, readonly unknown[], string | null> | undefined;
+} & {
+    queryKey: readonly unknown[] & {
+        [dataTagSymbol]: import("@tanstack/query-core").InfiniteData<CursorPaginatedResponse<T>, unknown>;
+        [dataTagErrorSymbol]: Error;
+    };
+};
+export declare function createOffsetPaginationOptions<T>(config: {
+    queryKey: QueryKey;
+    queryFn: (offset: number, limit: number) => Promise<OffsetPaginatedResponse<T>>;
+    limit?: number;
+    staleTime?: number;
+    gcTime?: number;
+}): import("@tanstack/query-core").OmitKeyof<UseInfiniteQueryOptions<OffsetPaginatedResponse<T>, Error, import("@tanstack/query-core").InfiniteData<OffsetPaginatedResponse<T>, unknown>, unknown[], number>, "queryFn"> & {
+    queryFn?: QueryFunction<OffsetPaginatedResponse<T>, unknown[], number> | undefined;
+} & {
+    queryKey: unknown[] & {
+        [dataTagSymbol]: import("@tanstack/query-core").InfiniteData<OffsetPaginatedResponse<T>, unknown>;
+        [dataTagErrorSymbol]: Error;
+    };
+};
+export declare function createPageNumberPaginationOptions<T>(config: {
+    queryKey: QueryKey;
+    queryFn: (page: number) => Promise<PageNumberPaginatedResponse<T>>;
+    staleTime?: number;
+    gcTime?: number;
+}): import("@tanstack/query-core").OmitKeyof<UseInfiniteQueryOptions<PageNumberPaginatedResponse<T>, Error, import("@tanstack/query-core").InfiniteData<PageNumberPaginatedResponse<T>, unknown>, readonly unknown[], number>, "queryFn"> & {
+    queryFn?: QueryFunction<PageNumberPaginatedResponse<T>, readonly unknown[], number> | undefined;
+} & {
+    queryKey: readonly unknown[] & {
+        [dataTagSymbol]: import("@tanstack/query-core").InfiniteData<PageNumberPaginatedResponse<T>, unknown>;
+        [dataTagErrorSymbol]: Error;
+    };
+};
+//# sourceMappingURL=useInfiniteQuery.d.ts.map

package/dist/hooks/useInfiniteQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInfiniteQuery.d.ts","sourceRoot":"","sources":["../../src/hooks/useInfiniteQuery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AACtH,OAAO,KAAK,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,2BAA2B,EAAE,MAAM,mBAAmB,CAAC;AAEvH,wBAAgB,wBAAwB,CAAC,YAAY,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK,EAAE,KAAK,GAAG,YAAY,EAAE,SAAS,SAAS,QAAQ,GAAG,QAAQ,EAAE,UAAU,GAAG,OAAO,EAAE,OAAO,EAAE,uBAAuB,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,UAAU,CAAC,GAAG,sBAAsB,CAAC,KAAK,EAAE,MAAM,CAAC,CAE/R;AACD,wBAAgB,0BAA0B,CAAC,YAAY,GAAG,OAAO,EAAE,SAAS,SAAS,QAAQ,GAAG,QAAQ,EAAE,UAAU,GAAG,OAAO,EAAE,MAAM,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,aAAa,CAAC,YAAY,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;IAAC,gBAAgB,EAAE,UAAU,CAAC;IAAC,gBAAgB,EAAE,CAAC,QAAQ,EAAE,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE,EAAE,aAAa,EAAE,UAAU,EAAE,aAAa,EAAE,UAAU,EAAE,KAAK,UAAU,GAAG,SAAS,GAAG,IAAI,CAAC;IAAC,oBAAoB,CAAC,EAAE,CAAC,SAAS,EAAE,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE,EAAE,cAAc,EAAE,UAAU,EAAE,aAAa,EAAE,UAAU,EAAE,KAAK,UAAU,GAAG,SAAS,GAAG,IAAI,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE;;;;EAEnmB;AACD,wBAAgB,6BAA6B,CAAC,CAAC,EAAE,MAAM,EAAE;IAAE,QAAQ,EAAE,QAAQ,CAAC;IAAC,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,KAAK,OAAO,CAAC,uBAAuB,CAAC,CAAC,CAAC,CAAC,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE;;;;;;;EAU3N;AACD,wBAAgB,6BAA6B,CAAC,CAAC,EAAE,MAAM,EAAE;IAAE,QAAQ,EAAE,QAAQ,CAAC;IAAC,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,uBAAuB,CAAC,CAAC,CAAC,CAAC,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE;;;;;;;EAmBpN;AACD,wBAAgB,iCAAiC,CAAC,CAAC,EAAE,MAAM,EAAE;IAAE,QAAQ,EAAE,QAAQ,CAAC;IAAC,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,2BAA2B,CAAC,CAAC,CAAC,CAAC,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE;;;;;;;EAiB3L"}

package/dist/hooks/useInfiniteQuery.js

@@ -0,0 +1,61 @@
+import { infiniteQueryOptions, useInfiniteQuery } from "@tanstack/react-query";
+export function useEnhancedInfiniteQuery(options) {
+    return useInfiniteQuery(options);
+}
+export function createInfiniteQueryOptions(config) {
+    return infiniteQueryOptions(config);
+}
+export function createCursorPaginationOptions(config) {
+    return createInfiniteQueryOptions({
+        queryKey: config.queryKey,
+        queryFn: ({ pageParam }) => config.queryFn(pageParam),
+        initialPageParam: config.initialCursor ?? null,
+        getNextPageParam: (lastPage) => lastPage.cursor ?? null,
+        getPreviousPageParam: () => null,
+        staleTime: config.staleTime,
+        gcTime: config.gcTime
+    });
+}
+export function createOffsetPaginationOptions(config) {
+    const limit = config.limit ?? 20;
+    return createInfiniteQueryOptions({
+        queryKey: [...config.queryKey, limit],
+        queryFn: ({ pageParam }) => config.queryFn(pageParam, limit),
+        initialPageParam: 0,
+        getNextPageParam: (lastPage, allPages) => {
+            if (lastPage.hasMore === false)
+                return undefined;
+            const currentOffset = allPages.length * limit;
+            if (currentOffset >= lastPage.total)
+                return undefined;
+            return currentOffset;
+        },
+        getPreviousPageParam: (_firstPage, allPages) => {
+            if (allPages.length <= 1)
+                return undefined;
+            return (allPages.length - 2) * limit;
+        },
+        staleTime: config.staleTime,
+        gcTime: config.gcTime
+    });
+}
+export function createPageNumberPaginationOptions(config) {
+    return createInfiniteQueryOptions({
+        queryKey: config.queryKey,
+        queryFn: ({ pageParam }) => config.queryFn(pageParam),
+        initialPageParam: 1,
+        getNextPageParam: (lastPage, allPages) => {
+            const nextPage = allPages.length + 1;
+            if (nextPage > lastPage.totalPages)
+                return undefined;
+            return nextPage;
+        },
+        getPreviousPageParam: (_firstPage, allPages) => {
+            if (allPages.length <= 1)
+                return undefined;
+            return allPages.length - 1;
+        },
+        staleTime: config.staleTime,
+        gcTime: config.gcTime
+    });
+}

package/dist/hooks/useMutation.d.ts

@@ -0,0 +1,34 @@
+import type { MutationFunction, MutationKey, QueryClient, QueryKey, UseMutationOptions as TanStackUseMutationOptions, UseMutationResult } from "@tanstack/react-query";
+import type { MutationContext, MutationOptions } from "../types";
+import type { EntityWithId } from "../types/selectors";
+export type { MutationKey };
+export interface MutationDefaultsConfig {
+    [key: string]: TanStackUseMutationOptions<any, any, any, any>;
+}
+export declare function useMutation<TData = unknown, TError = Error, TVariables = void, TContext = unknown>(options: MutationOptions<TData, TError, TVariables, TContext>): UseMutationResult<TData, TError, TVariables, TContext>;
+export declare function setupMutationDefaults(queryClient: QueryClient, config: MutationDefaultsConfig): void;
+export declare function useListMutation<T extends EntityWithId>(mutationFn: MutationFunction<T, {
+    operation: string;
+    data: Partial<T>;
+}>, queryKey: QueryKey, options?: TanStackUseMutationOptions<T, Error, {
+    operation: string;
+    data: Partial<T>;
+}> & {
+    mutationKey?: readonly unknown[];
+}): UseMutationResult<T, Error, {
+    operation: string;
+    data: Partial<T>;
+}, unknown>;
+export declare function useBatchMutation<TData = unknown, TError = Error, TVariables = unknown[]>(mutationFn: MutationFunction<TData[], TVariables>, options?: TanStackUseMutationOptions<TData[], TError, TVariables> & {
+    mutationKey?: readonly unknown[];
+}): UseMutationResult<TData[], TError, TVariables, unknown>;
+export declare function useConditionalOptimisticMutation<TData = unknown, TError = Error, TVariables = void, TContext = unknown>(mutationFn: MutationFunction<TData, TVariables>, condition: (variables: TVariables) => boolean, options?: Omit<MutationOptions<TData, TError, TVariables, TContext>, "mutationFn"> & {
+    mutationKey?: readonly unknown[];
+}): UseMutationResult<TData, TError, TVariables, MutationContext<unknown, TContext>>;
+export declare function cancelQueriesBatch(queryClient: QueryClient, queryKeys: Array<Parameters<QueryClient["cancelQueries"]>[0]>): Promise<void>;
+export declare function setQueryDataBatch(queryClient: QueryClient, updates: Array<{
+    queryKey: Parameters<QueryClient["setQueryData"]>[0];
+    updater: Parameters<QueryClient["setQueryData"]>[1];
+}>): void;
+export declare function invalidateQueriesBatch(queryClient: QueryClient, queryKeys: Array<Parameters<QueryClient["invalidateQueries"]>[0]>): Promise<void>;
+//# sourceMappingURL=useMutation.d.ts.map

package/dist/hooks/useMutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMutation.d.ts","sourceRoot":"","sources":["../../src/hooks/useMutation.ts"],"names":[],"mappings":"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"}