@tanstack/query-persist-client-core 5.92.1 → 5.92.4

package/build/legacy/_tsup-dts-rollup.d.cts

@@ -0,0 +1,246 @@
+import type { DehydratedState } from '@tanstack/query-core';
+import type { DehydrateOptions } from '@tanstack/query-core';
+import type { HydrateOptions } from '@tanstack/query-core';
+import { Options } from 'tsup';
+import type { Query } from '@tanstack/query-core';
+import type { QueryClient } from '@tanstack/query-core';
+import type { QueryFilters } from '@tanstack/query-core';
+import type { QueryFunctionContext } from '@tanstack/query-core';
+import type { QueryKey } from '@tanstack/query-core';
+import type { QueryState } from '@tanstack/query-core';
+import { UserConfig } from 'vite';
+
+declare interface AsyncStorage<TStorageValue = string> {
+    getItem: (key: string) => MaybePromise<TStorageValue | undefined | null>;
+    setItem: (key: string, value: TStorageValue) => MaybePromise<unknown>;
+    removeItem: (key: string) => MaybePromise<void>;
+    entries?: () => MaybePromise<Array<[key: string, value: TStorageValue]>>;
+}
+export { AsyncStorage }
+export { AsyncStorage as AsyncStorage_alias_1 }
+
+export declare function createMockPersister(): Persister;
+
+export declare function createSpyPersister(): Persister;
+
+export declare const default_alias: any[];
+
+export declare const default_alias_1: any[];
+
+export declare const default_alias_2: Options | Options[] | ((overrideOptions: Options) => Options | Options[] | Promise<Options | Options[]>);
+
+export declare const default_alias_3: UserConfig;
+
+/**
+ * Warning: experimental feature.
+ * This utility function enables fine-grained query persistence.
+ * Simple add it as a `persister` parameter to `useQuery` or `defaultOptions` on `queryClient`.
+ *
+ * ```
+ * useQuery({
+ queryKey: ['myKey'],
+ queryFn: fetcher,
+ persister: createPersister({
+ storage: localStorage,
+ }),
+ })
+ ```
+ */
+declare function experimental_createQueryPersister<TStorageValue = string>({ storage, buster, maxAge, serialize, deserialize, prefix, refetchOnRestore, filters, }: StoragePersisterOptions<TStorageValue>): {
+    persisterFn: <T, TQueryKey extends QueryKey>(queryFn: (context: QueryFunctionContext<TQueryKey>) => T | Promise<T>, ctx: QueryFunctionContext<TQueryKey>, query: Query) => Promise<T>;
+    persistQuery: (query: Query) => Promise<void>;
+    persistQueryByKey: (queryKey: QueryKey, queryClient: QueryClient) => Promise<void>;
+    retrieveQuery: <T>(queryHash: string, afterRestoreMacroTask?: (persistedQuery: PersistedQuery) => void) => Promise<T | undefined>;
+    persisterGc: () => Promise<void>;
+    restoreQueries: (queryClient: QueryClient, filters?: Pick<QueryFilters, "queryKey" | "exact">) => Promise<void>;
+    removeQueries: (filters?: Pick<QueryFilters, "queryKey" | "exact">) => Promise<void>;
+};
+export { experimental_createQueryPersister }
+export { experimental_createQueryPersister as experimental_createQueryPersister_alias_1 }
+
+/**
+ * @param {Object} opts - Options for building configurations.
+ * @param {string[]} opts.entry - The entry array.
+ * @returns {import('tsup').Options}
+ */
+export declare function legacyConfig(opts: {
+    entry: string[];
+}): Options;
+
+declare type MaybePromise<T> = T | Promise<T>;
+export { MaybePromise }
+export { MaybePromise as MaybePromise_alias_1 }
+
+/**
+ * @param {Object} opts - Options for building configurations.
+ * @param {string[]} opts.entry - The entry array.
+ * @returns {import('tsup').Options}
+ */
+export declare function modernConfig(opts: {
+    entry: string[];
+}): Options;
+
+declare interface PersistedClient {
+    timestamp: number;
+    buster: string;
+    clientState: DehydratedState;
+}
+export { PersistedClient }
+export { PersistedClient as PersistedClient_alias_1 }
+
+declare interface PersistedQuery {
+    buster: string;
+    queryHash: string;
+    queryKey: QueryKey;
+    state: QueryState;
+}
+export { PersistedQuery }
+export { PersistedQuery as PersistedQuery_alias_1 }
+
+declare interface PersistedQueryClientRestoreOptions extends PersistQueryClientRootOptions {
+    /** The max-allowed age of the cache in milliseconds.
+     * If a persisted cache is found that is older than this
+     * time, it will be discarded */
+    maxAge?: number;
+    /** The options passed to the hydrate function */
+    hydrateOptions?: HydrateOptions;
+}
+export { PersistedQueryClientRestoreOptions }
+export { PersistedQueryClientRestoreOptions as PersistedQueryClientRestoreOptions_alias_1 }
+
+declare interface PersistedQueryClientSaveOptions extends PersistQueryClientRootOptions {
+    /** The options passed to the dehydrate function */
+    dehydrateOptions?: DehydrateOptions;
+}
+export { PersistedQueryClientSaveOptions }
+export { PersistedQueryClientSaveOptions as PersistedQueryClientSaveOptions_alias_1 }
+
+declare interface Persister {
+    persistClient: (persistClient: PersistedClient) => Promisable<void>;
+    restoreClient: () => Promisable<PersistedClient | undefined>;
+    removeClient: () => Promisable<void>;
+}
+export { Persister }
+export { Persister as Persister_alias_1 }
+
+declare const PERSISTER_KEY_PREFIX = "tanstack-query";
+export { PERSISTER_KEY_PREFIX }
+export { PERSISTER_KEY_PREFIX as PERSISTER_KEY_PREFIX_alias_1 }
+
+/**
+ * Restores persisted data to QueryCache and persists further changes.
+ */
+declare function persistQueryClient(props: PersistQueryClientOptions): [() => void, Promise<void>];
+export { persistQueryClient }
+export { persistQueryClient as persistQueryClient_alias_1 }
+
+declare interface PersistQueryClientOptions extends PersistedQueryClientRestoreOptions, PersistedQueryClientSaveOptions, PersistQueryClientRootOptions {
+}
+export { PersistQueryClientOptions }
+export { PersistQueryClientOptions as PersistQueryClientOptions_alias_1 }
+
+/**
+ * Restores persisted data to the QueryCache
+ *  - data obtained from persister.restoreClient
+ *  - data is hydrated using hydrateOptions
+ * If data is expired, busted, empty, or throws, it runs persister.removeClient
+ */
+declare function persistQueryClientRestore({ queryClient, persister, maxAge, buster, hydrateOptions, }: PersistedQueryClientRestoreOptions): Promise<void>;
+export { persistQueryClientRestore }
+export { persistQueryClientRestore as persistQueryClientRestore_alias_1 }
+
+declare interface PersistQueryClientRootOptions {
+    /** The QueryClient to persist */
+    queryClient: QueryClient;
+    /** The Persister interface for storing and restoring the cache
+     * to/from a persisted location */
+    persister: Persister;
+    /** A unique string that can be used to forcefully
+     * invalidate existing caches if they do not share the same buster string */
+    buster?: string;
+}
+export { PersistQueryClientRootOptions }
+export { PersistQueryClientRootOptions as PersistQueryClientRootOptions_alias_1 }
+
+/**
+ * Persists data from the QueryCache
+ *  - data dehydrated using dehydrateOptions
+ *  - data is persisted using persister.persistClient
+ */
+declare function persistQueryClientSave({ queryClient, persister, buster, dehydrateOptions, }: PersistedQueryClientSaveOptions): Promise<void>;
+export { persistQueryClientSave }
+export { persistQueryClientSave as persistQueryClientSave_alias_1 }
+
+/**
+ * Subscribe to QueryCache and MutationCache updates (for persisting)
+ * @returns an unsubscribe function (to discontinue monitoring)
+ */
+declare function persistQueryClientSubscribe(props: PersistedQueryClientSaveOptions): () => void;
+export { persistQueryClientSubscribe }
+export { persistQueryClientSubscribe as persistQueryClientSubscribe_alias_1 }
+
+declare type PersistRetryer = (props: {
+    persistedClient: PersistedClient;
+    error: Error;
+    errorCount: number;
+}) => PersistedClient | undefined;
+export { PersistRetryer }
+export { PersistRetryer as PersistRetryer_alias_1 }
+
+declare type Promisable<T> = T | PromiseLike<T>;
+export { Promisable }
+export { Promisable as Promisable_alias_1 }
+
+declare const removeOldestQuery: PersistRetryer;
+export { removeOldestQuery }
+export { removeOldestQuery as removeOldestQuery_alias_1 }
+
+declare interface StoragePersisterOptions<TStorageValue = string> {
+    /** The storage client used for setting and retrieving items from cache.
+     * For SSR pass in `undefined`.
+     */
+    storage: AsyncStorage<TStorageValue> | undefined | null;
+    /**
+     * How to serialize the data to storage.
+     * @default `JSON.stringify`
+     */
+    serialize?: (persistedQuery: PersistedQuery) => MaybePromise<TStorageValue>;
+    /**
+     * How to deserialize the data from storage.
+     * @default `JSON.parse`
+     */
+    deserialize?: (cachedString: TStorageValue) => MaybePromise<PersistedQuery>;
+    /**
+     * A unique string that can be used to forcefully invalidate existing caches,
+     * if they do not share the same buster string
+     */
+    buster?: string;
+    /**
+     * The max-allowed age of the cache in milliseconds.
+     * If a persisted cache is found that is older than this
+     * time, it will be discarded
+     * @default 24 hours
+     */
+    maxAge?: number;
+    /**
+     * Prefix to be used for storage key.
+     * Storage key is a combination of prefix and query hash in a form of `prefix-queryHash`.
+     * @default 'tanstack-query'
+     */
+    prefix?: string;
+    /**
+     * If set to `true`, the query will refetch on successful query restoration if the data is stale.
+     * If set to `false`, the query will not refetch on successful query restoration.
+     * If set to `'always'`, the query will always refetch on successful query restoration.
+     * Defaults to `true`.
+     */
+    refetchOnRestore?: boolean | 'always';
+    /**
+     * Filters to narrow down which Queries should be persisted.
+     */
+    filters?: QueryFilters;
+}
+export { StoragePersisterOptions }
+export { StoragePersisterOptions as StoragePersisterOptions_alias_1 }
+
+export { }

package/build/legacy/_tsup-dts-rollup.d.ts

@@ -0,0 +1,246 @@
+import type { DehydratedState } from '@tanstack/query-core';
+import type { DehydrateOptions } from '@tanstack/query-core';
+import type { HydrateOptions } from '@tanstack/query-core';
+import { Options } from 'tsup';
+import type { Query } from '@tanstack/query-core';
+import type { QueryClient } from '@tanstack/query-core';
+import type { QueryFilters } from '@tanstack/query-core';
+import type { QueryFunctionContext } from '@tanstack/query-core';
+import type { QueryKey } from '@tanstack/query-core';
+import type { QueryState } from '@tanstack/query-core';
+import { UserConfig } from 'vite';
+
+declare interface AsyncStorage<TStorageValue = string> {
+    getItem: (key: string) => MaybePromise<TStorageValue | undefined | null>;
+    setItem: (key: string, value: TStorageValue) => MaybePromise<unknown>;
+    removeItem: (key: string) => MaybePromise<void>;
+    entries?: () => MaybePromise<Array<[key: string, value: TStorageValue]>>;
+}
+export { AsyncStorage }
+export { AsyncStorage as AsyncStorage_alias_1 }
+
+export declare function createMockPersister(): Persister;
+
+export declare function createSpyPersister(): Persister;
+
+export declare const default_alias: any[];
+
+export declare const default_alias_1: any[];
+
+export declare const default_alias_2: Options | Options[] | ((overrideOptions: Options) => Options | Options[] | Promise<Options | Options[]>);
+
+export declare const default_alias_3: UserConfig;
+
+/**
+ * Warning: experimental feature.
+ * This utility function enables fine-grained query persistence.
+ * Simple add it as a `persister` parameter to `useQuery` or `defaultOptions` on `queryClient`.
+ *
+ * ```
+ * useQuery({
+ queryKey: ['myKey'],
+ queryFn: fetcher,
+ persister: createPersister({
+ storage: localStorage,
+ }),
+ })
+ ```
+ */
+declare function experimental_createQueryPersister<TStorageValue = string>({ storage, buster, maxAge, serialize, deserialize, prefix, refetchOnRestore, filters, }: StoragePersisterOptions<TStorageValue>): {
+    persisterFn: <T, TQueryKey extends QueryKey>(queryFn: (context: QueryFunctionContext<TQueryKey>) => T | Promise<T>, ctx: QueryFunctionContext<TQueryKey>, query: Query) => Promise<T>;
+    persistQuery: (query: Query) => Promise<void>;
+    persistQueryByKey: (queryKey: QueryKey, queryClient: QueryClient) => Promise<void>;
+    retrieveQuery: <T>(queryHash: string, afterRestoreMacroTask?: (persistedQuery: PersistedQuery) => void) => Promise<T | undefined>;
+    persisterGc: () => Promise<void>;
+    restoreQueries: (queryClient: QueryClient, filters?: Pick<QueryFilters, "queryKey" | "exact">) => Promise<void>;
+    removeQueries: (filters?: Pick<QueryFilters, "queryKey" | "exact">) => Promise<void>;
+};
+export { experimental_createQueryPersister }
+export { experimental_createQueryPersister as experimental_createQueryPersister_alias_1 }
+
+/**
+ * @param {Object} opts - Options for building configurations.
+ * @param {string[]} opts.entry - The entry array.
+ * @returns {import('tsup').Options}
+ */
+export declare function legacyConfig(opts: {
+    entry: string[];
+}): Options;
+
+declare type MaybePromise<T> = T | Promise<T>;
+export { MaybePromise }
+export { MaybePromise as MaybePromise_alias_1 }
+
+/**
+ * @param {Object} opts - Options for building configurations.
+ * @param {string[]} opts.entry - The entry array.
+ * @returns {import('tsup').Options}
+ */
+export declare function modernConfig(opts: {
+    entry: string[];
+}): Options;
+
+declare interface PersistedClient {
+    timestamp: number;
+    buster: string;
+    clientState: DehydratedState;
+}
+export { PersistedClient }
+export { PersistedClient as PersistedClient_alias_1 }
+
+declare interface PersistedQuery {
+    buster: string;
+    queryHash: string;
+    queryKey: QueryKey;
+    state: QueryState;
+}
+export { PersistedQuery }
+export { PersistedQuery as PersistedQuery_alias_1 }
+
+declare interface PersistedQueryClientRestoreOptions extends PersistQueryClientRootOptions {
+    /** The max-allowed age of the cache in milliseconds.
+     * If a persisted cache is found that is older than this
+     * time, it will be discarded */
+    maxAge?: number;
+    /** The options passed to the hydrate function */
+    hydrateOptions?: HydrateOptions;
+}
+export { PersistedQueryClientRestoreOptions }
+export { PersistedQueryClientRestoreOptions as PersistedQueryClientRestoreOptions_alias_1 }
+
+declare interface PersistedQueryClientSaveOptions extends PersistQueryClientRootOptions {
+    /** The options passed to the dehydrate function */
+    dehydrateOptions?: DehydrateOptions;
+}
+export { PersistedQueryClientSaveOptions }
+export { PersistedQueryClientSaveOptions as PersistedQueryClientSaveOptions_alias_1 }
+
+declare interface Persister {
+    persistClient: (persistClient: PersistedClient) => Promisable<void>;
+    restoreClient: () => Promisable<PersistedClient | undefined>;
+    removeClient: () => Promisable<void>;
+}
+export { Persister }
+export { Persister as Persister_alias_1 }
+
+declare const PERSISTER_KEY_PREFIX = "tanstack-query";
+export { PERSISTER_KEY_PREFIX }
+export { PERSISTER_KEY_PREFIX as PERSISTER_KEY_PREFIX_alias_1 }
+
+/**
+ * Restores persisted data to QueryCache and persists further changes.
+ */
+declare function persistQueryClient(props: PersistQueryClientOptions): [() => void, Promise<void>];
+export { persistQueryClient }
+export { persistQueryClient as persistQueryClient_alias_1 }
+
+declare interface PersistQueryClientOptions extends PersistedQueryClientRestoreOptions, PersistedQueryClientSaveOptions, PersistQueryClientRootOptions {
+}
+export { PersistQueryClientOptions }
+export { PersistQueryClientOptions as PersistQueryClientOptions_alias_1 }
+
+/**
+ * Restores persisted data to the QueryCache
+ *  - data obtained from persister.restoreClient
+ *  - data is hydrated using hydrateOptions
+ * If data is expired, busted, empty, or throws, it runs persister.removeClient
+ */
+declare function persistQueryClientRestore({ queryClient, persister, maxAge, buster, hydrateOptions, }: PersistedQueryClientRestoreOptions): Promise<void>;
+export { persistQueryClientRestore }
+export { persistQueryClientRestore as persistQueryClientRestore_alias_1 }
+
+declare interface PersistQueryClientRootOptions {
+    /** The QueryClient to persist */
+    queryClient: QueryClient;
+    /** The Persister interface for storing and restoring the cache
+     * to/from a persisted location */
+    persister: Persister;
+    /** A unique string that can be used to forcefully
+     * invalidate existing caches if they do not share the same buster string */
+    buster?: string;
+}
+export { PersistQueryClientRootOptions }
+export { PersistQueryClientRootOptions as PersistQueryClientRootOptions_alias_1 }
+
+/**
+ * Persists data from the QueryCache
+ *  - data dehydrated using dehydrateOptions
+ *  - data is persisted using persister.persistClient
+ */
+declare function persistQueryClientSave({ queryClient, persister, buster, dehydrateOptions, }: PersistedQueryClientSaveOptions): Promise<void>;
+export { persistQueryClientSave }
+export { persistQueryClientSave as persistQueryClientSave_alias_1 }
+
+/**
+ * Subscribe to QueryCache and MutationCache updates (for persisting)
+ * @returns an unsubscribe function (to discontinue monitoring)
+ */
+declare function persistQueryClientSubscribe(props: PersistedQueryClientSaveOptions): () => void;
+export { persistQueryClientSubscribe }
+export { persistQueryClientSubscribe as persistQueryClientSubscribe_alias_1 }
+
+declare type PersistRetryer = (props: {
+    persistedClient: PersistedClient;
+    error: Error;
+    errorCount: number;
+}) => PersistedClient | undefined;
+export { PersistRetryer }
+export { PersistRetryer as PersistRetryer_alias_1 }
+
+declare type Promisable<T> = T | PromiseLike<T>;
+export { Promisable }
+export { Promisable as Promisable_alias_1 }
+
+declare const removeOldestQuery: PersistRetryer;
+export { removeOldestQuery }
+export { removeOldestQuery as removeOldestQuery_alias_1 }
+
+declare interface StoragePersisterOptions<TStorageValue = string> {
+    /** The storage client used for setting and retrieving items from cache.
+     * For SSR pass in `undefined`.
+     */
+    storage: AsyncStorage<TStorageValue> | undefined | null;
+    /**
+     * How to serialize the data to storage.
+     * @default `JSON.stringify`
+     */
+    serialize?: (persistedQuery: PersistedQuery) => MaybePromise<TStorageValue>;
+    /**
+     * How to deserialize the data from storage.
+     * @default `JSON.parse`
+     */
+    deserialize?: (cachedString: TStorageValue) => MaybePromise<PersistedQuery>;
+    /**
+     * A unique string that can be used to forcefully invalidate existing caches,
+     * if they do not share the same buster string
+     */
+    buster?: string;
+    /**
+     * The max-allowed age of the cache in milliseconds.
+     * If a persisted cache is found that is older than this
+     * time, it will be discarded
+     * @default 24 hours
+     */
+    maxAge?: number;
+    /**
+     * Prefix to be used for storage key.
+     * Storage key is a combination of prefix and query hash in a form of `prefix-queryHash`.
+     * @default 'tanstack-query'
+     */
+    prefix?: string;
+    /**
+     * If set to `true`, the query will refetch on successful query restoration if the data is stale.
+     * If set to `false`, the query will not refetch on successful query restoration.
+     * If set to `'always'`, the query will always refetch on successful query restoration.
+     * Defaults to `true`.
+     */
+    refetchOnRestore?: boolean | 'always';
+    /**
+     * Filters to narrow down which Queries should be persisted.
+     */
+    filters?: QueryFilters;
+}
+export { StoragePersisterOptions }
+export { StoragePersisterOptions as StoragePersisterOptions_alias_1 }
+
+export { }

package/build/legacy/createPersister.d.cts

@@ -1,87 +1,6 @@
-import { QueryKey, QueryState, QueryFilters, QueryFunctionContext, Query, QueryClient } from '@tanstack/query-core';
-
-interface PersistedQuery {
-    buster: string;
-    queryHash: string;
-    queryKey: QueryKey;
-    state: QueryState;
-}
-type MaybePromise<T> = T | Promise<T>;
-interface AsyncStorage<TStorageValue = string> {
-    getItem: (key: string) => MaybePromise<TStorageValue | undefined | null>;
-    setItem: (key: string, value: TStorageValue) => MaybePromise<unknown>;
-    removeItem: (key: string) => MaybePromise<void>;
-    entries?: () => MaybePromise<Array<[key: string, value: TStorageValue]>>;
-}
-interface StoragePersisterOptions<TStorageValue = string> {
-    /** The storage client used for setting and retrieving items from cache.
-     * For SSR pass in `undefined`.
-     */
-    storage: AsyncStorage<TStorageValue> | undefined | null;
-    /**
-     * How to serialize the data to storage.
-     * @default `JSON.stringify`
-     */
-    serialize?: (persistedQuery: PersistedQuery) => MaybePromise<TStorageValue>;
-    /**
-     * How to deserialize the data from storage.
-     * @default `JSON.parse`
-     */
-    deserialize?: (cachedString: TStorageValue) => MaybePromise<PersistedQuery>;
-    /**
-     * A unique string that can be used to forcefully invalidate existing caches,
-     * if they do not share the same buster string
-     */
-    buster?: string;
-    /**
-     * The max-allowed age of the cache in milliseconds.
-     * If a persisted cache is found that is older than this
-     * time, it will be discarded
-     * @default 24 hours
-     */
-    maxAge?: number;
-    /**
-     * Prefix to be used for storage key.
-     * Storage key is a combination of prefix and query hash in a form of `prefix-queryHash`.
-     * @default 'tanstack-query'
-     */
-    prefix?: string;
-    /**
-     * If set to `true`, the query will refetch on successful query restoration if the data is stale.
-     * If set to `false`, the query will not refetch on successful query restoration.
-     * If set to `'always'`, the query will always refetch on successful query restoration.
-     * Defaults to `true`.
-     */
-    refetchOnRestore?: boolean | 'always';
-    /**
-     * Filters to narrow down which Queries should be persisted.
-     */
-    filters?: QueryFilters;
-}
-declare const PERSISTER_KEY_PREFIX = "tanstack-query";
-/**
- * Warning: experimental feature.
- * This utility function enables fine-grained query persistence.
- * Simple add it as a `persister` parameter to `useQuery` or `defaultOptions` on `queryClient`.
- *
- * ```
- * useQuery({
-     queryKey: ['myKey'],
-     queryFn: fetcher,
-     persister: createPersister({
-       storage: localStorage,
-     }),
-   })
-   ```
- */
-declare function experimental_createQueryPersister<TStorageValue = string>({ storage, buster, maxAge, serialize, deserialize, prefix, refetchOnRestore, filters, }: StoragePersisterOptions<TStorageValue>): {
-    persisterFn: <T, TQueryKey extends QueryKey>(queryFn: (context: QueryFunctionContext<TQueryKey>) => T | Promise<T>, ctx: QueryFunctionContext<TQueryKey>, query: Query) => Promise<T>;
-    persistQuery: (query: Query) => Promise<void>;
-    persistQueryByKey: (queryKey: QueryKey, queryClient: QueryClient) => Promise<void>;
-    retrieveQuery: <T>(queryHash: string, afterRestoreMacroTask?: (persistedQuery: PersistedQuery) => void) => Promise<T | undefined>;
-    persisterGc: () => Promise<void>;
-    restoreQueries: (queryClient: QueryClient, filters?: Pick<QueryFilters, "queryKey" | "exact">) => Promise<void>;
-    removeQueries: (filters?: Pick<QueryFilters, "queryKey" | "exact">) => Promise<void>;
-};
-
-export { type AsyncStorage, type MaybePromise, PERSISTER_KEY_PREFIX, type PersistedQuery, type StoragePersisterOptions, experimental_createQueryPersister };
+export { experimental_createQueryPersister } from './_tsup-dts-rollup.cjs';
+export { PersistedQuery } from './_tsup-dts-rollup.cjs';
+export { MaybePromise } from './_tsup-dts-rollup.cjs';
+export { AsyncStorage } from './_tsup-dts-rollup.cjs';
+export { StoragePersisterOptions } from './_tsup-dts-rollup.cjs';
+export { PERSISTER_KEY_PREFIX } from './_tsup-dts-rollup.cjs';

package/build/legacy/createPersister.d.ts

@@ -1,87 +1,6 @@
-import { QueryKey, QueryState, QueryFilters, QueryFunctionContext, Query, QueryClient } from '@tanstack/query-core';
-
-interface PersistedQuery {
-    buster: string;
-    queryHash: string;
-    queryKey: QueryKey;
-    state: QueryState;
-}
-type MaybePromise<T> = T | Promise<T>;
-interface AsyncStorage<TStorageValue = string> {
-    getItem: (key: string) => MaybePromise<TStorageValue | undefined | null>;
-    setItem: (key: string, value: TStorageValue) => MaybePromise<unknown>;
-    removeItem: (key: string) => MaybePromise<void>;
-    entries?: () => MaybePromise<Array<[key: string, value: TStorageValue]>>;
-}
-interface StoragePersisterOptions<TStorageValue = string> {
-    /** The storage client used for setting and retrieving items from cache.
-     * For SSR pass in `undefined`.
-     */
-    storage: AsyncStorage<TStorageValue> | undefined | null;
-    /**
-     * How to serialize the data to storage.
-     * @default `JSON.stringify`
-     */
-    serialize?: (persistedQuery: PersistedQuery) => MaybePromise<TStorageValue>;
-    /**
-     * How to deserialize the data from storage.
-     * @default `JSON.parse`
-     */
-    deserialize?: (cachedString: TStorageValue) => MaybePromise<PersistedQuery>;
-    /**
-     * A unique string that can be used to forcefully invalidate existing caches,
-     * if they do not share the same buster string
-     */
-    buster?: string;
-    /**
-     * The max-allowed age of the cache in milliseconds.
-     * If a persisted cache is found that is older than this
-     * time, it will be discarded
-     * @default 24 hours
-     */
-    maxAge?: number;
-    /**
-     * Prefix to be used for storage key.
-     * Storage key is a combination of prefix and query hash in a form of `prefix-queryHash`.
-     * @default 'tanstack-query'
-     */
-    prefix?: string;
-    /**
-     * If set to `true`, the query will refetch on successful query restoration if the data is stale.
-     * If set to `false`, the query will not refetch on successful query restoration.
-     * If set to `'always'`, the query will always refetch on successful query restoration.
-     * Defaults to `true`.
-     */
-    refetchOnRestore?: boolean | 'always';
-    /**
-     * Filters to narrow down which Queries should be persisted.
-     */
-    filters?: QueryFilters;
-}
-declare const PERSISTER_KEY_PREFIX = "tanstack-query";
-/**
- * Warning: experimental feature.
- * This utility function enables fine-grained query persistence.
- * Simple add it as a `persister` parameter to `useQuery` or `defaultOptions` on `queryClient`.
- *
- * ```
- * useQuery({
-     queryKey: ['myKey'],
-     queryFn: fetcher,
-     persister: createPersister({
-       storage: localStorage,
-     }),
-   })
-   ```
- */
-declare function experimental_createQueryPersister<TStorageValue = string>({ storage, buster, maxAge, serialize, deserialize, prefix, refetchOnRestore, filters, }: StoragePersisterOptions<TStorageValue>): {
-    persisterFn: <T, TQueryKey extends QueryKey>(queryFn: (context: QueryFunctionContext<TQueryKey>) => T | Promise<T>, ctx: QueryFunctionContext<TQueryKey>, query: Query) => Promise<T>;
-    persistQuery: (query: Query) => Promise<void>;
-    persistQueryByKey: (queryKey: QueryKey, queryClient: QueryClient) => Promise<void>;
-    retrieveQuery: <T>(queryHash: string, afterRestoreMacroTask?: (persistedQuery: PersistedQuery) => void) => Promise<T | undefined>;
-    persisterGc: () => Promise<void>;
-    restoreQueries: (queryClient: QueryClient, filters?: Pick<QueryFilters, "queryKey" | "exact">) => Promise<void>;
-    removeQueries: (filters?: Pick<QueryFilters, "queryKey" | "exact">) => Promise<void>;
-};
-
-export { type AsyncStorage, type MaybePromise, PERSISTER_KEY_PREFIX, type PersistedQuery, type StoragePersisterOptions, experimental_createQueryPersister };
+export { experimental_createQueryPersister } from './_tsup-dts-rollup.js';
+export { PersistedQuery } from './_tsup-dts-rollup.js';
+export { MaybePromise } from './_tsup-dts-rollup.js';
+export { AsyncStorage } from './_tsup-dts-rollup.js';
+export { StoragePersisterOptions } from './_tsup-dts-rollup.js';
+export { PERSISTER_KEY_PREFIX } from './_tsup-dts-rollup.js';