@qiaopeng/tanstack-query-plus 0.5.9 → 0.5.10

package/dist/hooks/useMutation.js

@@ -1,180 +0,0 @@
-import { useQueryClient, useMutation as useTanStackMutation } from "@tanstack/react-query";
-import { DEFAULT_MUTATION_CONFIG } from "../core/config.js";
-function deriveFamilyKey(queryKey) {
-    const arr = Array.isArray(queryKey) ? [...queryKey] : [queryKey];
-    while (arr.length > 1) {
-        const last = arr[arr.length - 1];
-        if (last && typeof last === "object" && !Array.isArray(last)) {
-            arr.pop();
-            continue;
-        }
-        if (typeof last === "string" && (last === "paginated" || last === "filtered" || last === "sorted" || last === "search" || last === "complex")) {
-            arr.pop();
-            continue;
-        }
-        break;
-    }
-    return arr;
-}
-function isListFamilyKey(queryKey) {
-    const parts = Array.isArray(queryKey) ? queryKey : [queryKey];
-    return parts.includes("list") || parts.includes("paginated");
-}
-export function invalidateQueriesBatch(queryClient, tasks) {
-    tasks.forEach(task => queryClient.invalidateQueries(task));
-}
-export function cancelQueriesBatch(queryClient, tasks) {
-    tasks.forEach(task => queryClient.cancelQueries(task));
-}
-export function setQueryDataBatch(queryClient, tasks) {
-    tasks.forEach(task => queryClient.setQueryData(task.queryKey, task.data));
-}
-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 {
-                // Derive family key (e.g., ['products', 'list'] from ['products', 'list', { page: 1, pageSize: 10 }])
-                const familyKey = optimistic.familyKey ?? deriveFamilyKey(optimistic.queryKey);
-                // Cancel all queries in the family to prevent race conditions
-                await queryClient.cancelQueries({ queryKey: familyKey });
-                // Save snapshots of all queries in the family
-                const previousData = queryClient.getQueriesData({ queryKey: familyKey });
-                // Apply field mapping if specified
-                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];
-                        }
-                    });
-                }
-                // ✅ Official approach: Update all cached query variants using setQueriesData
-                queryClient.setQueriesData({ queryKey: familyKey }, (oldData) => {
-                    if (!oldData)
-                        return oldData;
-                    return 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) => {
-            // Rollback all query variants
-            if (context?.previousData) {
-                context.previousData.forEach(([queryKey, data]) => {
-                    queryClient.setQueryData(queryKey, data);
-                });
-            }
-            if (optimistic.rollback && context?.previousData) {
-                try {
-                    // Call rollback with the first snapshot (usually the current query)
-                    const firstSnapshot = context.previousData[0]?.[1];
-                    if (firstSnapshot) {
-                        optimistic.rollback(firstSnapshot, error);
-                    }
-                }
-                catch { }
-            }
-            if (onError) {
-                const errorCallback = onError;
-                errorCallback(error, variables, context?.userContext);
-            }
-        };
-        mutationConfig.onSuccess = (data, variables, context) => {
-            // Determine invalidation scope
-            const scope = optimistic.invalidateScope ?? (isListFamilyKey(optimistic.queryKey) ? "family" : "exact");
-            const invalidations = [];
-            if (scope !== "none") {
-                if (scope === "family") {
-                    const familyKey = optimistic.familyKey ?? deriveFamilyKey(optimistic.queryKey);
-                    invalidations.push({ queryKey: familyKey });
-                }
-                else {
-                    invalidations.push({ queryKey: optimistic.queryKey });
-                }
-            }
-            // Add related keys
-            if (Array.isArray(optimistic.relatedKeys) && optimistic.relatedKeys.length > 0) {
-                optimistic.relatedKeys.forEach((k) => invalidations.push({ queryKey: k }));
-            }
-            if (Array.isArray(optimistic.invalidates) && optimistic.invalidates.length > 0) {
-                optimistic.invalidates.forEach((k) => invalidations.push({ queryKey: k }));
-            }
-            // Execute invalidations (deduplicated)
-            if (invalidations.length > 0) {
-                const seen = new Set();
-                const tasks = invalidations
-                    .map((cfg) => ({ ...cfg, exact: false }))
-                    .filter((cfg) => {
-                    const key = JSON.stringify(cfg.queryKey);
-                    if (seen.has(key))
-                        return false;
-                    seen.add(key);
-                    return true;
-                });
-                tasks.forEach(task => queryClient.invalidateQueries(task));
-            }
-            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: () => {
-            // Invalidate all queries in the family
-            const familyKey = deriveFamilyKey(queryKey);
-            queryClient.invalidateQueries({ queryKey: familyKey, exact: false });
-        },
-        ...options,
-        mutationKey: options?.mutationKey
-    });
-}

package/dist/hooks/usePrefetch.d.ts

@@ -1,54 +0,0 @@
-import type { QueryFunction, QueryKey } from "@tanstack/react-query";
-export interface PrefetchOptions {
-    delay?: number;
-    enabled?: boolean;
-    staleTime?: number;
-    minInterval?: 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 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

@@ -1 +0,0 @@
-{"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;AAMrE,MAAM,WAAW,eAAe;IAAG,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE;AAChH,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;AASjI,wBAAgB,gBAAgB,CAAC,KAAK,GAAG,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,EAAE,OAAO,GAAE,oBAAyB;;;;EAwBtI;AAGD,wBAAgB,gBAAgB,KAGV,KAAK,sBAAsB,QAAQ,WAAW,aAAa,CAAC,KAAK,CAAC,YAAY,eAAe,UAUlH;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,UAO/H;AAED,wBAAgB,gBAAgB;eAUA,KAAK,sBAAsB,QAAQ,WAAW,aAAa,CAAC,KAAK,CAAC,YAAY,eAAe;;;EAa5H;AAaD,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,QAgBvJ;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,QAwBnJ;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,QAkBxJ;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

@@ -1,229 +0,0 @@
-import { useQueryClient } from "@tanstack/react-query";
-import { useCallback, useEffect, useRef, useState } from "react";
-import { DEFAULT_STALE_TIME } from "../core/config.js";
-import { isSlowNetwork } from "../utils/network.js";
-function isMissingOrStale(queryClient, queryKey, staleTime) {
-    const state = queryClient.getQueryState(queryKey);
-    if (!state || state.data === undefined)
-        return true;
-    const updatedAt = state.dataUpdatedAt ?? 0;
-    return Date.now() - updatedAt > staleTime;
-}
-export function useHoverPrefetch(queryKey, queryFn, options = {}) {
-    const queryClient = useQueryClient();
-    const timeoutRef = useRef(undefined);
-    const { hoverDelay = 200, enabled = true, staleTime = DEFAULT_STALE_TIME, minInterval = 1000 } = options;
-    const queryFnRef = useRef(queryFn);
-    useEffect(() => { queryFnRef.current = queryFn; }, [queryFn]);
-    const lastPrefetchRef = useRef(new Map());
-    const prefetch = useCallback(() => {
-        if (!enabled)
-            return;
-        const keyStr = JSON.stringify(queryKey);
-        const last = lastPrefetchRef.current.get(keyStr) ?? 0;
-        if (Date.now() - last < minInterval)
-            return;
-        if (!isMissingOrStale(queryClient, queryKey, staleTime))
-            return;
-        queryClient.prefetchQuery({ queryKey, queryFn: queryFnRef.current, staleTime });
-        lastPrefetchRef.current.set(keyStr, Date.now());
-    }, [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 useRoutePrefetch() {
-    const queryClient = useQueryClient();
-    const lastPrefetchRef = useRef(new Map());
-    return useCallback((queryKey, queryFn, options) => {
-        const { enabled = true, staleTime = DEFAULT_STALE_TIME, minInterval = 1000 } = options || {};
-        if (!enabled)
-            return;
-        const keyStr = JSON.stringify(queryKey);
-        const last = lastPrefetchRef.current.get(keyStr) ?? 0;
-        if (Date.now() - last < minInterval)
-            return;
-        if (!isMissingOrStale(queryClient, queryKey, staleTime))
-            return;
-        queryClient.prefetchQuery({ queryKey, queryFn, staleTime });
-        lastPrefetchRef.current.set(keyStr, Date.now());
-    }, [queryClient]);
-}
-export function useBatchPrefetch() {
-    const queryClient = useQueryClient();
-    return useCallback((queries) => {
-        queries.forEach(({ queryKey, queryFn, staleTime = DEFAULT_STALE_TIME }) => {
-            if (isMissingOrStale(queryClient, queryKey, staleTime)) {
-                queryClient.prefetchQuery({ queryKey, queryFn, staleTime });
-            }
-        });
-    }, [queryClient]);
-}
-export function useSmartPrefetch() {
-    const queryClient = useQueryClient();
-    const prefetchedRef = useRef(new Set());
-    const lastPrefetchRef = useRef(new Map());
-    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, minInterval = 1000 } = options || {};
-        const keyStr = JSON.stringify(queryKey);
-        const last = lastPrefetchRef.current.get(keyStr) ?? 0;
-        if (Date.now() - last < minInterval)
-            return;
-        if (!isMissingOrStale(queryClient, queryKey, staleTime))
-            return;
-        prefetchedRef.current.add(keyStr);
-        queryClient.prefetchQuery({ queryKey, queryFn, staleTime });
-        lastPrefetchRef.current.set(keyStr, Date.now());
-    }, [queryClient, shouldPrefetchQuery]);
-    const clearPrefetchHistory = useCallback(() => { prefetchedRef.current.clear(); }, []);
-    return { prefetch, shouldPrefetch: !isSlowNetwork(), clearPrefetchHistory };
-}
-function useStableQueryKey(queryKey) {
-    const keyRef = useRef(queryKey);
-    const keyStr = JSON.stringify(queryKey);
-    const prevKeyStr = useRef(keyStr);
-    if (prevKeyStr.current !== keyStr) {
-        keyRef.current = queryKey;
-        prevKeyStr.current = keyStr;
-    }
-    return keyRef.current;
-}
-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 = useStableQueryKey(queryKey);
-    useEffect(() => {
-        if (!condition)
-            return;
-        const currentQueryKey = stableQueryKey;
-        const timeoutId = setTimeout(() => {
-            if (isMissingOrStale(queryClient, currentQueryKey, staleTime)) {
-                queryClient.prefetchQuery({ queryKey: currentQueryKey, queryFn: queryFnRef.current, staleTime });
-            }
-        }, delay);
-        return () => clearTimeout(timeoutId);
-    }, [condition, queryClient, staleTime, delay, stableQueryKey]);
-}
-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 = useStableQueryKey(queryKey);
-    useEffect(() => {
-        if (!enabled)
-            return;
-        const currentQueryKey = stableQueryKey;
-        if (typeof window === "undefined" || !("requestIdleCallback" in window)) {
-            const timeoutId = setTimeout(() => {
-                if (isMissingOrStale(queryClient, currentQueryKey, staleTime)) {
-                    queryClient.prefetchQuery({ queryKey: currentQueryKey, queryFn: queryFnRef.current, staleTime });
-                }
-            }, timeout);
-            return () => clearTimeout(timeoutId);
-        }
-        const idleCallbackId = window.requestIdleCallback(() => {
-            if (isMissingOrStale(queryClient, currentQueryKey, staleTime)) {
-                queryClient.prefetchQuery({ queryKey: currentQueryKey, queryFn: queryFnRef.current, staleTime });
-            }
-        }, { timeout });
-        return () => window.cancelIdleCallback(idleCallbackId);
-    }, [queryClient, staleTime, enabled, timeout, stableQueryKey]);
-}
-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 = useStableQueryKey(queryKey);
-    useEffect(() => {
-        if (!enabled)
-            return;
-        const currentQueryKey = stableQueryKey;
-        const prefetchData = () => {
-            if (isMissingOrStale(queryClient, currentQueryKey, staleTime)) {
-                queryClient.prefetchQuery({ queryKey: currentQueryKey, queryFn: queryFnRef.current, staleTime });
-            }
-        };
-        prefetchData();
-        const intervalId = setInterval(prefetchData, interval);
-        return () => clearInterval(intervalId);
-    }, [queryClient, staleTime, enabled, interval, stableQueryKey]);
-}
-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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"useQuery.d.ts","sourceRoot":"","sources":["../../src/hooks/useQuery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACrG,OAAO,EAAE,SAAS,EAAY,MAAM,uBAAuB,CAAC;AAI5D,MAAM,WAAW,oBAAoB,CAAC,YAAY,GAAG,OAAO,EAAE,MAAM,GAAG,YAAY,EAAE,KAAK,GAAG,YAAY,EAAE,SAAS,SAAS,QAAQ,GAAG,QAAQ,CAAE,SAAQ,eAAe,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC;IAC/M,2CAA2C;IAC3C,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,sDAAsD;IACtD,WAAW,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,KAAK,IAAI,CAAC;IAC9D,6DAA6D;IAC7D,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,kCAAkC;IAClC,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,MAAM,mBAAmB,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,YAAY,IAAI,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG;IACxG,mDAAmD;IACnD,YAAY,EAAE,MAAM,CAAC;IACrB,gCAAgC;IAChC,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,YAAY,GAAG,OAAO,EAAE,MAAM,GAAG,YAAY,EAAE,KAAK,GAAG,YAAY,EAAE,SAAS,SAAS,QAAQ,GAAG,QAAQ,EACzI,OAAO,EAAE,oBAAoB,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,GACpE,mBAAmB,CAAC,KAAK,EAAE,MAAM,CAAC,CAoDpC;AAED,OAAO,EAAE,SAAS,EAAE,CAAC"}

package/dist/hooks/useQuery.js

@@ -1,46 +0,0 @@
-import { skipToken, useQuery } from "@tanstack/react-query";
-import { useEffect, useRef } from "react";
-import { isDev } from "../core/env.js";
-export function useEnhancedQuery(options) {
-    const { logErrors = isDev, onSlowQuery, slowQueryThreshold = 3000, trackPerformance = false, ...queryOptions } = options;
-    const startTimeRef = useRef(0);
-    const refetchCountRef = useRef(0);
-    const lastDurationRef = useRef(null);
-    const wasFetchingRef = useRef(false);
-    const result = useQuery(queryOptions);
-    // Performance tracking
-    useEffect(() => {
-        if (trackPerformance || onSlowQuery) {
-            if (result.isFetching && !wasFetchingRef.current) {
-                startTimeRef.current = Date.now();
-            }
-            else if (!result.isFetching && wasFetchingRef.current && startTimeRef.current > 0) {
-                const duration = Date.now() - startTimeRef.current;
-                lastDurationRef.current = duration;
-                if (onSlowQuery && duration > slowQueryThreshold) {
-                    onSlowQuery(duration, queryOptions.queryKey);
-                }
-                startTimeRef.current = 0;
-            }
-            wasFetchingRef.current = result.isFetching;
-        }
-    }, [result.isFetching, onSlowQuery, slowQueryThreshold, trackPerformance, queryOptions.queryKey]);
-    // Error logging
-    useEffect(() => {
-        if (logErrors && result.isError && result.error) {
-            console.error(`[useEnhancedQuery Error] ${JSON.stringify(queryOptions.queryKey)}:`, result.error);
-        }
-    }, [result.isError, result.error, logErrors, queryOptions.queryKey]);
-    // Refetch counting
-    useEffect(() => {
-        if (result.isRefetching) {
-            refetchCountRef.current++;
-        }
-    }, [result.isRefetching]);
-    return {
-        ...result,
-        refetchCount: refetchCountRef.current,
-        lastQueryDuration: lastDurationRef.current
-    };
-}
-export { skipToken };

package/dist/hooks/useSuspenseQuery.d.ts

@@ -1,11 +0,0 @@
-import type { DefaultError, 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 = 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>;
-export 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>;
-export declare function useEnhancedSuspenseQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>): UseSuspenseQueryResult<TData, TError>;
-export 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>;
-export {};
-//# sourceMappingURL=useSuspenseQuery.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"useSuspenseQuery.d.ts","sourceRoot":"","sources":["../../src/hooks/useSuspenseQuery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,oBAAoB,EAAE,QAAQ,EAAE,+BAA+B,EAAE,8BAA8B,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAE3N,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,YAAY,EAAE,KAAK,GAAG,YAAY,EAAE,SAAS,SAAS,QAAQ,GAAG,QAAQ,EAAE,UAAU,GAAG,IAAI,EAC/J,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,YAAY,EAAE,KAAK,GAAG,YAAY,EAAE,SAAS,SAAS,QAAQ,GAAG,QAAQ,EAAE,UAAU,GAAG,OAAO,EAAE,UAAU,GAAG,IAAI,EAC7L,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,YAAY,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,CAEpQ;AACD,wBAAgB,gCAAgC,CAAC,YAAY,GAAG,OAAO,EAAE,MAAM,GAAG,YAAY,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,CAE9T"}

package/dist/hooks/useSuspenseQuery.js

@@ -1,19 +0,0 @@
-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.map

@@ -1 +0,0 @@
-{"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,oBAAoB,EAAE,qBAAqB,EAAE,KAAK,+BAA+B,EAAE,MAAM,iCAAiC,CAAC;AAChK,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,SAAS,EAAE,cAAc,EAAE,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/react-query/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/react-query/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,mBAAmB,EACnB,cAAc,EACd,SAAS,EACT,aAAa,EACb,aAAa,EACb,QAAQ,EACR,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,wBAAwB,EACzB,MAAM,uBAAuB,CAAC;AAE/B,YAAY,EACV,eAAe,EACf,uBAAuB,EACvB,uBAAuB,EACvB,QAAQ,EACR,WAAW,EACX,YAAY,EACZ,cAAc,EACd,sBAAsB,EACtB,iBAAiB,EACjB,YAAY,EACb,MAAM,uBAAuB,CAAC"}

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

@@ -1 +0,0 @@
-{"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

@@ -1,26 +0,0 @@
-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 = {}));