@qiaopeng/tanstack-query-plus 0.1.0

package/dist/features/offline.js

@@ -0,0 +1,269 @@
+import { onlineManager } from "@tanstack/react-query";
+import { ConnectionQuality, StorageType } from "../types/base.js";
+import { isStorageAvailable } from "../utils/storage.js";
+export function setupOnlineManager() {
+    if (typeof window === "undefined")
+        return;
+    onlineManager.setEventListener((setOnline) => {
+        const handleOnline = () => setOnline(true);
+        const handleOffline = () => setOnline(false);
+        window.addEventListener("online", handleOnline);
+        window.addEventListener("offline", handleOffline);
+        return () => {
+            window.removeEventListener("online", handleOnline);
+            window.removeEventListener("offline", handleOffline);
+        };
+    });
+}
+export const isOnline = () => onlineManager.isOnline();
+export function subscribeToOnlineStatus(callback) { return onlineManager.subscribe(callback); }
+export function configureOfflineQueries(_queryClient) { }
+const DEFAULT_QUEUE_CONFIG = { enabled: true, maxSize: 100, persist: true, storageKey: "tanstack-query-offline-queue", autoExecuteInterval: 5000, executeOnReconnect: true, operationTimeout: 30000, concurrency: 3 };
+export function calculateExponentialBackoff(attempt, baseDelay = 1000, maxDelay = 30000) {
+    const delay = Math.min(baseDelay * 2 ** attempt, maxDelay);
+    const jitter = Math.random() * 0.3 * delay;
+    return Math.floor(delay + jitter);
+}
+class MutationRegistry {
+    constructor() {
+        this.registry = new Map();
+    }
+    register(key, fn) { this.registry.set(key, fn); }
+    get(key) { return this.registry.get(key); }
+    unregister(key) { this.registry.delete(key); }
+    clear() { this.registry.clear(); }
+    getKeys() { return Array.from(this.registry.keys()); }
+}
+export const mutationRegistry = new MutationRegistry();
+export class OfflineQueueManager {
+    constructor(config = {}) {
+        this.queue = [];
+        this.isExecuting = false;
+        this.executionTimer = null;
+        this.unsubscribeOnline = null;
+        this.executingOperations = new Set();
+        this.config = { ...DEFAULT_QUEUE_CONFIG, ...config };
+        if (this.config.persist) {
+            this.loadQueue();
+        }
+        if (this.config.executeOnReconnect) {
+            this.setupOnlineListener();
+        }
+        if (this.config.autoExecuteInterval > 0) {
+            this.startAutoExecution();
+        }
+    }
+    async add(operation) {
+        const id = `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        const newOperation = { ...operation, id, createdAt: new Date(), retryCount: 0 };
+        if (this.queue.length >= this.config.maxSize) {
+            throw new Error(`Queue is full (max size: ${this.config.maxSize})`);
+        }
+        const insertIndex = this.queue.findIndex((op) => op.priority < newOperation.priority);
+        if (insertIndex === -1) {
+            this.queue.push(newOperation);
+        }
+        else {
+            this.queue.splice(insertIndex, 0, newOperation);
+        }
+        if (this.config.persist) {
+            await this.persistQueue();
+        }
+        return id;
+    }
+    async remove(operationId) {
+        const index = this.queue.findIndex((op) => op.id === operationId);
+        if (index === -1)
+            return false;
+        this.queue.splice(index, 1);
+        if (this.config.persist) {
+            await this.persistQueue();
+        }
+        return true;
+    }
+    getState() {
+        const online = isOnline();
+        return { isOffline: !online, networkStatus: { isOnline: online, isOffline: !online, connectionQuality: ConnectionQuality.UNKNOWN }, queuedOperations: this.queue.length, failedQueries: this.queue.filter((op) => op.lastError).length, lastSyncAt: this.queue.length === 0 ? new Date() : undefined, isRecovering: this.isExecuting };
+    }
+    getOperations() { return [...this.queue]; }
+    async clear() { this.queue = []; if (this.config.persist) {
+        await this.persistQueue();
+    } }
+    async execute() {
+        if (this.isExecuting) {
+            return { success: 0, failed: 0, skipped: this.queue.length };
+        }
+        if (!isOnline()) {
+            return { success: 0, failed: 0, skipped: this.queue.length };
+        }
+        this.isExecuting = true;
+        let successCount = 0;
+        let failedCount = 0;
+        let skippedCount = 0;
+        try {
+            const sortedOperations = this.sortOperationsByDependency();
+            const batches = this.createBatches(sortedOperations, this.config.concurrency);
+            for (const batch of batches) {
+                const results = await Promise.allSettled(batch.map((op) => this.executeOperation(op)));
+                results.forEach((result) => {
+                    if (result.status === "fulfilled") {
+                        if (result.value) {
+                            successCount++;
+                        }
+                        else {
+                            skippedCount++;
+                        }
+                    }
+                    else {
+                        failedCount++;
+                    }
+                });
+            }
+            this.queue = this.queue.filter((op) => op.lastError !== undefined);
+            if (this.config.persist) {
+                await this.persistQueue();
+            }
+            return { success: successCount, failed: failedCount, skipped: skippedCount };
+        }
+        finally {
+            this.isExecuting = false;
+        }
+    }
+    async executeOperation(operation) {
+        if (this.executingOperations.has(operation.id)) {
+            return false;
+        }
+        if (operation.dependsOn && operation.dependsOn.length > 0) {
+            const dependenciesMet = operation.dependsOn.every((depId) => !this.queue.find((op) => op.id === depId));
+            if (!dependenciesMet) {
+                return false;
+            }
+        }
+        this.executingOperations.add(operation.id);
+        try {
+            const mutationKey = Array.isArray(operation.mutationKey) ? operation.mutationKey.join("-") : String(operation.mutationKey);
+            const mutationFn = mutationRegistry.get(mutationKey) || operation.mutationFn;
+            const timeoutPromise = new Promise((_, reject) => { setTimeout(() => reject(new Error("Operation timeout")), this.config.operationTimeout); });
+            await Promise.race([mutationFn(), timeoutPromise]);
+            await this.remove(operation.id);
+            return true;
+        }
+        catch (error) {
+            operation.retryCount++;
+            operation.lastError = error instanceof Error ? error : new Error(String(error));
+            if (operation.retryCount >= 5) { /* noop */ }
+            if (this.config.persist) {
+                await this.persistQueue();
+            }
+            return false;
+        }
+        finally {
+            this.executingOperations.delete(operation.id);
+        }
+    }
+    sortOperationsByDependency() {
+        const sorted = [];
+        const visited = new Set();
+        const visiting = new Set();
+        const visit = (operation) => {
+            if (visited.has(operation.id))
+                return;
+            if (visiting.has(operation.id)) {
+                return;
+            }
+            visiting.add(operation.id);
+            if (operation.dependsOn) {
+                for (const depId of operation.dependsOn) {
+                    const dep = this.queue.find((op) => op.id === depId);
+                    if (dep) {
+                        visit(dep);
+                    }
+                }
+            }
+            visiting.delete(operation.id);
+            visited.add(operation.id);
+            sorted.push(operation);
+        };
+        const prioritySorted = [...this.queue].sort((a, b) => b.priority - a.priority);
+        for (const operation of prioritySorted) {
+            visit(operation);
+        }
+        return sorted;
+    }
+    createBatches(operations, batchSize) {
+        const batches = [];
+        for (let i = 0; i < operations.length; i += batchSize) {
+            batches.push(operations.slice(i, i + batchSize));
+        }
+        return batches;
+    }
+    async persistQueue() {
+        if (!isStorageAvailable(StorageType.LOCAL)) {
+            return;
+        }
+        try {
+            const serialized = JSON.stringify(this.queue.map((op) => ({ ...op, createdAt: op.createdAt.toISOString(), mutationFn: undefined })));
+            localStorage.setItem(this.config.storageKey, serialized);
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === "QuotaExceededError") {
+                this.cleanupOldOperations();
+                try {
+                    const serialized = JSON.stringify(this.queue.map((op) => ({ ...op, createdAt: op.createdAt.toISOString(), mutationFn: undefined })));
+                    localStorage.setItem(this.config.storageKey, serialized);
+                }
+                catch { }
+            }
+        }
+    }
+    loadQueue() {
+        if (!isStorageAvailable(StorageType.LOCAL)) {
+            return;
+        }
+        try {
+            const stored = localStorage.getItem(this.config.storageKey);
+            if (!stored)
+                return;
+            const parsed = JSON.parse(stored);
+            if (!Array.isArray(parsed)) {
+                this.queue = [];
+                return;
+            }
+            this.queue = parsed.map((op) => ({ ...op, createdAt: new Date(op.createdAt), mutationFn: op.mutationFn || (() => Promise.reject(new Error("Mutation function not registered"))) }));
+        }
+        catch {
+            this.queue = [];
+        }
+    }
+    cleanupOldOperations() {
+        const oneDayAgo = new Date(Date.now() - 24 * 60 * 60 * 1000);
+        this.queue = this.queue.filter((op) => op.createdAt > oneDayAgo);
+    }
+    setupOnlineListener() {
+        this.unsubscribeOnline = subscribeToOnlineStatus((online) => { if (online && this.queue.length > 0) {
+            this.execute().catch(() => { });
+        } });
+    }
+    startAutoExecution() {
+        this.executionTimer = setInterval(() => {
+            if (isOnline() && this.queue.length > 0 && !this.isExecuting) {
+                this.execute().catch(() => { });
+            }
+        }, this.config.autoExecuteInterval);
+    }
+    stopAutoExecution() {
+        if (this.executionTimer) {
+            clearInterval(this.executionTimer);
+            this.executionTimer = null;
+        }
+    }
+    destroy() {
+        this.stopAutoExecution();
+        if (this.unsubscribeOnline) {
+            this.unsubscribeOnline();
+            this.unsubscribeOnline = null;
+        }
+        this.executingOperations.clear();
+    }
+}
+export function createOfflineQueueManager(config) { return new OfflineQueueManager(config); }

package/dist/features/persistence.d.ts

@@ -0,0 +1,36 @@
+import type { Query } from "@tanstack/react-query";
+import type { PersistedClient, Persister } from "@tanstack/react-query-persist-client";
+export interface PersistOptions {
+    maxAge?: number;
+    onlyPersistSuccess?: boolean;
+    dehydrateOptions?: {
+        shouldDehydrateQuery?: (query: Query) => boolean;
+    };
+}
+export declare function createPersistOptions(config?: Partial<PersistOptions>): {
+    maxAge: number;
+    dehydrateOptions?: {
+        shouldDehydrateQuery?: (query: Query) => boolean;
+    };
+};
+export declare function createPersister(storageKey?: string, storage?: Storage): Persister | undefined;
+export declare function clearCache(key?: string): void;
+export declare function clearExpiredCache(key?: string, maxAge?: number): void;
+export declare function migrateToIndexedDB(localStorageKey: string | undefined, indexedDBKey: string | undefined, indexedDBStorage: Storage | {
+    setItem: (key: string, value: string) => Promise<void>;
+}): Promise<boolean>;
+export declare function checkStorageSize(key?: string): {
+    sizeInBytes: number;
+    sizeInMB: number;
+    shouldMigrate: boolean;
+    message: string;
+};
+export declare function getStorageStats(key?: string): {
+    exists: boolean;
+    age?: number;
+    queriesCount?: number;
+    mutationsCount?: number;
+    sizeInfo: ReturnType<typeof checkStorageSize>;
+};
+export type { PersistedClient, Persister };
+//# sourceMappingURL=persistence.d.ts.map

package/dist/features/persistence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence.d.ts","sourceRoot":"","sources":["../../src/features/persistence.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAsBvF,MAAM,WAAW,cAAc;IAAG,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAAC,gBAAgB,CAAC,EAAE;QAAE,oBAAoB,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAA;KAAE,CAAA;CAAE;AAC1J,wBAAgB,oBAAoB,CAAC,MAAM,GAAE,OAAO,CAAC,cAAc,CAAM,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,gBAAgB,CAAC,EAAE;QAAE,oBAAoB,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAA;KAAE,CAAA;CAAE,CAiBtK;AACD,wBAAgB,eAAe,CAAC,UAAU,SAAyB,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,SAAS,CAa7G;AACD,wBAAgB,UAAU,CAAC,GAAG,SAAyB,GAAG,IAAI,CAA0D;AACxH,wBAAgB,iBAAiB,CAAC,GAAG,SAAyB,EAAE,MAAM,SAAsB,GAAG,IAAI,CAQlG;AACD,wBAAsB,kBAAkB,CAAC,eAAe,oBAAyB,EAAE,YAAY,oBAAyB,EAAE,gBAAgB,EAAE,OAAO,GAAG;IAAE,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAWlO;AACD,wBAAgB,gBAAgB,CAAC,GAAG,SAAyB,GAAG;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CASjJ;AACD,wBAAgB,eAAe,CAAC,GAAG,SAAyB,GAAG;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAA;CAAE,CAS9L;AACD,YAAY,EAAE,eAAe,EAAE,SAAS,EAAE,CAAC"}

package/dist/features/persistence.js

@@ -0,0 +1,175 @@
+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) {
+    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 { } },
+            restoreClient: async () => { try {
+                const raw = safeStorage.getItem(storageKey);
+                return raw ? JSON.parse(raw) : undefined;
+            }
+            catch {
+                return undefined;
+            } },
+            removeClient: async () => { try {
+                safeStorage.removeItem(storageKey);
+            }
+            catch { } }
+        };
+        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

@@ -0,0 +1,128 @@
+import type { QueryClient, UseQueryOptions, UseQueryResult, UseSuspenseQueryOptions, UseSuspenseQueryResult } 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;
+}): {
+    primaryResult: UseQueryResult<import("@tanstack/query-core").NoInfer<TPrimaryData>, Error>;
+    results: UseQueryResult<unknown, Error>[];
+    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

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