@qiaopeng/tanstack-query-plus 0.5.9 → 0.5.10

package/dist/persistence-tIrEb0pR.d.ts

@@ -0,0 +1,216 @@
+import { QueryKey } from '@tanstack/react-query';
+import { S as StorageType } from './base-CHnwqfyz.js';
+
+type Selector<TInput, TOutput> = (data: TInput | undefined) => TOutput;
+type EntityWithId<T = string | number> = {
+    id: T;
+    [key: string]: unknown;
+};
+type PaginatedData<T> = {
+    items: T[];
+    total?: number;
+    [key: string]: unknown;
+};
+
+interface OptimisticUpdateConfig<TData = unknown, TVariables = unknown> {
+    queryKey: QueryKey;
+    updater: (oldData: TData | undefined, variables: TVariables) => TData | undefined;
+    rollback?: (previousData: TData, error: Error) => void;
+    enabled?: boolean;
+}
+interface OptimisticContext<TData = unknown> {
+    previousData?: TData;
+    timestamp: number;
+    operationType: OptimisticOperationTypeValue;
+}
+declare const OptimisticOperationType: {
+    readonly CREATE: "create";
+    readonly UPDATE: "update";
+    readonly DELETE: "delete";
+    readonly BATCH: "batch";
+};
+type OptimisticOperationTypeValue = (typeof OptimisticOperationType)[keyof typeof OptimisticOperationType];
+interface ListOperationConfig<T extends EntityWithId> {
+    queryKey: QueryKey;
+    operation: ListOperationType;
+    onRollback?: (error: Error, context: OptimisticContext<T[]>) => void;
+}
+declare enum ListOperationType {
+    ADD = "add",
+    UPDATE = "update",
+    REMOVE = "remove"
+}
+interface BatchQueryResult<TData = unknown, TError = Error> {
+    data: TData | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: TError | null;
+    status: "pending" | "error" | "success";
+}
+type OptimisticUpdater<TData = unknown, TVariables = unknown> = (oldData: TData | undefined, variables: TVariables) => TData;
+type RollbackFunction<TData = unknown> = (previousData: TData, error: Error) => void;
+type ListUpdater<T extends EntityWithId> = {
+    add: (items: T[] | undefined, newItem: T) => T[];
+    update: (items: T[] | undefined, updatedItem: Partial<T> & {
+        id: T["id"];
+    }) => T[];
+    remove: (items: T[] | undefined, itemId: T["id"]) => T[];
+};
+interface OptimisticGlobalConfig {
+    enabledByDefault: boolean;
+    defaultRollbackDelay: number;
+    debugMode: boolean;
+    maxRetries: number;
+}
+interface BatchQueryStats {
+    total: number;
+    loading: number;
+    success: number;
+    error: number;
+    stale: number;
+    successRate: number;
+    errorRate: number;
+}
+interface BatchQueryConfig<TData = unknown, TError = Error> {
+    enableStats?: boolean;
+    enableBatchOperations?: boolean;
+    autoRefreshInterval?: number;
+    onBatchSuccess?: (results: TData[]) => void;
+    onBatchError?: (errors: TError[]) => void;
+    onBatchSettled?: (results: TData[], errors: TError[]) => void;
+    retryConfig?: BatchRetryConfig;
+    enablePartialSuccess?: boolean;
+    onPartialSuccess?: (report: BatchOperationReport<TData, TError>) => void;
+}
+interface BatchRetryConfig {
+    maxRetries?: number;
+    retryDelay?: number | ((attemptIndex: number) => number);
+    retryOnlyFailed?: boolean;
+    shouldRetry?: (error: Error, attemptCount: number) => boolean;
+}
+interface BatchOperationReport<TData = unknown, TError = Error> {
+    total: number;
+    successful: number;
+    failed: number;
+    successResults: Array<{
+        index: number;
+        data: TData;
+    }>;
+    failureErrors: Array<{
+        index: number;
+        error: TError;
+        queryKey?: unknown[];
+    }>;
+    isPartialSuccess: boolean;
+    isFullSuccess: boolean;
+    isFullFailure: boolean;
+    duration: number;
+    retryCount?: number;
+}
+interface BatchErrorAggregate<TError = Error> {
+    totalErrors: number;
+    errors: Array<{
+        index: number;
+        error: TError;
+        queryKey?: unknown[];
+    }>;
+    errorsByType: Map<string, TError[]>;
+    firstError: TError | null;
+    lastError: TError | null;
+    errorSummary: string;
+}
+interface BatchQueryOperations {
+    refetchAll: () => Promise<PromiseSettledResult<unknown>[]>;
+    invalidateAll: () => Promise<PromiseSettledResult<void>[]>;
+    cancelAll: () => Promise<PromiseSettledResult<void>[]>;
+    resetAll: () => Promise<PromiseSettledResult<void>[]>;
+    removeAll: () => void;
+    retryFailed: () => Promise<BatchOperationReport>;
+    getErrorAggregate: () => BatchErrorAggregate;
+    getOperationReport: () => BatchOperationReport;
+}
+interface EnhancedBatchQueryResult<TData = unknown, TCombinedResult = TData, TError = Error> {
+    data: TCombinedResult;
+    stats: BatchQueryStats;
+    operations: BatchQueryOperations;
+    config: BatchQueryConfig<TData, TError>;
+}
+
+/**
+ * 数据防护策略类型
+ */
+type DataGuardStrategy = "version" | "timestamp" | "hash" | "none";
+/**
+ * 带版本控制的实体基础接口
+ */
+interface VersionedEntity {
+    id: string | number;
+    version?: number;
+    updatedAt?: string;
+}
+/**
+ * 带版本控制的分页响应
+ */
+interface VersionedPaginatedResponse<T> {
+    items: T[];
+    total: number;
+    page?: number;
+    pageSize?: number;
+    version?: number;
+    updatedAt?: string;
+    _hash?: string;
+    _recentlyUpdatedIds?: Array<string | number> | Set<string | number>;
+}
+/**
+ * 旧数据检测信息
+ */
+interface StaleDataInfo {
+    reason: string;
+    strategy: DataGuardStrategy;
+    queryKey: QueryKey;
+    cached: any;
+    rejected: any;
+}
+/**
+ * 数据防护应用信息
+ */
+interface DataGuardInfo {
+    strategy: DataGuardStrategy;
+    passed: boolean;
+    details: any;
+}
+/**
+ * 数据防护配置选项
+ */
+interface DataGuardOptions {
+    /** 时间戳模式下，最大接受的数据年龄（毫秒），默认 10000 */
+    maxDataAge?: number;
+    /** 启用版本号检查，默认 true */
+    enableVersionCheck?: boolean;
+    /** 启用时间戳检查，默认 true */
+    enableTimestampCheck?: boolean;
+    /** 启用哈希检查（兜底），默认 true */
+    enableHashCheck?: boolean;
+    /** 检测到旧数据时的回调 */
+    onStaleDataDetected?: (info: StaleDataInfo) => void;
+    /** 应用防护时的回调 */
+    onDataGuardApplied?: (info: DataGuardInfo) => void;
+}
+/**
+ * 冲突错误类
+ */
+declare class ConflictError extends Error {
+    details: any;
+    constructor(details: any);
+}
+
+interface StorageInfo {
+    type: StorageType;
+    used: number;
+    total: number;
+    usage: number;
+    available: boolean;
+    error?: string;
+}
+
+export { type BatchQueryResult as B, ConflictError as C, type DataGuardStrategy as D, type EnhancedBatchQueryResult as E, type ListOperationConfig as L, type OptimisticUpdateConfig as O, type PaginatedData as P, type RollbackFunction as R, type StaleDataInfo as S, type VersionedEntity as V, type VersionedPaginatedResponse as a, type DataGuardInfo as b, type DataGuardOptions as c, type OptimisticContext as d, OptimisticOperationType as e, type OptimisticOperationTypeValue as f, ListOperationType as g, type OptimisticUpdater as h, type ListUpdater as i, type OptimisticGlobalConfig as j, type BatchQueryStats as k, type BatchQueryConfig as l, type BatchRetryConfig as m, type BatchOperationReport as n, type BatchErrorAggregate as o, type BatchQueryOperations as p, type StorageInfo as q, type Selector as r, type EntityWithId as s };

package/dist/react-query/index.cjs

@@ -0,0 +1,52 @@
+'use strict';
+
+var reactQuery = require('@tanstack/react-query');
+
+
+
+Object.defineProperty(exports, "QueryClient", {
+  enumerable: true,
+  get: function () { return reactQuery.QueryClient; }
+});
+Object.defineProperty(exports, "QueryClientProvider", {
+  enumerable: true,
+  get: function () { return reactQuery.QueryClientProvider; }
+});
+Object.defineProperty(exports, "skipToken", {
+  enumerable: true,
+  get: function () { return reactQuery.skipToken; }
+});
+Object.defineProperty(exports, "useInfiniteQuery", {
+  enumerable: true,
+  get: function () { return reactQuery.useInfiniteQuery; }
+});
+Object.defineProperty(exports, "useIsFetching", {
+  enumerable: true,
+  get: function () { return reactQuery.useIsFetching; }
+});
+Object.defineProperty(exports, "useIsMutating", {
+  enumerable: true,
+  get: function () { return reactQuery.useIsMutating; }
+});
+Object.defineProperty(exports, "useMutation", {
+  enumerable: true,
+  get: function () { return reactQuery.useMutation; }
+});
+Object.defineProperty(exports, "useQuery", {
+  enumerable: true,
+  get: function () { return reactQuery.useQuery; }
+});
+Object.defineProperty(exports, "useQueryClient", {
+  enumerable: true,
+  get: function () { return reactQuery.useQueryClient; }
+});
+Object.defineProperty(exports, "useSuspenseInfiniteQuery", {
+  enumerable: true,
+  get: function () { return reactQuery.useSuspenseInfiniteQuery; }
+});
+Object.defineProperty(exports, "useSuspenseQuery", {
+  enumerable: true,
+  get: function () { return reactQuery.useSuspenseQuery; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/react-query/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs","sourcesContent":[]}

package/dist/react-query/index.d.cts

@@ -0,0 +1 @@
+export { DefaultError, InfiniteData, MutationKey, QueryClient, QueryClientProvider, QueryKey, UseInfiniteQueryOptions, UseInfiniteQueryResult, UseMutationResult, UseQueryOptions, UseQueryResult, UseSuspenseQueryOptions, skipToken, useInfiniteQuery, useIsFetching, useIsMutating, useMutation, useQuery, useQueryClient, useSuspenseInfiniteQuery, useSuspenseQuery } from '@tanstack/react-query';

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

@@ -1,3 +1 @@
-export { QueryClient, QueryClientProvider, useQueryClient, skipToken, useIsMutating, useIsFetching, useQuery, useInfiniteQuery, useMutation, useSuspenseQuery, useSuspenseInfiniteQuery } from "@tanstack/react-query";
-export type { UseQueryOptions, UseSuspenseQueryOptions, UseInfiniteQueryOptions, QueryKey, MutationKey, InfiniteData, UseQueryResult, UseInfiniteQueryResult, UseMutationResult, DefaultError } from "@tanstack/react-query";
-//# sourceMappingURL=index.d.ts.map
+export { DefaultError, InfiniteData, MutationKey, QueryClient, QueryClientProvider, QueryKey, UseInfiniteQueryOptions, UseInfiniteQueryResult, UseMutationResult, UseQueryOptions, UseQueryResult, UseSuspenseQueryOptions, skipToken, useInfiniteQuery, useIsFetching, useIsMutating, useMutation, useQuery, useQueryClient, useSuspenseInfiniteQuery, useSuspenseQuery } from '@tanstack/react-query';

package/dist/react-query/index.js

@@ -1 +1,3 @@
-export { QueryClient, QueryClientProvider, useQueryClient, skipToken, useIsMutating, useIsFetching, useQuery, useInfiniteQuery, useMutation, useSuspenseQuery, useSuspenseInfiniteQuery } from "@tanstack/react-query";
+export { QueryClient, QueryClientProvider, skipToken, useInfiniteQuery, useIsFetching, useIsMutating, useMutation, useQuery, useQueryClient, useSuspenseInfiniteQuery, useSuspenseQuery } from '@tanstack/react-query';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/react-query/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js","sourcesContent":[]}

package/dist/types/index.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+var chunkBK3OTIBD_cjs = require('../chunk-BK3OTIBD.cjs');
+var chunkUVF5S6LX_cjs = require('../chunk-UVF5S6LX.cjs');
+var chunk5J6OXSLW_cjs = require('../chunk-5J6OXSLW.cjs');
+var chunkYW5PNTRU_cjs = require('../chunk-YW5PNTRU.cjs');
+
+
+
+Object.defineProperty(exports, "MutationOperationType", {
+  enumerable: true,
+  get: function () { return chunkBK3OTIBD_cjs.MutationOperationType; }
+});
+Object.defineProperty(exports, "ListOperationType", {
+  enumerable: true,
+  get: function () { return chunkUVF5S6LX_cjs.ListOperationType; }
+});
+Object.defineProperty(exports, "OptimisticOperationType", {
+  enumerable: true,
+  get: function () { return chunkUVF5S6LX_cjs.OptimisticOperationType; }
+});
+Object.defineProperty(exports, "CachePriority", {
+  enumerable: true,
+  get: function () { return chunk5J6OXSLW_cjs.CachePriority; }
+});
+Object.defineProperty(exports, "ConnectionQuality", {
+  enumerable: true,
+  get: function () { return chunk5J6OXSLW_cjs.ConnectionQuality; }
+});
+Object.defineProperty(exports, "PersistenceStrategyType", {
+  enumerable: true,
+  get: function () { return chunk5J6OXSLW_cjs.PersistenceStrategyType; }
+});
+Object.defineProperty(exports, "StorageType", {
+  enumerable: true,
+  get: function () { return chunk5J6OXSLW_cjs.StorageType; }
+});
+Object.defineProperty(exports, "ConflictError", {
+  enumerable: true,
+  get: function () { return chunkYW5PNTRU_cjs.ConflictError; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/types/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/dist/types/index.d.cts

@@ -0,0 +1,157 @@
+import { QueryKey, UseSuspenseQueryOptions, UseSuspenseInfiniteQueryOptions, UseSuspenseQueryResult, UseSuspenseInfiniteQueryResult, InfiniteData, UseMutationOptions } from '@tanstack/react-query';
+export { QueryClient } from '@tanstack/react-query';
+export { a as CachePriority, C as ConnectionQuality, D as DeepReadonly, N as NetworkInformation, b as NetworkStatus, O as OperationResult, c as Optional, P as PersistenceStrategyType, R as Required, S as StorageType } from '../base-CHnwqfyz.cjs';
+export { o as BatchErrorAggregate, n as BatchOperationReport, l as BatchQueryConfig, p as BatchQueryOperations, B as BatchQueryResult, k as BatchQueryStats, m as BatchRetryConfig, C as ConflictError, b as DataGuardInfo, c as DataGuardOptions, D as DataGuardStrategy, E as EnhancedBatchQueryResult, s as EntityWithId, L as ListOperationConfig, g as ListOperationType, i as ListUpdater, d as OptimisticContext, j as OptimisticGlobalConfig, e as OptimisticOperationType, f as OptimisticOperationTypeValue, O as OptimisticUpdateConfig, h as OptimisticUpdater, P as PaginatedData, R as RollbackFunction, r as Selector, S as StaleDataInfo, q as StorageInfo, V as VersionedEntity, a as VersionedPaginatedResponse } from '../persistence-MRtkmhqq.cjs';
+export { d as MutationFunctionRegistry, M as MutationOperationType, e as OfflineManagerConfig, b as OfflineMutationOperation, h as OfflineMutationOptions, a as OfflineQueryInfo, g as OfflineQueryOptions, c as OfflineQueueConfig, O as OfflineRecoveryConfig, f as OfflineState } from '../offline-xxeA_-6V.cjs';
+import { ReactNode } from 'react';
+export { PersistedClient, Persister } from '@tanstack/react-query-persist-client';
+
+interface CursorPaginatedResponse<T> {
+    items: T[];
+    cursor?: string | null;
+    hasMore?: boolean;
+}
+interface OffsetPaginatedResponse<T> {
+    items: T[];
+    offset: number;
+    limit: number;
+    total: number;
+    hasMore?: boolean;
+}
+interface PageNumberPaginatedResponse<T> {
+    items: T[];
+    page: number;
+    pageSize: number;
+    totalPages: number;
+    totalItems: number;
+}
+interface PaginationParams {
+    cursor?: string;
+    offset?: number;
+    page?: number;
+    limit?: number;
+    pageSize?: number;
+}
+interface PaginationMeta {
+    currentPage?: number;
+    totalPages?: number;
+    totalItems?: number;
+    pageSize?: number;
+    hasNextPage?: boolean;
+    hasPreviousPage?: boolean;
+}
+interface PaginatedResponseWithMeta<T> {
+    items: T[];
+    meta: PaginationMeta;
+}
+
+interface EnhancedSuspenseQueryOptions<TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends Omit<UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, "queryKey" | "queryFn"> {
+    enableAutoRefresh?: boolean;
+    refreshInterval?: number;
+}
+interface EnhancedSuspenseInfiniteQueryOptions<TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends Omit<UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, "queryKey" | "queryFn"> {
+    enableAutoRefresh?: boolean;
+    refreshInterval?: number;
+}
+type SuspenseQueryFunction<TQueryFnData = unknown, TQueryKey extends QueryKey = QueryKey> = (context: {
+    queryKey: TQueryKey;
+    signal: AbortSignal;
+}) => Promise<TQueryFnData>;
+type SuspenseInfiniteQueryFunction<TQueryFnData = unknown, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = (context: {
+    queryKey: TQueryKey;
+    signal: AbortSignal;
+    pageParam: TPageParam;
+}) => Promise<TQueryFnData>;
+type EnhancedSuspenseQueryResult<TData = unknown, TError = Error> = UseSuspenseQueryResult<TData, TError>;
+type EnhancedSuspenseInfiniteQueryResult<TData = unknown, TError = Error> = UseSuspenseInfiniteQueryResult<InfiniteData<TData>, TError>;
+interface SuspenseWrapperProps {
+    children: ReactNode;
+    fallback?: ReactNode;
+    errorFallback?: (error: Error, resetErrorBoundary: () => void) => ReactNode;
+    onError?: (error: Error, errorInfo: {
+        componentStack: string;
+    }) => void;
+    resetKeys?: Array<string | number>;
+}
+interface ErrorBoundaryProps {
+    children: ReactNode;
+    fallback?: (error: Error, resetErrorBoundary: () => void) => ReactNode;
+    onError?: (error: Error, errorInfo: {
+        componentStack: string;
+    }) => void;
+    onReset?: () => void;
+    resetKeys?: Array<string | number>;
+}
+interface ErrorBoundaryState {
+    hasError: boolean;
+    error?: Error;
+}
+interface LoadingFallbackProps {
+    message?: string;
+    size?: "small" | "medium" | "large";
+    className?: string;
+}
+interface ErrorFallbackProps {
+    error: Error;
+    resetErrorBoundary: () => void;
+    className?: string;
+}
+interface SuspenseConfig {
+    defaultStaleTime?: number;
+    defaultGcTime?: number;
+    defaultRetry?: number | boolean;
+    enableDevtools?: boolean;
+}
+type QueryStatus = "pending" | "error" | "success";
+interface QueryMetadata {
+    queryKey: QueryKey;
+    status: QueryStatus;
+    lastUpdated?: Date;
+    errorCount?: number;
+}
+
+interface MutationContext<TData = unknown, TContext = unknown> {
+    /** Snapshots of all query variants (from getQueriesData) */
+    previousData?: Array<[QueryKey, any]>;
+    /** User-provided context from onMutate */
+    userContext?: TContext;
+    /** For conditional mutations */
+    conditionMet?: boolean;
+}
+/**
+ * Enhanced mutation options using official TanStack Query approach
+ *
+ * Uses setQueriesData to update all cached query variants automatically.
+ * This prevents data rollback and flicker when switching between pageSize, filters, etc.
+ *
+ * Recommended: Use long staleTime (5+ minutes) in your queries for best results.
+ */
+interface MutationOptions<TData, TError, TVariables, TContext = unknown> extends UseMutationOptions<TData, TError, TVariables, TContext> {
+    optimistic?: {
+        /** Query key to update (will also update all variants in the same family) */
+        queryKey: QueryKey;
+        /** Function to update the cached data - will be applied to all query variants */
+        updater: <TQueryData = unknown>(oldData: TQueryData | undefined, variables: TVariables) => TQueryData | undefined;
+        /** Enable/disable optimistic updates */
+        enabled?: boolean;
+        /** Map mutation variable fields to cache data fields */
+        fieldMapping?: Record<string, string>;
+        /** Callback when rollback occurs on error */
+        rollback?: <TQueryData = unknown>(previousData: TQueryData, error: Error) => void;
+        /**
+         * Invalidation scope after success:
+         * - "exact": Only invalidate the exact queryKey
+         * - "family": Invalidate all queries in the family (default for list queries)
+         * - "none": Don't invalidate (rely on optimistic update only)
+         */
+        invalidateScope?: "none" | "exact" | "family";
+        /** Override the derived family key (e.g., ['products', 'list']) */
+        familyKey?: QueryKey;
+        /** Additional query keys to invalidate */
+        relatedKeys?: QueryKey[];
+        /** Alias for relatedKeys */
+        invalidates?: QueryKey[];
+    };
+}
+
+export type { CursorPaginatedResponse, EnhancedSuspenseInfiniteQueryOptions, EnhancedSuspenseInfiniteQueryResult, EnhancedSuspenseQueryOptions, EnhancedSuspenseQueryResult, ErrorBoundaryProps, ErrorBoundaryState, ErrorFallbackProps, LoadingFallbackProps, MutationContext, MutationOptions, OffsetPaginatedResponse, PageNumberPaginatedResponse, PaginatedResponseWithMeta, PaginationMeta, PaginationParams, QueryMetadata, QueryStatus, SuspenseConfig, SuspenseInfiniteQueryFunction, SuspenseQueryFunction, SuspenseWrapperProps };

package/dist/types/index.d.ts

@@ -1,13 +1,116 @@
-import type { QueryKey, UseMutationOptions } from "@tanstack/react-query";
-export * from "./base.js";
-export * from "./dataGuard.js";
-export * from "./infinite.js";
-export * from "./offline.js";
-export * from "./optimistic.js";
-export * from "./persistence.js";
-export * from "./selectors.js";
-export * from "./suspense.js";
-export interface MutationContext<TData = unknown, TContext = unknown> {
+import { QueryKey, UseSuspenseQueryOptions, UseSuspenseInfiniteQueryOptions, UseSuspenseQueryResult, UseSuspenseInfiniteQueryResult, InfiniteData, UseMutationOptions } from '@tanstack/react-query';
+export { QueryClient } from '@tanstack/react-query';
+export { a as CachePriority, C as ConnectionQuality, D as DeepReadonly, N as NetworkInformation, b as NetworkStatus, O as OperationResult, c as Optional, P as PersistenceStrategyType, R as Required, S as StorageType } from '../base-CHnwqfyz.js';
+export { o as BatchErrorAggregate, n as BatchOperationReport, l as BatchQueryConfig, p as BatchQueryOperations, B as BatchQueryResult, k as BatchQueryStats, m as BatchRetryConfig, C as ConflictError, b as DataGuardInfo, c as DataGuardOptions, D as DataGuardStrategy, E as EnhancedBatchQueryResult, s as EntityWithId, L as ListOperationConfig, g as ListOperationType, i as ListUpdater, d as OptimisticContext, j as OptimisticGlobalConfig, e as OptimisticOperationType, f as OptimisticOperationTypeValue, O as OptimisticUpdateConfig, h as OptimisticUpdater, P as PaginatedData, R as RollbackFunction, r as Selector, S as StaleDataInfo, q as StorageInfo, V as VersionedEntity, a as VersionedPaginatedResponse } from '../persistence-tIrEb0pR.js';
+export { d as MutationFunctionRegistry, M as MutationOperationType, e as OfflineManagerConfig, b as OfflineMutationOperation, h as OfflineMutationOptions, a as OfflineQueryInfo, g as OfflineQueryOptions, c as OfflineQueueConfig, O as OfflineRecoveryConfig, f as OfflineState } from '../offline-DVPtgoAS.js';
+import { ReactNode } from 'react';
+export { PersistedClient, Persister } from '@tanstack/react-query-persist-client';
+
+interface CursorPaginatedResponse<T> {
+    items: T[];
+    cursor?: string | null;
+    hasMore?: boolean;
+}
+interface OffsetPaginatedResponse<T> {
+    items: T[];
+    offset: number;
+    limit: number;
+    total: number;
+    hasMore?: boolean;
+}
+interface PageNumberPaginatedResponse<T> {
+    items: T[];
+    page: number;
+    pageSize: number;
+    totalPages: number;
+    totalItems: number;
+}
+interface PaginationParams {
+    cursor?: string;
+    offset?: number;
+    page?: number;
+    limit?: number;
+    pageSize?: number;
+}
+interface PaginationMeta {
+    currentPage?: number;
+    totalPages?: number;
+    totalItems?: number;
+    pageSize?: number;
+    hasNextPage?: boolean;
+    hasPreviousPage?: boolean;
+}
+interface PaginatedResponseWithMeta<T> {
+    items: T[];
+    meta: PaginationMeta;
+}
+
+interface EnhancedSuspenseQueryOptions<TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends Omit<UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, "queryKey" | "queryFn"> {
+    enableAutoRefresh?: boolean;
+    refreshInterval?: number;
+}
+interface EnhancedSuspenseInfiniteQueryOptions<TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends Omit<UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, "queryKey" | "queryFn"> {
+    enableAutoRefresh?: boolean;
+    refreshInterval?: number;
+}
+type SuspenseQueryFunction<TQueryFnData = unknown, TQueryKey extends QueryKey = QueryKey> = (context: {
+    queryKey: TQueryKey;
+    signal: AbortSignal;
+}) => Promise<TQueryFnData>;
+type SuspenseInfiniteQueryFunction<TQueryFnData = unknown, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = (context: {
+    queryKey: TQueryKey;
+    signal: AbortSignal;
+    pageParam: TPageParam;
+}) => Promise<TQueryFnData>;
+type EnhancedSuspenseQueryResult<TData = unknown, TError = Error> = UseSuspenseQueryResult<TData, TError>;
+type EnhancedSuspenseInfiniteQueryResult<TData = unknown, TError = Error> = UseSuspenseInfiniteQueryResult<InfiniteData<TData>, TError>;
+interface SuspenseWrapperProps {
+    children: ReactNode;
+    fallback?: ReactNode;
+    errorFallback?: (error: Error, resetErrorBoundary: () => void) => ReactNode;
+    onError?: (error: Error, errorInfo: {
+        componentStack: string;
+    }) => void;
+    resetKeys?: Array<string | number>;
+}
+interface ErrorBoundaryProps {
+    children: ReactNode;
+    fallback?: (error: Error, resetErrorBoundary: () => void) => ReactNode;
+    onError?: (error: Error, errorInfo: {
+        componentStack: string;
+    }) => void;
+    onReset?: () => void;
+    resetKeys?: Array<string | number>;
+}
+interface ErrorBoundaryState {
+    hasError: boolean;
+    error?: Error;
+}
+interface LoadingFallbackProps {
+    message?: string;
+    size?: "small" | "medium" | "large";
+    className?: string;
+}
+interface ErrorFallbackProps {
+    error: Error;
+    resetErrorBoundary: () => void;
+    className?: string;
+}
+interface SuspenseConfig {
+    defaultStaleTime?: number;
+    defaultGcTime?: number;
+    defaultRetry?: number | boolean;
+    enableDevtools?: boolean;
+}
+type QueryStatus = "pending" | "error" | "success";
+interface QueryMetadata {
+    queryKey: QueryKey;
+    status: QueryStatus;
+    lastUpdated?: Date;
+    errorCount?: number;
+}
+
+interface MutationContext<TData = unknown, TContext = unknown> {
     /** Snapshots of all query variants (from getQueriesData) */
     previousData?: Array<[QueryKey, any]>;
     /** User-provided context from onMutate */
@@ -23,7 +126,7 @@ export interface MutationContext<TData = unknown, TContext = unknown> {
  *
  * Recommended: Use long staleTime (5+ minutes) in your queries for best results.
  */
-export interface MutationOptions<TData, TError, TVariables, TContext = unknown> extends UseMutationOptions<TData, TError, TVariables, TContext> {
+interface MutationOptions<TData, TError, TVariables, TContext = unknown> extends UseMutationOptions<TData, TError, TVariables, TContext> {
     optimistic?: {
         /** Query key to update (will also update all variants in the same family) */
         queryKey: QueryKey;
@@ -50,4 +153,5 @@ export interface MutationOptions<TData, TError, TVariables, TContext = unknown>
         invalidates?: QueryKey[];
     };
 }
-//# sourceMappingURL=index.d.ts.map
+
+export type { CursorPaginatedResponse, EnhancedSuspenseInfiniteQueryOptions, EnhancedSuspenseInfiniteQueryResult, EnhancedSuspenseQueryOptions, EnhancedSuspenseQueryResult, ErrorBoundaryProps, ErrorBoundaryState, ErrorFallbackProps, LoadingFallbackProps, MutationContext, MutationOptions, OffsetPaginatedResponse, PageNumberPaginatedResponse, PaginatedResponseWithMeta, PaginationMeta, PaginationParams, QueryMetadata, QueryStatus, SuspenseConfig, SuspenseInfiniteQueryFunction, SuspenseQueryFunction, SuspenseWrapperProps };

package/dist/types/index.js

@@ -1,8 +1,6 @@
-export * from "./base.js";
-export * from "./dataGuard.js";
-export * from "./infinite.js";
-export * from "./offline.js";
-export * from "./optimistic.js";
-export * from "./persistence.js";
-export * from "./selectors.js";
-export * from "./suspense.js";
+export { MutationOperationType } from '../chunk-BYAOQALW.js';
+export { ListOperationType, OptimisticOperationType } from '../chunk-ZNXSWUIS.js';
+export { CachePriority, ConnectionQuality, PersistenceStrategyType, StorageType } from '../chunk-LHEHSLD5.js';
+export { ConflictError } from '../chunk-HRO2DWKZ.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}