@qiaopeng/tanstack-query-plus 0.5.8 → 0.5.10

package/dist/features/persistence.js

@@ -1,186 +0,0 @@
-function isSerializable(data) {
-    try {
-        JSON.stringify(data);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function handleStorageQuotaError(error, key) {
-    if (error instanceof Error && error.name === "QuotaExceededError") {
-        try {
-            window.localStorage.removeItem(key);
-        }
-        catch { }
-    }
-}
-function createSafeStorage(storage, key) {
-    return {
-        getItem: (storageKey) => { try {
-            return storage.getItem(storageKey);
-        }
-        catch {
-            return null;
-        } },
-        setItem: (storageKey, value) => { try {
-            storage.setItem(storageKey, value);
-        }
-        catch (error) {
-            handleStorageQuotaError(error, key);
-        } },
-        removeItem: (storageKey) => { try {
-            storage.removeItem(storageKey);
-        }
-        catch { } },
-        clear: () => { try {
-            storage.clear();
-        }
-        catch { } },
-        key: (index) => { try {
-            return storage.key(index);
-        }
-        catch {
-            return null;
-        } },
-        get length() {
-            try {
-                return storage.length;
-            }
-            catch {
-                return 0;
-            }
-        }
-    };
-}
-export function createPersistOptions(config = {}) {
-    const { maxAge = 1000 * 60 * 60 * 24, onlyPersistSuccess = true, dehydrateOptions } = config;
-    return {
-        maxAge,
-        dehydrateOptions: {
-            ...dehydrateOptions,
-            shouldDehydrateQuery: dehydrateOptions?.shouldDehydrateQuery ||
-                (onlyPersistSuccess
-                    ? (query) => {
-                        if (query.state.status !== "success")
-                            return false;
-                        if (!isSerializable(query.state.data))
-                            return false;
-                        return true;
-                    }
-                    : undefined)
-        }
-    };
-}
-export function createPersister(storageKey = "tanstack-query-cache", storage, onError) {
-    if (typeof window === "undefined") {
-        return undefined;
-    }
-    const targetStorage = storage || window.localStorage;
-    if (!targetStorage) {
-        return undefined;
-    }
-    try {
-        const safeStorage = createSafeStorage(targetStorage, storageKey);
-        const persister = {
-            persistClient: async (client) => { try {
-                safeStorage.setItem(storageKey, JSON.stringify(client));
-            }
-            catch (e) {
-                if (onError && e instanceof Error) {
-                    onError(e);
-                }
-            } },
-            restoreClient: async () => { try {
-                const raw = safeStorage.getItem(storageKey);
-                return raw ? JSON.parse(raw) : undefined;
-            }
-            catch (e) {
-                if (onError && e instanceof Error) {
-                    onError(e);
-                }
-                return undefined;
-            } },
-            removeClient: async () => { try {
-                safeStorage.removeItem(storageKey);
-            }
-            catch (e) {
-                if (onError && e instanceof Error) {
-                    onError(e);
-                }
-            } }
-        };
-        return persister;
-    }
-    catch {
-        return undefined;
-    }
-}
-export function clearCache(key = "tanstack-query-cache") { try {
-    window.localStorage.removeItem(key);
-}
-catch { } }
-export function clearExpiredCache(key = "tanstack-query-cache", maxAge = 1000 * 60 * 60 * 24) {
-    try {
-        const stored = window.localStorage.getItem(key);
-        if (!stored)
-            return;
-        const parsed = JSON.parse(stored);
-        const now = Date.now();
-        if (parsed.timestamp && now - parsed.timestamp > maxAge) {
-            window.localStorage.removeItem(key);
-        }
-    }
-    catch { }
-}
-export async function migrateToIndexedDB(localStorageKey = "tanstack-query-cache", indexedDBKey = "tanstack-query-cache", indexedDBStorage) {
-    try {
-        const localData = window.localStorage.getItem(localStorageKey);
-        if (!localData) {
-            return true;
-        }
-        const parsed = JSON.parse(localData);
-        if (!parsed.clientState) {
-            return false;
-        }
-        const setItemResult = indexedDBStorage.setItem(indexedDBKey, localData);
-        if (setItemResult instanceof Promise) {
-            await setItemResult;
-        }
-        window.localStorage.removeItem(localStorageKey);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export function checkStorageSize(key = "tanstack-query-cache") {
-    try {
-        const data = window.localStorage.getItem(key);
-        if (!data) {
-            return { sizeInBytes: 0, sizeInMB: 0, shouldMigrate: false, message: "No cache data found" };
-        }
-        const sizeInBytes = new Blob([data]).size;
-        const sizeInMB = sizeInBytes / (1024 * 1024);
-        const shouldMigrate = sizeInMB > 5;
-        return { sizeInBytes, sizeInMB: Math.round(sizeInMB * 100) / 100, shouldMigrate, message: shouldMigrate ? `Cache size (${sizeInMB.toFixed(2)}MB) exceeds recommended limit. Consider migrating to IndexedDB.` : `Cache size (${sizeInMB.toFixed(2)}MB) is within acceptable range.` };
-    }
-    catch {
-        return { sizeInBytes: 0, sizeInMB: 0, shouldMigrate: false, message: "Failed to check storage size" };
-    }
-}
-export function getStorageStats(key = "tanstack-query-cache") {
-    try {
-        const data = window.localStorage.getItem(key);
-        if (!data) {
-            return { exists: false, sizeInfo: checkStorageSize(key) };
-        }
-        const parsed = JSON.parse(data);
-        const now = Date.now();
-        const age = parsed.timestamp ? now - parsed.timestamp : undefined;
-        return { exists: true, age, queriesCount: parsed.clientState?.queries?.length, mutationsCount: parsed.clientState?.mutations?.length, sizeInfo: checkStorageSize(key) };
-    }
-    catch {
-        return { exists: false, sizeInfo: checkStorageSize(key) };
-    }
-}

package/dist/hooks/batchQueries.d.ts

@@ -1,129 +0,0 @@
-import type { QueryClient, UseQueryOptions, UseQueryResult, UseSuspenseQueryOptions, UseSuspenseQueryResult, DefaultError } from "@tanstack/react-query";
-import type { BatchErrorAggregate, BatchOperationReport, BatchQueryConfig, BatchQueryOperations, BatchQueryStats } from "../types/optimistic";
-interface InternalBatchQueryOperations extends BatchQueryOperations {
-    _queryClient: QueryClient;
-    _queries: UseQueryOptions[];
-    _results: UseQueryResult[] | UseSuspenseQueryResult[];
-}
-export declare function calculateBatchStats(results: UseQueryResult[] | UseSuspenseQueryResult[]): BatchQueryStats;
-export declare function useEnhancedQueries(queries: UseQueryOptions[], config?: BatchQueryConfig): {
-    data: UseQueryResult<unknown, Error>[];
-    stats: BatchQueryStats;
-    operations: InternalBatchQueryOperations;
-    config: BatchQueryConfig<unknown, Error>;
-};
-export declare function useEnhancedSuspenseQueries(queries: UseSuspenseQueryOptions[], config?: BatchQueryConfig): {
-    data: UseSuspenseQueryResult<unknown, Error>[];
-    stats: BatchQueryStats;
-    operations: InternalBatchQueryOperations;
-    config: BatchQueryConfig<unknown, Error>;
-};
-export declare function createBatchQueryConfig(config?: Partial<BatchQueryConfig>): BatchQueryConfig;
-export declare const batchQueryUtils: {
-    isAllLoading: (results: UseQueryResult[] | UseSuspenseQueryResult[]) => boolean;
-    isAllSuccess: (results: UseQueryResult[] | UseSuspenseQueryResult[]) => boolean;
-    hasError: (results: UseQueryResult[] | UseSuspenseQueryResult[]) => boolean;
-    hasStale: (results: UseQueryResult[] | UseSuspenseQueryResult[]) => boolean;
-    getAllErrors: (results: UseQueryResult[] | UseSuspenseQueryResult[]) => Error[];
-    getAllData: (results: UseQueryResult[] | UseSuspenseQueryResult[]) => unknown[];
-    isAllPending: (results: UseQueryResult[] | UseSuspenseQueryResult[]) => boolean;
-    isAnyFetching: (results: UseQueryResult[] | UseSuspenseQueryResult[]) => boolean;
-    getSuccessData: <T>(results: UseQueryResult<T>[]) => T[];
-    getFirstError: (results: UseQueryResult[] | UseSuspenseQueryResult[]) => Error | null;
-    createErrorAggregate: <TError = Error>(results: UseQueryResult[] | UseSuspenseQueryResult[], queries: UseQueryOptions[]) => BatchErrorAggregate<TError>;
-    createOperationReport: <TData = unknown, TError = Error>(results: UseQueryResult[] | UseSuspenseQueryResult[], queries: UseQueryOptions[], startTime: number, retryCount?: number) => BatchOperationReport<TData, TError>;
-};
-export declare function useCombinedQueries<TCombinedResult = UseQueryResult[]>(options: {
-    queries: UseQueryOptions[];
-    combine?: (results: UseQueryResult[]) => TCombinedResult;
-}): TCombinedResult;
-export declare function useDynamicBatchQueries<TItem, TData = unknown>(options: {
-    items: TItem[];
-    queryKeyPrefix: unknown[];
-    queryFn: (item: TItem) => Promise<TData>;
-    enabled?: boolean;
-    staleTime?: number;
-    gcTime?: number;
-    config?: BatchQueryConfig;
-}): {
-    data: UseQueryResult<unknown, Error>[];
-    stats: BatchQueryStats;
-    operations: InternalBatchQueryOperations;
-    config: BatchQueryConfig<unknown, Error>;
-};
-export declare function useDependentBatchQueries<TPrimaryData>(options: {
-    primaryQuery: UseQueryOptions<TPrimaryData>;
-    dependentQueries: (data: TPrimaryData) => UseQueryOptions[];
-    config?: BatchQueryConfig;
-}): DependentBatchQueriesResult<TPrimaryData>;
-export interface DependentBatchQueriesResult<TPrimaryData> {
-    primaryResult: UseQueryResult<TPrimaryData, DefaultError>;
-    results: UseQueryResult[];
-    stats: BatchQueryStats;
-    operations: InternalBatchQueryOperations;
-}
-export declare function useAutoRefreshBatchQueries(options: {
-    queries: UseQueryOptions[];
-    refreshInterval?: number;
-    enabled?: boolean;
-    config?: BatchQueryConfig;
-}): {
-    data: UseQueryResult<unknown, Error>[];
-    stats: BatchQueryStats;
-    operations: InternalBatchQueryOperations;
-    config: BatchQueryConfig<unknown, Error>;
-};
-export declare function useDashboardQueries<T extends Record<string, UseQueryOptions>>(queriesMap: T): {
-    data: { [K in keyof T]: T[K] extends UseQueryOptions<infer TData, Error, infer TData, readonly unknown[]> ? TData : unknown; };
-    results: UseQueryResult<unknown, Error>[];
-    stats: BatchQueryStats;
-    isLoading: boolean;
-    isError: boolean;
-    isSuccess: boolean;
-};
-export declare function usePaginatedBatchQueries<TData = unknown>(options: {
-    pageNumbers: number[];
-    queryKeyPrefix: unknown[];
-    queryFn: (page: number) => Promise<TData>;
-    staleTime?: number;
-    config?: BatchQueryConfig;
-}): {
-    data: UseQueryResult<unknown, Error>[];
-    stats: BatchQueryStats;
-    operations: InternalBatchQueryOperations;
-    config: BatchQueryConfig<unknown, Error>;
-};
-export declare function useConditionalBatchQueries(queries: (UseQueryOptions & {
-    enabled?: boolean;
-})[]): {
-    data: UseQueryResult<unknown, Error>[];
-    stats: BatchQueryStats;
-    operations: InternalBatchQueryOperations;
-    config: BatchQueryConfig<unknown, Error>;
-};
-export declare function useRetryBatchQueries(options: {
-    queries: UseQueryOptions[];
-    retry?: number | ((failureCount: number, error: Error) => boolean);
-    retryDelay?: number | ((attemptIndex: number) => number);
-    config?: BatchQueryConfig;
-}): {
-    data: UseQueryResult<unknown, Error>[];
-    stats: BatchQueryStats;
-    operations: InternalBatchQueryOperations;
-    config: BatchQueryConfig<unknown, Error>;
-};
-export declare function useBatchQueryPerformance(results: UseQueryResult[] | UseSuspenseQueryResult[]): {
-    avgFetchTime: number;
-    totalQueries: number;
-    activeQueries: number;
-    cachedQueries: number;
-    total: number;
-    loading: number;
-    success: number;
-    error: number;
-    stale: number;
-    successRate: number;
-    errorRate: number;
-};
-export {};
-//# sourceMappingURL=batchQueries.d.ts.map

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

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

package/dist/hooks/batchQueries.js

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

@@ -1 +0,0 @@
-{"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,0BAA0B,EAAE,6BAA6B,EAAE,iCAAiC,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAC9L,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EACtB,KAAK,sBAAsB,EAC3B,KAAK,WAAW,EAChB,iBAAiB,EACjB,qBAAqB,EACrB,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,mBAAmB,EACnB,qBAAqB,EACrB,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,KAAK,oBAAoB,EAAE,KAAK,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACjH,OAAO,EAAE,2BAA2B,EAAE,mBAAmB,EAAE,gCAAgC,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACrJ,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAE,oBAAoB,EAAE,KAAK,wBAAwB,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/hooks/useDataGuardMutation.d.ts

@@ -1,39 +0,0 @@
-import type { QueryKey, UseMutationResult } from "@tanstack/react-query";
-import type { MutationOptions } from "../types/index.js";
-import type { VersionedEntity } from "../types/dataGuard.js";
-export interface DataGuardMutationOptions<TData, TError, TVariables, TContext> extends MutationOptions<TData, TError, TVariables, TContext> {
-    /** 冲突错误回调 */
-    onConflict?: (error: any) => void;
-}
-/**
- * 带数据防护的 Mutation Hook
- *
- * 自动处理：
- * 1. 乐观更新时递增版本号和更新时间戳
- * 2. 标记最近更新的项
- * 3. 成功后更新所有家族缓存的元数据
- * 4. 冲突检测（409 错误）
- * 5. 延迟清理更新标记
- *
- * @example
- * ```typescript
- * const mutation = useDataGuardMutation(
- *   (updated) => api.updateProduct(updated.id, updated),
- *   ['products', 'list', { page: 1, pageSize: 20 }],
- *   {
- *     optimistic: {
- *       queryKey: ['products', 'list', { page: 1, pageSize: 20 }],
- *       updater: (old, updated) => ({
- *         ...old,
- *         items: old?.items?.map(p => p.id === updated.id ? updated : p)
- *       })
- *     },
- *     onConflict: (error) => {
- *       toast.error('数据冲突，请刷新')
- *     }
- *   }
- * )
- * ```
- */
-export declare function useDataGuardMutation<TData extends VersionedEntity = VersionedEntity, TError = Error, TVariables extends VersionedEntity = VersionedEntity, TContext = unknown>(mutationFn: (data: TVariables) => Promise<TData>, queryKey: QueryKey, options?: DataGuardMutationOptions<TData, TError, TVariables, TContext>): UseMutationResult<TData, TError, TVariables, TContext>;
-//# sourceMappingURL=useDataGuardMutation.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"useDataGuardMutation.d.ts","sourceRoot":"","sources":["../../src/hooks/useDataGuardMutation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AACzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAA8B,MAAM,uBAAuB,CAAC;AAuBzF,MAAM,WAAW,wBAAwB,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,CAAE,SAAQ,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,CAAC;IACzI,aAAa;IACb,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,SAAS,eAAe,GAAG,eAAe,EAC/C,MAAM,GAAG,KAAK,EACd,UAAU,SAAS,eAAe,GAAG,eAAe,EACpD,QAAQ,GAAG,OAAO,EAElB,UAAU,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,KAAK,CAAC,EAChD,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE,wBAAwB,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,CAAC,GACtE,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,CAAC,CAkHxD"}