@qiaopeng/tanstack-query-plus 0.1.0

package/dist/hooks/useMutation.js

@@ -0,0 +1,176 @@
+import { useQueryClient, useMutation as useTanStackMutation } from "@tanstack/react-query";
+import { DEFAULT_MUTATION_CONFIG } from "../core/config.js";
+export function useMutation(options) {
+    const queryClient = useQueryClient();
+    const { optimistic, onMutate, onError, onSuccess, onSettled, ...restOptions } = options;
+    const mutationConfig = {
+        ...restOptions,
+        retry: restOptions.retry ?? DEFAULT_MUTATION_CONFIG?.retry,
+        retryDelay: restOptions.retryDelay ?? DEFAULT_MUTATION_CONFIG?.retryDelay,
+        gcTime: restOptions.gcTime ?? DEFAULT_MUTATION_CONFIG?.gcTime
+    };
+    if (!optimistic) {
+        if (onMutate) {
+            mutationConfig.onMutate = onMutate;
+        }
+        if (onError) {
+            mutationConfig.onError = onError;
+        }
+        if (onSuccess) {
+            mutationConfig.onSuccess = onSuccess;
+        }
+        if (onSettled) {
+            mutationConfig.onSettled = onSettled;
+        }
+    }
+    else {
+        mutationConfig.onMutate = async (variables) => {
+            if (optimistic.enabled === false) {
+                const mutateCallback = onMutate;
+                const userContext = onMutate ? await mutateCallback(variables) : undefined;
+                return { userContext };
+            }
+            try {
+                await queryClient.cancelQueries({ queryKey: optimistic.queryKey });
+                const previousData = queryClient.getQueryData(optimistic.queryKey);
+                let mappedVariables = variables;
+                if (optimistic.fieldMapping && typeof variables === "object" && variables !== null) {
+                    mappedVariables = { ...variables };
+                    const sourceObj = variables;
+                    const targetObj = mappedVariables;
+                    Object.entries(optimistic.fieldMapping).forEach(([sourceField, targetField]) => {
+                        if (sourceField in sourceObj) {
+                            targetObj[targetField] = sourceObj[sourceField];
+                        }
+                    });
+                }
+                queryClient.setQueryData(optimistic.queryKey, (oldData) => optimistic.updater(oldData, mappedVariables));
+                const mutateCallback = onMutate;
+                const userContext = onMutate ? await mutateCallback(variables) : undefined;
+                return { previousData, userContext };
+            }
+            catch (error) {
+                return { userContext: undefined };
+            }
+        };
+        mutationConfig.onError = (error, variables, context) => {
+            if (context?.previousData !== undefined) {
+                queryClient.setQueryData(optimistic.queryKey, context.previousData);
+            }
+            if (optimistic.rollback && context?.previousData !== undefined) {
+                try {
+                    optimistic.rollback(context.previousData, error);
+                }
+                catch { }
+            }
+            if (onError) {
+                const errorCallback = onError;
+                errorCallback(error, variables, context?.userContext);
+            }
+        };
+        mutationConfig.onSuccess = (data, variables, context) => {
+            queryClient.invalidateQueries({ queryKey: optimistic.queryKey });
+            if (onSuccess) {
+                const successCallback = onSuccess;
+                successCallback(data, variables, context?.userContext);
+            }
+        };
+        mutationConfig.onSettled = (data, error, variables, context) => {
+            if (onSettled) {
+                const settledCallback = onSettled;
+                settledCallback(data, error, variables, context?.userContext);
+            }
+        };
+    }
+    return useTanStackMutation(mutationConfig);
+}
+export function setupMutationDefaults(queryClient, config) {
+    Object.entries(config).forEach(([key, options]) => { queryClient.setMutationDefaults([key], options); });
+}
+export function useListMutation(mutationFn, queryKey, options) {
+    const queryClient = useQueryClient();
+    return useTanStackMutation({ mutationFn, onSettled: () => { queryClient.invalidateQueries({ queryKey }); }, ...options, mutationKey: options?.mutationKey });
+}
+export function useBatchMutation(mutationFn, options) {
+    return useTanStackMutation({ mutationFn, ...options, mutationKey: options?.mutationKey });
+}
+export function useConditionalOptimisticMutation(mutationFn, condition, options) {
+    const queryClient = useQueryClient();
+    const { mutationKey, optimistic, onMutate, onError, onSettled, onSuccess } = options || {};
+    const mutationConfig = { mutationKey, mutationFn };
+    if (optimistic) {
+        mutationConfig.onMutate = async (variables) => {
+            const conditionMet = condition(variables);
+            if (!conditionMet || optimistic.enabled === false) {
+                const mutateCallback = onMutate;
+                const userContext = onMutate ? await mutateCallback(variables) : undefined;
+                return { userContext, conditionMet: false };
+            }
+            try {
+                await queryClient.cancelQueries({ queryKey: optimistic.queryKey });
+                const previousData = queryClient.getQueryData(optimistic.queryKey);
+                queryClient.setQueryData(optimistic.queryKey, (oldData) => optimistic.updater(oldData, variables));
+                const mutateCallback = onMutate;
+                const userContext = onMutate ? await mutateCallback(variables) : undefined;
+                return { previousData, userContext, conditionMet: true };
+            }
+            catch {
+                return { userContext: undefined, conditionMet: false };
+            }
+        };
+        mutationConfig.onError = (error, variables, context) => {
+            if (context?.conditionMet && context?.previousData !== undefined) {
+                queryClient.setQueryData(optimistic.queryKey, context.previousData);
+                if (optimistic.rollback) {
+                    try {
+                        optimistic.rollback(context.previousData, error);
+                    }
+                    catch { }
+                }
+            }
+            if (onError) {
+                const errorCallback = onError;
+                errorCallback(error, variables, context?.userContext);
+            }
+        };
+        mutationConfig.onSuccess = (data, variables, context) => {
+            if (onSuccess) {
+                const successCallback = onSuccess;
+                successCallback(data, variables, context?.userContext);
+            }
+        };
+        mutationConfig.onSettled = (data, error, variables, context) => {
+            if (context?.conditionMet) {
+                queryClient.invalidateQueries({ queryKey: optimistic.queryKey });
+            }
+            if (onSettled) {
+                const settledCallback = onSettled;
+                settledCallback(data, error, variables, context?.userContext);
+            }
+        };
+    }
+    else {
+        if (onMutate) {
+            mutationConfig.onMutate = async (variables) => { const mutateCallback = onMutate; const userContext = await mutateCallback(variables); return { userContext, conditionMet: false }; };
+        }
+        if (onError) {
+            mutationConfig.onError = (error, variables, context) => { const errorCallback = onError; errorCallback(error, variables, context?.userContext); };
+        }
+        if (onSuccess) {
+            mutationConfig.onSuccess = (data, variables, context) => { const successCallback = onSuccess; successCallback(data, variables, context?.userContext); };
+        }
+        if (onSettled) {
+            mutationConfig.onSettled = (data, error, variables, context) => { const settledCallback = onSettled; settledCallback(data, error, variables, context?.userContext); };
+        }
+    }
+    return useTanStackMutation(mutationConfig);
+}
+export async function cancelQueriesBatch(queryClient, queryKeys) {
+    await Promise.all(queryKeys.map((queryKey) => queryClient.cancelQueries(queryKey)));
+}
+export function setQueryDataBatch(queryClient, updates) {
+    updates.forEach(({ queryKey, updater }) => { queryClient.setQueryData(queryKey, updater); });
+}
+export async function invalidateQueriesBatch(queryClient, queryKeys) {
+    await Promise.all(queryKeys.map((queryKey) => queryClient.invalidateQueries(queryKey)));
+}

package/dist/hooks/usePrefetch.d.ts

@@ -0,0 +1,54 @@
+import type { QueryFunction, QueryKey } from "@tanstack/react-query";
+export interface PrefetchOptions {
+    delay?: number;
+    enabled?: boolean;
+    staleTime?: number;
+}
+export interface HoverPrefetchOptions extends PrefetchOptions {
+    hoverDelay?: number;
+}
+export interface InViewPrefetchOptions extends PrefetchOptions {
+    threshold?: number;
+    rootMargin?: string;
+    triggerOnce?: boolean;
+}
+export declare function useHoverPrefetch<TData = unknown>(queryKey: QueryKey, queryFn: QueryFunction<TData>, options?: HoverPrefetchOptions): {
+    onMouseEnter: () => void;
+    onMouseLeave: () => void;
+    onFocus: () => void;
+};
+export declare function useInViewPrefetch<TData = unknown>(queryKey: QueryKey, queryFn: QueryFunction<TData>, options?: InViewPrefetchOptions): (node?: Element | null) => void;
+export declare function useRoutePrefetch(): <TData = unknown>(queryKey: QueryKey, queryFn: QueryFunction<TData>, options?: PrefetchOptions) => void;
+export declare function useBatchPrefetch(): <TData = unknown>(queries: Array<{
+    queryKey: QueryKey;
+    queryFn: QueryFunction<TData>;
+    staleTime?: number;
+}>) => void;
+export declare function useSmartPrefetch(): {
+    prefetch: <TData = unknown>(queryKey: QueryKey, queryFn: QueryFunction<TData>, options?: PrefetchOptions) => void;
+    shouldPrefetch: boolean;
+    clearPrefetchHistory: () => void;
+};
+export declare function useConditionalPrefetch<TData = unknown>(queryKey: QueryKey, queryFn: QueryFunction<TData>, condition: boolean, options?: PrefetchOptions): void;
+export declare function useIdlePrefetch<TData = unknown>(queryKey: QueryKey, queryFn: QueryFunction<TData>, options?: PrefetchOptions & {
+    timeout?: number;
+}): void;
+export declare function usePeriodicPrefetch<TData = unknown>(queryKey: QueryKey, queryFn: QueryFunction<TData>, options?: PrefetchOptions & {
+    interval?: number;
+}): void;
+export 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;
+};
+export declare function usePriorityPrefetch(): {
+    addPrefetchTask: <TData = unknown>(queryKey: QueryKey, queryFn: QueryFunction<TData>, priority?: "high" | "medium" | "low") => void;
+    processTasks: () => Promise<void>;
+    clearTasks: () => void;
+    taskCount: number;
+};
+//# sourceMappingURL=usePrefetch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"usePrefetch.d.ts","sourceRoot":"","sources":["../../src/hooks/usePrefetch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAOrE,MAAM,WAAW,eAAe;IAAG,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE;AAC1F,MAAM,WAAW,oBAAqB,SAAQ,eAAe;IAAG,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE;AACrF,MAAM,WAAW,qBAAsB,SAAQ,eAAe;IAAG,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,OAAO,CAAA;CAAE;AAEjI,wBAAgB,gBAAgB,CAAC,KAAK,GAAG,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,EAAE,OAAO,GAAE,oBAAyB;;;;EAkBtI;AAED,wBAAgB,iBAAiB,CAAC,KAAK,GAAG,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,EAAE,OAAO,GAAE,qBAA0B,mCAcxI;AAED,wBAAgB,gBAAgB,KAEV,KAAK,sBAAsB,QAAQ,WAAW,aAAa,CAAC,KAAK,CAAC,YAAY,eAAe,UAKlH;AAED,wBAAgB,gBAAgB,KAEV,KAAK,qBAAqB,KAAK,CAAC;IAAE,QAAQ,EAAE,QAAQ,CAAC;IAAC,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,UAK/H;AAED,wBAAgB,gBAAgB;eASA,KAAK,sBAAsB,QAAQ,WAAW,aAAa,CAAC,KAAK,CAAC,YAAY,eAAe;;;EAS5H;AAED,wBAAgB,sBAAsB,CAAC,KAAK,GAAG,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,eAAe,QAcvJ;AAED,wBAAgB,eAAe,CAAC,KAAK,GAAG,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,QAoBnJ;AAED,wBAAgB,mBAAmB,CAAC,KAAK,GAAG,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,QAgBxJ;AAED,wBAAgB,qBAAqB;gCAIY,MAAM,UAAU,MAAM;;wBAa9B,KAAK,4BAA4B,CAAC,MAAM,EAAE,MAAM,KAAK;QAAE,QAAQ,EAAE,QAAQ,CAAC;QAAC,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,CAAA;KAAE;;EASlJ;AAED,wBAAgB,mBAAmB;sBAII,KAAK,sBAAsB,QAAQ,WAAW,aAAa,CAAC,KAAK,CAAC,aAAY,MAAM,GAAG,QAAQ,GAAG,KAAK;;;;EAmB7I"}

package/dist/hooks/usePrefetch.js

@@ -0,0 +1,203 @@
+import { useQueryClient } from "@tanstack/react-query";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useInView } from "react-intersection-observer";
+import { DEFAULT_STALE_TIME } from "../core/config.js";
+import { isSlowNetwork } from "../utils/network.js";
+export function useHoverPrefetch(queryKey, queryFn, options = {}) {
+    const queryClient = useQueryClient();
+    const timeoutRef = useRef(undefined);
+    const { hoverDelay = 200, enabled = true, staleTime = DEFAULT_STALE_TIME } = options;
+    const queryFnRef = useRef(queryFn);
+    useEffect(() => { queryFnRef.current = queryFn; }, [queryFn]);
+    const prefetch = useCallback(() => {
+        if (!enabled)
+            return;
+        queryClient.prefetchQuery({ queryKey, queryFn: queryFnRef.current, staleTime });
+    }, [queryClient, queryKey, enabled, staleTime]);
+    const handleMouseEnter = useCallback(() => {
+        if (!enabled)
+            return;
+        if (timeoutRef.current) {
+            clearTimeout(timeoutRef.current);
+        }
+        timeoutRef.current = setTimeout(prefetch, hoverDelay);
+    }, [prefetch, hoverDelay, enabled]);
+    const handleMouseLeave = useCallback(() => { if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+    } }, []);
+    useEffect(() => () => { if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+    } }, []);
+    return { onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onFocus: prefetch };
+}
+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;
+}
+export function useRoutePrefetch() {
+    const queryClient = useQueryClient();
+    return useCallback((queryKey, queryFn, options) => {
+        const { enabled = true, staleTime = DEFAULT_STALE_TIME } = options || {};
+        if (!enabled)
+            return;
+        queryClient.prefetchQuery({ queryKey, queryFn, staleTime });
+    }, [queryClient]);
+}
+export function useBatchPrefetch() {
+    const queryClient = useQueryClient();
+    return useCallback((queries) => {
+        queries.forEach(({ queryKey, queryFn, staleTime = DEFAULT_STALE_TIME }) => {
+            queryClient.prefetchQuery({ queryKey, queryFn, staleTime });
+        });
+    }, [queryClient]);
+}
+export function useSmartPrefetch() {
+    const queryClient = useQueryClient();
+    const prefetchedRef = useRef(new Set());
+    const shouldPrefetchQuery = useCallback((queryKey) => {
+        const key = JSON.stringify(queryKey);
+        if (prefetchedRef.current.has(key))
+            return false;
+        if (isSlowNetwork())
+            return false;
+        return true;
+    }, []);
+    const prefetch = useCallback((queryKey, queryFn, options) => {
+        if (!shouldPrefetchQuery(queryKey))
+            return;
+        const { staleTime = DEFAULT_STALE_TIME } = options || {};
+        const key = JSON.stringify(queryKey);
+        prefetchedRef.current.add(key);
+        queryClient.prefetchQuery({ queryKey, queryFn, staleTime });
+    }, [queryClient, shouldPrefetchQuery]);
+    const clearPrefetchHistory = useCallback(() => { prefetchedRef.current.clear(); }, []);
+    return { prefetch, shouldPrefetch: !isSlowNetwork(), clearPrefetchHistory };
+}
+export function useConditionalPrefetch(queryKey, queryFn, condition, options) {
+    const queryClient = useQueryClient();
+    const { staleTime = DEFAULT_STALE_TIME, delay = 0 } = options || {};
+    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 (!condition)
+            return;
+        const timeoutId = setTimeout(() => {
+            queryClient.prefetchQuery({ queryKey: stableQueryKey.current, queryFn: queryFnRef.current, staleTime });
+        }, delay);
+        return () => clearTimeout(timeoutId);
+    }, [condition, queryClient, staleTime, delay]);
+}
+export function useIdlePrefetch(queryKey, queryFn, options) {
+    const queryClient = useQueryClient();
+    const { staleTime = DEFAULT_STALE_TIME, enabled = true, timeout = 1000 } = options || {};
+    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 (!enabled)
+            return;
+        if (typeof window === "undefined" || !("requestIdleCallback" in window)) {
+            const timeoutId = setTimeout(() => {
+                queryClient.prefetchQuery({ queryKey: stableQueryKey.current, queryFn: queryFnRef.current, staleTime });
+            }, timeout);
+            return () => clearTimeout(timeoutId);
+        }
+        const idleCallbackId = window.requestIdleCallback(() => {
+            queryClient.prefetchQuery({ queryKey: stableQueryKey.current, queryFn: queryFnRef.current, staleTime });
+        }, { timeout });
+        return () => window.cancelIdleCallback(idleCallbackId);
+    }, [queryClient, staleTime, enabled, timeout]);
+}
+export function usePeriodicPrefetch(queryKey, queryFn, options) {
+    const queryClient = useQueryClient();
+    const { staleTime = DEFAULT_STALE_TIME, enabled = true, interval = 60000 } = options || {};
+    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 (!enabled)
+            return;
+        const prefetchData = () => {
+            queryClient.prefetchQuery({ queryKey: stableQueryKey.current, queryFn: queryFnRef.current, staleTime });
+        };
+        prefetchData();
+        const intervalId = setInterval(prefetchData, interval);
+        return () => clearInterval(intervalId);
+    }, [queryClient, staleTime, enabled, interval]);
+}
+export function usePredictivePrefetch() {
+    const queryClient = useQueryClient();
+    const interactionHistoryRef = useRef([]);
+    const maxHistorySize = 50;
+    const recordInteraction = useCallback((action, target) => {
+        interactionHistoryRef.current.push({ action, target, timestamp: Date.now() });
+        if (interactionHistoryRef.current.length > maxHistorySize) {
+            interactionHistoryRef.current.shift();
+        }
+    }, []);
+    const getPredictions = useCallback(() => {
+        const history = interactionHistoryRef.current;
+        if (history.length < 3)
+            return [];
+        const targetCounts = new Map();
+        history.forEach(({ target }) => { targetCounts.set(target, (targetCounts.get(target) || 0) + 1); });
+        return Array.from(targetCounts.entries()).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([target]) => target);
+    }, []);
+    const prefetchPredicted = useCallback((getQueryConfig) => {
+        const predictions = getPredictions();
+        predictions.forEach((target) => {
+            const { queryKey, queryFn } = getQueryConfig(target);
+            queryClient.prefetchQuery({ queryKey, queryFn });
+        });
+    }, [queryClient, getPredictions]);
+    const clearHistory = useCallback(() => { interactionHistoryRef.current = []; }, []);
+    return { recordInteraction, getPredictions, prefetchPredicted, clearHistory };
+}
+export function usePriorityPrefetch() {
+    const queryClient = useQueryClient();
+    const tasksRef = useRef([]);
+    const [taskCount, setTaskCount] = useState(0);
+    const addPrefetchTask = useCallback((queryKey, queryFn, priority = "medium") => {
+        tasksRef.current.push({ queryKey, queryFn, priority, timestamp: Date.now() });
+        setTaskCount(tasksRef.current.length);
+    }, []);
+    const processTasks = useCallback(async () => {
+        const priorityOrder = { high: 0, medium: 1, low: 2 };
+        const sortedTasks = [...tasksRef.current].sort((a, b) => {
+            const priorityDiff = priorityOrder[a.priority] - priorityOrder[b.priority];
+            if (priorityDiff !== 0)
+                return priorityDiff;
+            return a.timestamp - b.timestamp;
+        });
+        for (const task of sortedTasks) {
+            await queryClient.prefetchQuery({ queryKey: task.queryKey, queryFn: task.queryFn });
+        }
+        tasksRef.current = [];
+        setTaskCount(0);
+    }, [queryClient]);
+    const clearTasks = useCallback(() => { tasksRef.current = []; setTaskCount(0); }, []);
+    return { addPrefetchTask, processTasks, clearTasks, taskCount };
+}

package/dist/hooks/useQuery.d.ts

@@ -0,0 +1,5 @@
+import type { QueryKey, UseQueryOptions, UseQueryResult } from "@tanstack/react-query";
+import { skipToken } from "@tanstack/react-query";
+export declare function useEnhancedQuery<TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>): UseQueryResult<TData, TError>;
+export { skipToken };
+//# sourceMappingURL=useQuery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useQuery.d.ts","sourceRoot":"","sources":["../../src/hooks/useQuery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvF,OAAO,EAAE,SAAS,EAAY,MAAM,uBAAuB,CAAC;AAC5D,wBAAgB,gBAAgB,CAAC,YAAY,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK,EAAE,KAAK,GAAG,YAAY,EAAE,SAAS,SAAS,QAAQ,GAAG,QAAQ,EAAE,OAAO,EAAE,eAAe,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,GAAG,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,CAErO;AACD,OAAO,EAAE,SAAS,EAAE,CAAC"}

package/dist/hooks/useQuery.js

@@ -0,0 +1,5 @@
+import { skipToken, useQuery } from "@tanstack/react-query";
+export function useEnhancedQuery(options) {
+    return useQuery(options);
+}
+export { skipToken };

package/dist/hooks/useSuspenseQuery.d.ts

@@ -0,0 +1,11 @@
+import type { QueryFunction, QueryFunctionContext, QueryKey, UseSuspenseInfiniteQueryOptions, UseSuspenseInfiniteQueryResult, UseSuspenseQueryOptions, UseSuspenseQueryResult } from "@tanstack/react-query";
+type InfiniteQueryFunction<TQueryFnData = unknown, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = (context: QueryFunctionContext<TQueryKey, TPageParam>) => Promise<TQueryFnData>;
+export declare function createSuspenseQuery<TQueryFnData = unknown, TError = Error, 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>;
+export declare function createSuspenseInfiniteQuery<TQueryFnData = unknown, TError = Error, 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>;
+export declare function useEnhancedSuspenseQuery<TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>): UseSuspenseQueryResult<TData, TError>;
+export declare function useEnhancedSuspenseInfiniteQuery<TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UseSuspenseInfiniteQueryResult<TData, TError>;
+export {};
+//# sourceMappingURL=useSuspenseQuery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useSuspenseQuery.d.ts","sourceRoot":"","sources":["../../src/hooks/useSuspenseQuery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,QAAQ,EAAE,+BAA+B,EAAE,8BAA8B,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAE7M,KAAK,qBAAqB,CAAC,YAAY,GAAG,OAAO,EAAE,SAAS,SAAS,QAAQ,GAAG,QAAQ,EAAE,UAAU,GAAG,OAAO,IAAI,CAAC,OAAO,EAAE,oBAAoB,CAAC,SAAS,EAAE,UAAU,CAAC,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;AAClM,wBAAgB,mBAAmB,CAAC,YAAY,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK,EAAE,KAAK,GAAG,YAAY,EAAE,SAAS,SAAS,QAAQ,GAAG,QAAQ,EAAE,UAAU,GAAG,IAAI,EACxJ,WAAW,EAAE,CAAC,SAAS,EAAE,UAAU,KAAK,SAAS,EACjD,OAAO,EAAE,aAAa,CAAC,YAAY,EAAE,SAAS,CAAC,EAC/C,OAAO,CAAC,EAAE,IAAI,CAAC,uBAAuB,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC,IAE/F,WAAW,UAAU,KAAG,sBAAsB,CAAC,KAAK,EAAE,MAAM,CAAC,CAItE;AACD,wBAAgB,2BAA2B,CAAC,YAAY,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK,EAAE,KAAK,GAAG,YAAY,EAAE,SAAS,SAAS,QAAQ,GAAG,QAAQ,EAAE,UAAU,GAAG,OAAO,EAAE,UAAU,GAAG,IAAI,EACtL,WAAW,EAAE,CAAC,SAAS,EAAE,UAAU,KAAK,SAAS,EACjD,OAAO,EAAE,qBAAqB,CAAC,YAAY,EAAE,SAAS,EAAE,UAAU,CAAC,EACnE,OAAO,EAAE,IAAI,CAAC,+BAA+B,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,UAAU,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC,GAAG;IAC3H,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;IAC9J,gBAAgB,EAAE,UAAU,CAAC;CAC9B,IAEO,WAAW,UAAU,KAAG,8BAA8B,CAAC,KAAK,EAAE,MAAM,CAAC,CAI9E;AACD,wBAAgB,wBAAwB,CAAC,YAAY,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK,EAAE,KAAK,GAAG,YAAY,EAAE,SAAS,SAAS,QAAQ,GAAG,QAAQ,EAAE,OAAO,EAAE,uBAAuB,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,GAAG,sBAAsB,CAAC,KAAK,EAAE,MAAM,CAAC,CAE7P;AACD,wBAAgB,gCAAgC,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,+BAA+B,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,UAAU,CAAC,GAAG,8BAA8B,CAAC,KAAK,EAAE,MAAM,CAAC,CAEvT"}

package/dist/hooks/useSuspenseQuery.js

@@ -0,0 +1,19 @@
+import { useSuspenseInfiniteQuery, useSuspenseQuery } from "@tanstack/react-query";
+export function createSuspenseQuery(getQueryKey, queryFn, options) {
+    return (variables) => {
+        const queryKey = getQueryKey(variables);
+        return useSuspenseQuery({ queryKey, queryFn, ...options });
+    };
+}
+export function createSuspenseInfiniteQuery(getQueryKey, queryFn, options) {
+    return (variables) => {
+        const queryKey = getQueryKey(variables);
+        return useSuspenseInfiniteQuery({ queryKey, queryFn, ...options });
+    };
+}
+export function useEnhancedSuspenseQuery(options) {
+    return useSuspenseQuery(options);
+}
+export function useEnhancedSuspenseInfiniteQuery(options) {
+    return useSuspenseInfiniteQuery(options);
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./components/index.js";
+export * from "./core/index.js";
+export * from "./hooks/index.js";
+export { PersistQueryClientProvider, type PersistQueryClientProviderProps } from "./PersistQueryClientProvider.js";
+export * from "./types/index.js";
+export * from "./utils/index.js";
+export { QueryClient, QueryClientProvider, skipToken, useQueryClient } from "@tanstack/react-query";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,OAAO,EAAE,0BAA0B,EAAE,KAAK,+BAA+B,EAAE,MAAM,iCAAiC,CAAC;AACnH,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+export * from "./components/index.js";
+export * from "./core/index.js";
+export * from "./hooks/index.js";
+export { PersistQueryClientProvider } from "./PersistQueryClientProvider.js";
+export * from "./types/index.js";
+export * from "./utils/index.js";
+export { QueryClient, QueryClientProvider, skipToken, useQueryClient } from "@tanstack/react-query";

package/dist/types/base.d.ts

@@ -0,0 +1,54 @@
+import type { QueryClient } from "@tanstack/react-query";
+import type { PersistedClient, Persister } from "@tanstack/react-query-persist-client";
+export declare enum StorageType {
+    LOCAL = "localStorage",
+    SESSION = "sessionStorage",
+    INDEXED_DB = "indexedDB",
+    CUSTOM = "custom"
+}
+export declare enum ConnectionQuality {
+    SLOW = "slow",
+    FAST = "fast",
+    UNKNOWN = "unknown"
+}
+export declare enum CachePriority {
+    HIGH = "high",
+    MEDIUM = "medium",
+    LOW = "low"
+}
+export declare enum PersistenceStrategyType {
+    AGGRESSIVE = "aggressive",
+    CONSERVATIVE = "conservative",
+    SELECTIVE = "selective",
+    CUSTOM = "custom"
+}
+export interface OperationResult<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: Error;
+    duration?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface NetworkInformation {
+    effectiveType?: "4g" | "3g" | "2g" | "slow-2g";
+    saveData?: boolean;
+    downlink?: number;
+    rtt?: number;
+}
+export interface NetworkStatus {
+    isOnline: boolean;
+    isOffline: boolean;
+    connectionQuality: ConnectionQuality;
+    connection?: NetworkInformation;
+    lastOnlineAt?: Date;
+    lastOfflineAt?: Date;
+}
+export type DeepReadonly<T> = {
+    readonly [P in keyof T]: T[P] extends object ? DeepReadonly<T[P]> : T[P];
+};
+export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type Required<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+export type { PersistedClient, Persister, QueryClient };
+//# sourceMappingURL=base.d.ts.map

package/dist/types/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/types/base.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AACvF,oBAAY,WAAW;IAAG,KAAK,iBAAiB;IAAE,OAAO,mBAAmB;IAAE,UAAU,cAAc;IAAE,MAAM,WAAW;CAAE;AAC3H,oBAAY,iBAAiB;IAAG,IAAI,SAAS;IAAE,IAAI,SAAS;IAAE,OAAO,YAAY;CAAE;AACnF,oBAAY,aAAa;IAAG,IAAI,SAAS;IAAE,MAAM,WAAW;IAAE,GAAG,QAAQ;CAAE;AAC3E,oBAAY,uBAAuB;IAAG,UAAU,eAAe;IAAE,YAAY,iBAAiB;IAAE,SAAS,cAAc;IAAE,MAAM,WAAW;CAAE;AAC5I,MAAM,WAAW,eAAe,CAAC,CAAC,GAAG,OAAO;IAAI,OAAO,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAAC,KAAK,CAAC,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE;AAClJ,MAAM,WAAW,kBAAkB;IAAG,aAAa,CAAC,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,SAAS,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE;AAC3I,MAAM,WAAW,aAAa;IAAG,QAAQ,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,iBAAiB,EAAE,iBAAiB,CAAC;IAAC,UAAU,CAAC,EAAE,kBAAkB,CAAC;IAAC,YAAY,CAAC,EAAE,IAAI,CAAC;IAAC,aAAa,CAAC,EAAE,IAAI,CAAA;CAAE;AAC1L,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI;IAAE,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC;AAC3G,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAC9E,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI,CAAC,GAAG;KAAG,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC;AACtE,YAAY,EAAE,eAAe,EAAE,SAAS,EAAE,WAAW,EAAE,CAAC"}

package/dist/types/base.js

@@ -0,0 +1,26 @@
+export var StorageType;
+(function (StorageType) {
+    StorageType["LOCAL"] = "localStorage";
+    StorageType["SESSION"] = "sessionStorage";
+    StorageType["INDEXED_DB"] = "indexedDB";
+    StorageType["CUSTOM"] = "custom";
+})(StorageType || (StorageType = {}));
+export var ConnectionQuality;
+(function (ConnectionQuality) {
+    ConnectionQuality["SLOW"] = "slow";
+    ConnectionQuality["FAST"] = "fast";
+    ConnectionQuality["UNKNOWN"] = "unknown";
+})(ConnectionQuality || (ConnectionQuality = {}));
+export var CachePriority;
+(function (CachePriority) {
+    CachePriority["HIGH"] = "high";
+    CachePriority["MEDIUM"] = "medium";
+    CachePriority["LOW"] = "low";
+})(CachePriority || (CachePriority = {}));
+export var PersistenceStrategyType;
+(function (PersistenceStrategyType) {
+    PersistenceStrategyType["AGGRESSIVE"] = "aggressive";
+    PersistenceStrategyType["CONSERVATIVE"] = "conservative";
+    PersistenceStrategyType["SELECTIVE"] = "selective";
+    PersistenceStrategyType["CUSTOM"] = "custom";
+})(PersistenceStrategyType || (PersistenceStrategyType = {}));

package/dist/types/index.d.ts

@@ -0,0 +1,23 @@
+import type { QueryKey, UseMutationOptions } from "@tanstack/react-query";
+export * from "./base.js";
+export * from "./infinite.js";
+export * from "./offline.js";
+export * from "./optimistic.js";
+export * from "./persistence.js";
+export * from "./selectors.js";
+export * from "./suspense.js";
+export interface MutationContext<TData = unknown, TContext = unknown> {
+    previousData?: TData;
+    userContext?: TContext;
+    conditionMet?: boolean;
+}
+export interface MutationOptions<TData, TError, TVariables, TContext = unknown> extends UseMutationOptions<TData, TError, TVariables, TContext> {
+    optimistic?: {
+        queryKey: QueryKey;
+        updater: <TQueryData = unknown>(oldData: TQueryData | undefined, variables: TVariables) => TQueryData | undefined;
+        enabled?: boolean;
+        fieldMapping?: Record<string, string>;
+        rollback?: <TQueryData = unknown>(previousData: TQueryData, error: Error) => void;
+    };
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC1E,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,MAAM,WAAW,eAAe,CAAC,KAAK,GAAG,OAAO,EAAE,QAAQ,GAAG,OAAO;IAAI,YAAY,CAAC,EAAE,KAAK,CAAC;IAAC,WAAW,CAAC,EAAE,QAAQ,CAAC;IAAC,YAAY,CAAC,EAAE,OAAO,CAAA;CAAE;AAC9I,MAAM,WAAW,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,GAAG,OAAO,CAAE,SAAQ,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,CAAC;IAC7I,UAAU,CAAC,EAAE;QAAE,QAAQ,EAAE,QAAQ,CAAC;QAAC,OAAO,EAAE,CAAC,UAAU,GAAG,OAAO,EAAE,OAAO,EAAE,UAAU,GAAG,SAAS,EAAE,SAAS,EAAE,UAAU,KAAK,UAAU,GAAG,SAAS,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAAC,QAAQ,CAAC,EAAE,CAAC,UAAU,GAAG,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;KAAE,CAAC;CACrS"}

package/dist/types/index.js

@@ -0,0 +1,7 @@
+export * from "./base.js";
+export * from "./infinite.js";
+export * from "./offline.js";
+export * from "./optimistic.js";
+export * from "./persistence.js";
+export * from "./selectors.js";
+export * from "./suspense.js";