@qiaopeng/tanstack-query-plus 0.5.8 → 0.5.10

package/dist/chunk-52ZO6Y67.cjs

@@ -0,0 +1,1121 @@
+'use strict';
+
+var chunkYW5PNTRU_cjs = require('./chunk-YW5PNTRU.cjs');
+var chunkAPXNNHBD_cjs = require('./chunk-APXNNHBD.cjs');
+var chunkNF5QYPYC_cjs = require('./chunk-NF5QYPYC.cjs');
+var chunk6MAYHLTE_cjs = require('./chunk-6MAYHLTE.cjs');
+var chunkOFLCHKKE_cjs = require('./chunk-OFLCHKKE.cjs');
+var reactQuery = require('@tanstack/react-query');
+var react = require('react');
+
+function createErrorAggregate(results, queries) {
+  const errors = [];
+  const errorsByType = /* @__PURE__ */ 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 !== void 0) {
+      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 ?? 1e3;
+  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 };
+}
+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 };
+}
+function useEnhancedQueries(queries, config = {}) {
+  const queryClient = reactQuery.useQueryClient();
+  const { results, stats } = reactQuery.useQueries({ queries, combine: (results2) => ({ results: results2, stats: calculateBatchStats(results2) }) });
+  const retryCountRef = react.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 };
+}
+function useEnhancedSuspenseQueries(queries, config = {}) {
+  const queryClient = reactQuery.useQueryClient();
+  const { results, stats } = reactQuery.useSuspenseQueries({ queries, combine: (results2) => ({ results: results2, stats: calculateBatchStats(results2) }) });
+  const retryCountRef = react.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 };
+}
+function createBatchQueryConfig(config = {}) {
+  return { enableStats: true, enableBatchOperations: true, autoRefreshInterval: void 0, onBatchSuccess: void 0, onBatchError: void 0, onBatchSettled: void 0, enablePartialSuccess: false, onPartialSuccess: void 0, retryConfig: void 0, ...config };
+}
+var 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 !== void 0).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)
+};
+function useCombinedQueries(options) {
+  return reactQuery.useQueries(options);
+}
+function useDynamicBatchQueries(options) {
+  const { items, queryKeyPrefix, queryFn, enabled = true, staleTime, gcTime, config = {} } = options;
+  const queries = react.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);
+}
+function useDependentBatchQueries(options) {
+  const { primaryQuery, dependentQueries, config = {} } = options;
+  const primaryResult = reactQuery.useQuery(primaryQuery);
+  const queries = react.useMemo(() => {
+    try {
+      if (!primaryResult.data) {
+        return [];
+      }
+      return dependentQueries(primaryResult.data);
+    } catch {
+      return [];
+    }
+  }, [primaryResult.data, dependentQueries]);
+  const enhancedQueriesResult = useEnhancedQueries(queries, config);
+  return { primaryResult, results: enhancedQueriesResult.data, stats: enhancedQueriesResult.stats, operations: enhancedQueriesResult.operations };
+}
+function useAutoRefreshBatchQueries(options) {
+  const { queries, refreshInterval = 3e4, enabled = true, config = {} } = options;
+  const result = useEnhancedQueries(queries, config);
+  react.useEffect(() => {
+    if (!enabled || !refreshInterval || !result.operations) return;
+    const intervalId = setInterval(() => {
+      result.operations?.refetchAll();
+    }, refreshInterval);
+    return () => clearInterval(intervalId);
+  }, [enabled, refreshInterval, result.operations]);
+  return result;
+}
+function useDashboardQueries(queriesMap) {
+  const queries = react.useMemo(() => {
+    return Object.values(queriesMap);
+  }, [queriesMap]);
+  const { results, combinedData, stats } = reactQuery.useQueries({ queries, combine: (results2) => {
+    const keys = Object.keys(queriesMap);
+    const data = {};
+    keys.forEach((key, index) => {
+      data[key] = results2[index].data;
+    });
+    return { results: results2, combinedData: data, stats: calculateBatchStats(results2) };
+  } });
+  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 };
+}
+function usePaginatedBatchQueries(options) {
+  const { pageNumbers, queryKeyPrefix, queryFn, staleTime, config } = options;
+  return useDynamicBatchQueries({ items: pageNumbers, queryKeyPrefix, queryFn, staleTime, config });
+}
+function useConditionalBatchQueries(queries) {
+  const enabledQueries = react.useMemo(() => {
+    return queries.filter((q) => q.enabled !== false);
+  }, [queries]);
+  return useEnhancedQueries(enabledQueries);
+}
+function useRetryBatchQueries(options) {
+  const { queries, retry, retryDelay, config } = options;
+  const queriesWithRetry = react.useMemo(() => {
+    return queries.map((query) => ({ ...query, retry: query.retry ?? retry, retryDelay: query.retryDelay ?? retryDelay }));
+  }, [queries, retry, retryDelay]);
+  return useEnhancedQueries(queriesWithRetry, config);
+}
+function useBatchQueryPerformance(results) {
+  return react.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]);
+}
+function useFocusState() {
+  const [focused, setFocused] = react.useState(chunkNF5QYPYC_cjs.focusManager.isFocused());
+  react.useEffect(() => {
+    const unsubscribe = chunkNF5QYPYC_cjs.focusManager.subscribe((isFocused) => {
+      setFocused(isFocused);
+    });
+    return unsubscribe;
+  }, []);
+  return focused;
+}
+function useFocusRefetch(options = {}) {
+  const queryClient = reactQuery.useQueryClient();
+  const { enabled = true, minInterval = 5e3, queryKeys = [] } = options;
+  const smartManager = chunkNF5QYPYC_cjs.getSmartFocusManager();
+  const queryKeysJson = JSON.stringify(queryKeys);
+  const stableQueryKeys = react.useMemo(() => queryKeys, [queryKeysJson]);
+  react.useEffect(() => {
+    if (!enabled || stableQueryKeys.length === 0) return;
+    const unsubscribe = chunkNF5QYPYC_cjs.focusManager.subscribe((isFocused) => {
+      if (!isFocused) return;
+      stableQueryKeys.forEach((queryKey) => {
+        if (smartManager.shouldRefetch(queryKey, minInterval)) {
+          queryClient.invalidateQueries({ queryKey });
+        }
+      });
+    });
+    return unsubscribe;
+  }, [queryClient, enabled, minInterval, stableQueryKeys, smartManager]);
+}
+function usePauseFocus(options = {}) {
+  const { autoPause = false, pauseWhen = false } = options;
+  react.useEffect(() => {
+    if (autoPause || pauseWhen) {
+      chunkNF5QYPYC_cjs.pauseFocusManager();
+      return () => {
+        chunkNF5QYPYC_cjs.resumeFocusManager();
+      };
+    }
+  }, [autoPause, pauseWhen]);
+  const pause = react.useCallback(() => {
+    chunkNF5QYPYC_cjs.pauseFocusManager();
+  }, []);
+  const resume = react.useCallback(() => {
+    chunkNF5QYPYC_cjs.resumeFocusManager();
+  }, []);
+  return { pause, resume };
+}
+function useSmartFocusManager() {
+  const manager = chunkNF5QYPYC_cjs.getSmartFocusManager();
+  const pause = react.useCallback(() => {
+    manager.pause();
+  }, [manager]);
+  const resume = react.useCallback(() => {
+    manager.resume();
+  }, [manager]);
+  const getStats = react.useCallback(() => {
+    return manager.getStats();
+  }, [manager]);
+  return { pause, resume, getStats, stats: manager.getStats() };
+}
+function useConditionalFocusRefetch(queryKey, condition, options = {}) {
+  const queryClient = reactQuery.useQueryClient();
+  const { minInterval = 5e3, enabled = true } = options;
+  const smartManager = chunkNF5QYPYC_cjs.getSmartFocusManager();
+  const queryKeyJson = JSON.stringify(queryKey);
+  const stableQueryKey = react.useMemo(() => queryKey, [queryKeyJson]);
+  const conditionRef = react.useRef(condition);
+  react.useEffect(() => {
+    conditionRef.current = condition;
+  }, [condition]);
+  react.useEffect(() => {
+    if (!enabled) return;
+    const unsubscribe = chunkNF5QYPYC_cjs.focusManager.subscribe((isFocused) => {
+      if (!isFocused || !conditionRef.current()) return;
+      if (smartManager.shouldRefetch(stableQueryKey, minInterval)) {
+        queryClient.invalidateQueries({ queryKey: stableQueryKey });
+      }
+    });
+    return unsubscribe;
+  }, [queryClient, stableQueryKey, minInterval, enabled, smartManager]);
+}
+function useFocusCallback(callback, options = {}) {
+  const { minInterval = 0, enabled = true, queryKey } = options;
+  const lastCallTime = react.useRef(0);
+  const smartManager = chunkNF5QYPYC_cjs.getSmartFocusManager();
+  const queryKeyJson = JSON.stringify(queryKey);
+  const stableQueryKey = react.useMemo(() => queryKey, [queryKeyJson]);
+  const callbackRef = react.useRef(callback);
+  react.useEffect(() => {
+    callbackRef.current = callback;
+  }, [callback]);
+  react.useEffect(() => {
+    if (!enabled) return;
+    const unsubscribe = chunkNF5QYPYC_cjs.focusManager.subscribe((isFocused) => {
+      if (!isFocused) return;
+      if (stableQueryKey !== void 0) {
+        if (smartManager.shouldRefetch(stableQueryKey, minInterval)) {
+          callbackRef.current();
+        }
+        return;
+      }
+      const now = Date.now();
+      if (minInterval > 0 && now - lastCallTime.current < minInterval) return;
+      lastCallTime.current = now;
+      callbackRef.current();
+    });
+    return unsubscribe;
+  }, [minInterval, enabled, stableQueryKey, smartManager]);
+}
+function usePageVisibility() {
+  const [isVisible, setIsVisible] = react.useState(typeof document !== "undefined" ? !document.hidden : true);
+  react.useEffect(() => {
+    const unsubscribe = chunkNF5QYPYC_cjs.focusManager.subscribe((isFocused) => {
+      setIsVisible(isFocused);
+    });
+    return unsubscribe;
+  }, []);
+  return isVisible;
+}
+function useEnhancedInfiniteQuery(options) {
+  return reactQuery.useInfiniteQuery(options);
+}
+function createInfiniteQueryOptions(config) {
+  return reactQuery.infiniteQueryOptions({ ...config, maxPages: config.maxPages });
+}
+function createCursorPaginationOptions(config) {
+  return createInfiniteQueryOptions({
+    queryKey: config.queryKey,
+    queryFn: ({ pageParam }) => config.queryFn(pageParam),
+    initialPageParam: config.initialCursor ?? null,
+    getNextPageParam: (lastPage) => lastPage.cursor ?? null,
+    getPreviousPageParam: () => null,
+    staleTime: config.staleTime,
+    gcTime: config.gcTime,
+    maxPages: config.maxPages
+  });
+}
+function createOffsetPaginationOptions(config) {
+  const limit = config.limit ?? 20;
+  return createInfiniteQueryOptions({
+    queryKey: [...config.queryKey, limit],
+    queryFn: ({ pageParam }) => config.queryFn(pageParam, limit),
+    initialPageParam: 0,
+    getNextPageParam: (lastPage, allPages) => {
+      if (lastPage.hasMore === false) return void 0;
+      const currentOffset = allPages.length * limit;
+      if (currentOffset >= lastPage.total) return void 0;
+      return currentOffset;
+    },
+    getPreviousPageParam: (_firstPage, allPages) => {
+      if (allPages.length <= 1) return void 0;
+      return (allPages.length - 2) * limit;
+    },
+    staleTime: config.staleTime,
+    gcTime: config.gcTime,
+    maxPages: config.maxPages
+  });
+}
+function createPageNumberPaginationOptions(config) {
+  return createInfiniteQueryOptions({
+    queryKey: config.queryKey,
+    queryFn: ({ pageParam }) => config.queryFn(pageParam),
+    initialPageParam: 1,
+    getNextPageParam: (lastPage, allPages) => {
+      const nextPage = allPages.length + 1;
+      if (nextPage > lastPage.totalPages) return void 0;
+      return nextPage;
+    },
+    getPreviousPageParam: (_firstPage, allPages) => {
+      if (allPages.length <= 1) return void 0;
+      return allPages.length - 1;
+    },
+    staleTime: config.staleTime,
+    gcTime: config.gcTime,
+    maxPages: config.maxPages
+  });
+}
+function useMutation(options) {
+  const queryClient = reactQuery.useQueryClient();
+  const { optimistic, onMutate, onError, onSuccess, onSettled, ...restOptions } = options;
+  const mutationConfig = {
+    ...restOptions,
+    retry: restOptions.retry ?? chunk6MAYHLTE_cjs.DEFAULT_MUTATION_CONFIG.retry,
+    retryDelay: restOptions.retryDelay ?? chunk6MAYHLTE_cjs.DEFAULT_MUTATION_CONFIG.retryDelay,
+    gcTime: restOptions.gcTime ?? chunk6MAYHLTE_cjs.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) : void 0;
+        return { userContext };
+      }
+      try {
+        const familyKey = optimistic.familyKey ?? chunkAPXNNHBD_cjs.deriveFamilyKey(optimistic.queryKey);
+        await queryClient.cancelQueries({ queryKey: familyKey });
+        const previousData = queryClient.getQueriesData({ queryKey: familyKey });
+        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.setQueriesData(
+          { queryKey: familyKey },
+          (oldData) => {
+            if (!oldData) return oldData;
+            return optimistic.updater(oldData, mappedVariables);
+          }
+        );
+        const mutateCallback = onMutate;
+        const userContext = onMutate ? await mutateCallback(variables) : void 0;
+        return { previousData, userContext };
+      } catch (error) {
+        return { userContext: void 0 };
+      }
+    };
+    mutationConfig.onError = (error, variables, context) => {
+      if (context?.previousData) {
+        context.previousData.forEach(([queryKey, data]) => {
+          queryClient.setQueryData(queryKey, data);
+        });
+      }
+      if (optimistic.rollback && context?.previousData) {
+        try {
+          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) => {
+      const scope = optimistic.invalidateScope ?? (chunkAPXNNHBD_cjs.isListFamilyKey(optimistic.queryKey) ? "family" : "exact");
+      const invalidations = [];
+      if (scope !== "none") {
+        if (scope === "family") {
+          const familyKey = optimistic.familyKey ?? chunkAPXNNHBD_cjs.deriveFamilyKey(optimistic.queryKey);
+          invalidations.push({ queryKey: familyKey });
+        } else {
+          invalidations.push({ queryKey: optimistic.queryKey });
+        }
+      }
+      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 }));
+      }
+      if (invalidations.length > 0) {
+        const seen = /* @__PURE__ */ 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 reactQuery.useMutation(mutationConfig);
+}
+function setupMutationDefaults(queryClient, config) {
+  Object.entries(config).forEach(([key, options]) => {
+    queryClient.setMutationDefaults([key], options);
+  });
+}
+function useListMutation(mutationFn, queryKey, options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn,
+    onSettled: () => {
+      const familyKey = chunkAPXNNHBD_cjs.deriveFamilyKey(queryKey);
+      queryClient.invalidateQueries({ queryKey: familyKey, exact: false });
+    },
+    ...options,
+    mutationKey: options?.mutationKey
+  });
+}
+function isMissingOrStale(queryClient, queryKey, staleTime) {
+  const state = queryClient.getQueryState(queryKey);
+  if (!state || state.data === void 0) return true;
+  const updatedAt = state.dataUpdatedAt ?? 0;
+  return Date.now() - updatedAt > staleTime;
+}
+function useHoverPrefetch(queryKey, queryFn, options = {}) {
+  const queryClient = reactQuery.useQueryClient();
+  const timeoutRef = react.useRef(void 0);
+  const { hoverDelay = 200, enabled = true, staleTime = chunk6MAYHLTE_cjs.DEFAULT_STALE_TIME, minInterval = 1e3 } = options;
+  const queryFnRef = react.useRef(queryFn);
+  react.useEffect(() => {
+    queryFnRef.current = queryFn;
+  }, [queryFn]);
+  const lastPrefetchRef = react.useRef(/* @__PURE__ */ new Map());
+  const prefetch = react.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 = react.useCallback(() => {
+    if (!enabled) return;
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+    }
+    timeoutRef.current = setTimeout(prefetch, hoverDelay);
+  }, [prefetch, hoverDelay, enabled]);
+  const handleMouseLeave = react.useCallback(() => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+    }
+  }, []);
+  react.useEffect(() => () => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+    }
+  }, []);
+  return { onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onFocus: prefetch };
+}
+function useRoutePrefetch() {
+  const queryClient = reactQuery.useQueryClient();
+  const lastPrefetchRef = react.useRef(/* @__PURE__ */ new Map());
+  return react.useCallback((queryKey, queryFn, options) => {
+    const { enabled = true, staleTime = chunk6MAYHLTE_cjs.DEFAULT_STALE_TIME, minInterval = 1e3 } = 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]);
+}
+function useBatchPrefetch() {
+  const queryClient = reactQuery.useQueryClient();
+  return react.useCallback((queries) => {
+    queries.forEach(({ queryKey, queryFn, staleTime = chunk6MAYHLTE_cjs.DEFAULT_STALE_TIME }) => {
+      if (isMissingOrStale(queryClient, queryKey, staleTime)) {
+        queryClient.prefetchQuery({ queryKey, queryFn, staleTime });
+      }
+    });
+  }, [queryClient]);
+}
+function useSmartPrefetch() {
+  const queryClient = reactQuery.useQueryClient();
+  const prefetchedRef = react.useRef(/* @__PURE__ */ new Set());
+  const lastPrefetchRef = react.useRef(/* @__PURE__ */ new Map());
+  const shouldPrefetchQuery = react.useCallback((queryKey) => {
+    const key = JSON.stringify(queryKey);
+    if (prefetchedRef.current.has(key)) return false;
+    if (chunkAPXNNHBD_cjs.isSlowNetwork()) return false;
+    return true;
+  }, []);
+  const prefetch = react.useCallback((queryKey, queryFn, options) => {
+    if (!shouldPrefetchQuery(queryKey)) return;
+    const { staleTime = chunk6MAYHLTE_cjs.DEFAULT_STALE_TIME, minInterval = 1e3 } = 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 = react.useCallback(() => {
+    prefetchedRef.current.clear();
+  }, []);
+  return { prefetch, shouldPrefetch: !chunkAPXNNHBD_cjs.isSlowNetwork(), clearPrefetchHistory };
+}
+function useStableQueryKey(queryKey) {
+  const keyRef = react.useRef(queryKey);
+  const keyStr = JSON.stringify(queryKey);
+  const prevKeyStr = react.useRef(keyStr);
+  if (prevKeyStr.current !== keyStr) {
+    keyRef.current = queryKey;
+    prevKeyStr.current = keyStr;
+  }
+  return keyRef.current;
+}
+function useConditionalPrefetch(queryKey, queryFn, condition, options) {
+  const queryClient = reactQuery.useQueryClient();
+  const { staleTime = chunk6MAYHLTE_cjs.DEFAULT_STALE_TIME, delay = 0 } = options || {};
+  const queryFnRef = react.useRef(queryFn);
+  react.useEffect(() => {
+    queryFnRef.current = queryFn;
+  }, [queryFn]);
+  const stableQueryKey = useStableQueryKey(queryKey);
+  react.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]);
+}
+function useIdlePrefetch(queryKey, queryFn, options) {
+  const queryClient = reactQuery.useQueryClient();
+  const { staleTime = chunk6MAYHLTE_cjs.DEFAULT_STALE_TIME, enabled = true, timeout = 1e3 } = options || {};
+  const queryFnRef = react.useRef(queryFn);
+  react.useEffect(() => {
+    queryFnRef.current = queryFn;
+  }, [queryFn]);
+  const stableQueryKey = useStableQueryKey(queryKey);
+  react.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]);
+}
+function usePeriodicPrefetch(queryKey, queryFn, options) {
+  const queryClient = reactQuery.useQueryClient();
+  const { staleTime = chunk6MAYHLTE_cjs.DEFAULT_STALE_TIME, enabled = true, interval = 6e4 } = options || {};
+  const queryFnRef = react.useRef(queryFn);
+  react.useEffect(() => {
+    queryFnRef.current = queryFn;
+  }, [queryFn]);
+  const stableQueryKey = useStableQueryKey(queryKey);
+  react.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]);
+}
+function usePredictivePrefetch() {
+  const queryClient = reactQuery.useQueryClient();
+  const interactionHistoryRef = react.useRef([]);
+  const maxHistorySize = 50;
+  const recordInteraction = react.useCallback((action, target) => {
+    interactionHistoryRef.current.push({ action, target, timestamp: Date.now() });
+    if (interactionHistoryRef.current.length > maxHistorySize) {
+      interactionHistoryRef.current.shift();
+    }
+  }, []);
+  const getPredictions = react.useCallback(() => {
+    const history = interactionHistoryRef.current;
+    if (history.length < 3) return [];
+    const targetCounts = /* @__PURE__ */ 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 = react.useCallback((getQueryConfig) => {
+    const predictions = getPredictions();
+    predictions.forEach((target) => {
+      const { queryKey, queryFn } = getQueryConfig(target);
+      queryClient.prefetchQuery({ queryKey, queryFn });
+    });
+  }, [queryClient, getPredictions]);
+  const clearHistory = react.useCallback(() => {
+    interactionHistoryRef.current = [];
+  }, []);
+  return { recordInteraction, getPredictions, prefetchPredicted, clearHistory };
+}
+function usePriorityPrefetch() {
+  const queryClient = reactQuery.useQueryClient();
+  const tasksRef = react.useRef([]);
+  const [taskCount, setTaskCount] = react.useState(0);
+  const addPrefetchTask = react.useCallback((queryKey, queryFn, priority = "medium") => {
+    tasksRef.current.push({ queryKey, queryFn, priority, timestamp: Date.now() });
+    setTaskCount(tasksRef.current.length);
+  }, []);
+  const processTasks = react.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 = react.useCallback(() => {
+    tasksRef.current = [];
+    setTaskCount(0);
+  }, []);
+  return { addPrefetchTask, processTasks, clearTasks, taskCount };
+}
+function useEnhancedQuery(options) {
+  const {
+    logErrors = chunkOFLCHKKE_cjs.isDev,
+    onSlowQuery,
+    slowQueryThreshold = 3e3,
+    trackPerformance = false,
+    ...queryOptions
+  } = options;
+  const startTimeRef = react.useRef(0);
+  const refetchCountRef = react.useRef(0);
+  const lastDurationRef = react.useRef(null);
+  const wasFetchingRef = react.useRef(false);
+  const result = reactQuery.useQuery(queryOptions);
+  react.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]);
+  react.useEffect(() => {
+    if (logErrors && result.isError && result.error) {
+      console.error(`[useEnhancedQuery Error] ${JSON.stringify(queryOptions.queryKey)}:`, result.error);
+    }
+  }, [result.isError, result.error, logErrors, queryOptions.queryKey]);
+  react.useEffect(() => {
+    if (result.isRefetching) {
+      refetchCountRef.current++;
+    }
+  }, [result.isRefetching]);
+  return {
+    ...result,
+    refetchCount: refetchCountRef.current,
+    lastQueryDuration: lastDurationRef.current
+  };
+}
+function createSuspenseQuery(getQueryKey, queryFn, options) {
+  return (variables) => {
+    const queryKey = getQueryKey(variables);
+    return reactQuery.useSuspenseQuery({ queryKey, queryFn, ...options });
+  };
+}
+function createSuspenseInfiniteQuery(getQueryKey, queryFn, options) {
+  return (variables) => {
+    const queryKey = getQueryKey(variables);
+    return reactQuery.useSuspenseInfiniteQuery({ queryKey, queryFn, ...options });
+  };
+}
+function useEnhancedSuspenseQuery(options) {
+  return reactQuery.useSuspenseQuery(options);
+}
+function useEnhancedSuspenseInfiniteQuery(options) {
+  return reactQuery.useSuspenseInfiniteQuery(options);
+}
+function useDataGuardQueryConfig(queryKey, fetchFn, options) {
+  const queryClient = reactQuery.useQueryClient();
+  return {
+    queryKey,
+    queryFn: async () => {
+      const newData = await fetchFn();
+      const cached = queryClient.getQueryData(queryKey);
+      const { shouldReject, reason, strategy, guardDetails } = chunkAPXNNHBD_cjs.applyDataGuard(
+        newData,
+        cached,
+        queryKey,
+        options
+      );
+      options?.onDataGuardApplied?.({
+        strategy,
+        passed: !shouldReject,
+        details: guardDetails
+      });
+      if (shouldReject) {
+        if (chunkOFLCHKKE_cjs.isDev) {
+          console.warn("[Data Guard] \u62D2\u7EDD\u65E7\u6570\u636E", {
+            reason,
+            strategy,
+            queryKey,
+            guardDetails
+          });
+        }
+        options?.onStaleDataDetected?.({
+          reason,
+          strategy,
+          queryKey,
+          cached,
+          rejected: newData
+        });
+        return cached;
+      }
+      if (chunkOFLCHKKE_cjs.isDev) {
+        console.log("[Data Guard] \u63A5\u53D7\u65B0\u6570\u636E", {
+          strategy,
+          guardDetails
+        });
+      }
+      return chunkAPXNNHBD_cjs.addHashToData(newData);
+    }
+  };
+}
+function useDataGuardMutation(mutationFn, queryKey, options) {
+  const queryClient = reactQuery.useQueryClient();
+  const { onConflict, onSuccess, optimistic, ...restOptions } = options || {};
+  const enhancedMutationFn = async (data) => {
+    try {
+      const result = await mutationFn(data);
+      return result;
+    } catch (error) {
+      if (error && typeof error === "object" && (error.status === 409 || error.code === "CONFLICT" || error.name === "ConflictError")) {
+        onConflict?.(error);
+        throw new chunkYW5PNTRU_cjs.ConflictError(error);
+      }
+      throw error;
+    }
+  };
+  const enhancedOptimistic = optimistic ? {
+    ...optimistic,
+    updater: (old, variables) => {
+      const updated = optimistic.updater(old, variables);
+      if (!updated) return updated;
+      if (variables.id === void 0 || variables.id === null) {
+        return updated;
+      }
+      const withMark = chunkAPXNNHBD_cjs.markRecentlyUpdated(updated, variables.id);
+      if (old && old.version !== void 0) {
+        withMark.version = old.version + 1;
+      }
+      if (old && old.updatedAt !== void 0) {
+        withMark.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      if (old && old._hash !== void 0) {
+        withMark._hash = chunkAPXNNHBD_cjs.hashObject(withMark.items);
+      }
+      return withMark;
+    }
+  } : void 0;
+  const enhancedOnSuccess = (data, variables, onMutateResult, context) => {
+    try {
+      const familyKey = Array.isArray(queryKey) ? queryKey.slice(0, -1) : [queryKey];
+      chunkAPXNNHBD_cjs.updateFamilyMetadata(queryClient, familyKey, data);
+      const cleanupDelay = 5e3;
+      setTimeout(() => {
+        try {
+          if (variables.id === void 0 || variables.id === null) {
+            return;
+          }
+          const cache = queryClient.getQueryCache();
+          const queries = cache.findAll({
+            predicate: (q) => chunkAPXNNHBD_cjs.startsWithKeyPrefix(q.queryKey, familyKey)
+          });
+          queries.forEach((q) => {
+            const old = queryClient.getQueryData(q.queryKey);
+            if (old?._recentlyUpdatedIds) {
+              const cleared = chunkAPXNNHBD_cjs.clearRecentlyUpdated(old, variables.id);
+              queryClient.setQueryData(q.queryKey, cleared);
+            }
+          });
+        } catch (error) {
+        }
+      }, cleanupDelay);
+    } catch (error) {
+    }
+    onSuccess?.(data, variables, onMutateResult, context);
+  };
+  return useMutation({
+    ...restOptions,
+    mutationFn: enhancedMutationFn,
+    optimistic: enhancedOptimistic,
+    // 类型复杂，暂时保留
+    onSuccess: enhancedOnSuccess,
+    onError: (error, variables, onMutateResult, context) => {
+      if (error instanceof chunkYW5PNTRU_cjs.ConflictError) {
+        const familyKey = Array.isArray(queryKey) ? queryKey.slice(0, -1) : [queryKey];
+        queryClient.invalidateQueries({ queryKey: familyKey });
+      }
+      restOptions.onError?.(error, variables, onMutateResult, context);
+    }
+  });
+}
+function useMutationState(options = {}) {
+  return reactQuery.useMutationState(options);
+}
+function useIsFetching(filters) {
+  return reactQuery.useIsFetching(filters);
+}
+function useIsMutating(filters) {
+  return reactQuery.useIsMutating(filters);
+}
+
+Object.defineProperty(exports, "skipToken", {
+  enumerable: true,
+  get: function () { return reactQuery.skipToken; }
+});
+exports.batchQueryUtils = batchQueryUtils;
+exports.calculateBatchStats = calculateBatchStats;
+exports.createBatchQueryConfig = createBatchQueryConfig;
+exports.createCursorPaginationOptions = createCursorPaginationOptions;
+exports.createInfiniteQueryOptions = createInfiniteQueryOptions;
+exports.createOffsetPaginationOptions = createOffsetPaginationOptions;
+exports.createPageNumberPaginationOptions = createPageNumberPaginationOptions;
+exports.createSuspenseInfiniteQuery = createSuspenseInfiniteQuery;
+exports.createSuspenseQuery = createSuspenseQuery;
+exports.setupMutationDefaults = setupMutationDefaults;
+exports.useAutoRefreshBatchQueries = useAutoRefreshBatchQueries;
+exports.useBatchPrefetch = useBatchPrefetch;
+exports.useBatchQueryPerformance = useBatchQueryPerformance;
+exports.useCombinedQueries = useCombinedQueries;
+exports.useConditionalBatchQueries = useConditionalBatchQueries;
+exports.useConditionalFocusRefetch = useConditionalFocusRefetch;
+exports.useConditionalPrefetch = useConditionalPrefetch;
+exports.useDashboardQueries = useDashboardQueries;
+exports.useDataGuardMutation = useDataGuardMutation;
+exports.useDataGuardQueryConfig = useDataGuardQueryConfig;
+exports.useDependentBatchQueries = useDependentBatchQueries;
+exports.useDynamicBatchQueries = useDynamicBatchQueries;
+exports.useEnhancedInfiniteQuery = useEnhancedInfiniteQuery;
+exports.useEnhancedQueries = useEnhancedQueries;
+exports.useEnhancedQuery = useEnhancedQuery;
+exports.useEnhancedSuspenseInfiniteQuery = useEnhancedSuspenseInfiniteQuery;
+exports.useEnhancedSuspenseQueries = useEnhancedSuspenseQueries;
+exports.useEnhancedSuspenseQuery = useEnhancedSuspenseQuery;
+exports.useFocusCallback = useFocusCallback;
+exports.useFocusRefetch = useFocusRefetch;
+exports.useFocusState = useFocusState;
+exports.useHoverPrefetch = useHoverPrefetch;
+exports.useIdlePrefetch = useIdlePrefetch;
+exports.useIsFetching = useIsFetching;
+exports.useIsMutating = useIsMutating;
+exports.useListMutation = useListMutation;
+exports.useMutation = useMutation;
+exports.useMutationState = useMutationState;
+exports.usePageVisibility = usePageVisibility;
+exports.usePaginatedBatchQueries = usePaginatedBatchQueries;
+exports.usePauseFocus = usePauseFocus;
+exports.usePeriodicPrefetch = usePeriodicPrefetch;
+exports.usePredictivePrefetch = usePredictivePrefetch;
+exports.usePriorityPrefetch = usePriorityPrefetch;
+exports.useRetryBatchQueries = useRetryBatchQueries;
+exports.useRoutePrefetch = useRoutePrefetch;
+exports.useSmartFocusManager = useSmartFocusManager;
+exports.useSmartPrefetch = useSmartPrefetch;
+//# sourceMappingURL=chunk-52ZO6Y67.cjs.map
+//# sourceMappingURL=chunk-52ZO6Y67.cjs.map