@tanstack/query-core 5.107.0 → 5.107.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/build/legacy/{hydration-BIRJt69T.d.cts → hydration-24GwbSaU.d.cts} +3178 -3178
- package/build/legacy/hydration-24GwbSaU.d.cts.map +1 -0
- package/build/legacy/{hydration-9_kOYxJM.d.ts → hydration-Cbq_heQS.d.ts} +3178 -3178
- package/build/legacy/hydration-Cbq_heQS.d.ts.map +1 -0
- package/build/legacy/hydration.cjs.map +1 -1
- package/build/legacy/hydration.d.cts +1 -1
- package/build/legacy/hydration.d.ts +1 -1
- package/build/legacy/hydration.js.map +1 -1
- package/build/legacy/index.cjs.map +1 -1
- package/build/legacy/index.d.cts +2 -2
- package/build/legacy/index.d.ts +2 -2
- package/build/legacy/index.js.map +1 -1
- package/build/legacy/infiniteQueryBehavior.cjs.map +1 -1
- package/build/legacy/infiniteQueryBehavior.d.cts +1 -1
- package/build/legacy/infiniteQueryBehavior.d.ts +1 -1
- package/build/legacy/infiniteQueryBehavior.js.map +1 -1
- package/build/legacy/infiniteQueryObserver.cjs.map +1 -1
- package/build/legacy/infiniteQueryObserver.d.cts +1 -1
- package/build/legacy/infiniteQueryObserver.d.ts +1 -1
- package/build/legacy/infiniteQueryObserver.js.map +1 -1
- package/build/legacy/mutation.cjs +1 -1
- package/build/legacy/mutation.cjs.map +1 -1
- package/build/legacy/mutation.d.cts +1 -1
- package/build/legacy/mutation.d.ts +1 -1
- package/build/legacy/mutation.js +1 -1
- package/build/legacy/mutation.js.map +1 -1
- package/build/legacy/mutationCache.cjs.map +1 -1
- package/build/legacy/mutationCache.d.cts +1 -1
- package/build/legacy/mutationCache.d.ts +1 -1
- package/build/legacy/mutationCache.js.map +1 -1
- package/build/legacy/mutationObserver.cjs.map +1 -1
- package/build/legacy/mutationObserver.d.cts +1 -1
- package/build/legacy/mutationObserver.d.ts +1 -1
- package/build/legacy/mutationObserver.js.map +1 -1
- package/build/legacy/queriesObserver.cjs.map +1 -1
- package/build/legacy/queriesObserver.d.cts +1 -1
- package/build/legacy/queriesObserver.d.ts +1 -1
- package/build/legacy/queriesObserver.js.map +1 -1
- package/build/legacy/query.cjs +6 -4
- package/build/legacy/query.cjs.map +1 -1
- package/build/legacy/query.d.cts +1 -1
- package/build/legacy/query.d.ts +1 -1
- package/build/legacy/query.js +6 -4
- package/build/legacy/query.js.map +1 -1
- package/build/legacy/queryCache.cjs.map +1 -1
- package/build/legacy/queryCache.d.cts +1 -1
- package/build/legacy/queryCache.d.ts +1 -1
- package/build/legacy/queryCache.js.map +1 -1
- package/build/legacy/queryClient.cjs.map +1 -1
- package/build/legacy/queryClient.d.cts +1 -1
- package/build/legacy/queryClient.d.ts +1 -1
- package/build/legacy/queryClient.js.map +1 -1
- package/build/legacy/queryObserver.cjs.map +1 -1
- package/build/legacy/queryObserver.d.cts +1 -1
- package/build/legacy/queryObserver.d.ts +1 -1
- package/build/legacy/queryObserver.js.map +1 -1
- package/build/legacy/removable.cjs.map +1 -1
- package/build/legacy/removable.js.map +1 -1
- package/build/legacy/retryer.cjs.map +1 -1
- package/build/legacy/retryer.d.cts +1 -1
- package/build/legacy/retryer.d.ts +1 -1
- package/build/legacy/retryer.js.map +1 -1
- package/build/legacy/streamedQuery.cjs.map +1 -1
- package/build/legacy/streamedQuery.d.cts +1 -1
- package/build/legacy/streamedQuery.d.ts +1 -1
- package/build/legacy/streamedQuery.js.map +1 -1
- package/build/legacy/subscribable-D2lAzdDi.d.cts.map +1 -1
- package/build/legacy/subscribable-D2lAzdDi.d.ts.map +1 -1
- package/build/legacy/subscribable.cjs.map +1 -1
- package/build/legacy/subscribable.js.map +1 -1
- package/build/legacy/types.cjs.map +1 -1
- package/build/legacy/types.d.cts +1 -1
- package/build/legacy/types.d.ts +1 -1
- package/build/legacy/types.js.map +1 -1
- package/build/legacy/utils.cjs.map +1 -1
- package/build/legacy/utils.d.cts +1 -1
- package/build/legacy/utils.d.ts +1 -1
- package/build/legacy/utils.js.map +1 -1
- package/build/modern/{hydration-BIRJt69T.d.cts → hydration-24GwbSaU.d.cts} +3178 -3178
- package/build/modern/hydration-24GwbSaU.d.cts.map +1 -0
- package/build/modern/{hydration-9_kOYxJM.d.ts → hydration-Cbq_heQS.d.ts} +3178 -3178
- package/build/modern/hydration-Cbq_heQS.d.ts.map +1 -0
- package/build/modern/hydration.cjs.map +1 -1
- package/build/modern/hydration.d.cts +1 -1
- package/build/modern/hydration.d.ts +1 -1
- package/build/modern/hydration.js.map +1 -1
- package/build/modern/index.cjs.map +1 -1
- package/build/modern/index.d.cts +2 -2
- package/build/modern/index.d.ts +2 -2
- package/build/modern/index.js.map +1 -1
- package/build/modern/infiniteQueryBehavior.cjs.map +1 -1
- package/build/modern/infiniteQueryBehavior.d.cts +1 -1
- package/build/modern/infiniteQueryBehavior.d.ts +1 -1
- package/build/modern/infiniteQueryBehavior.js.map +1 -1
- package/build/modern/infiniteQueryObserver.cjs.map +1 -1
- package/build/modern/infiniteQueryObserver.d.cts +1 -1
- package/build/modern/infiniteQueryObserver.d.ts +1 -1
- package/build/modern/infiniteQueryObserver.js.map +1 -1
- package/build/modern/mutation.cjs +1 -1
- package/build/modern/mutation.cjs.map +1 -1
- package/build/modern/mutation.d.cts +1 -1
- package/build/modern/mutation.d.ts +1 -1
- package/build/modern/mutation.js +1 -1
- package/build/modern/mutation.js.map +1 -1
- package/build/modern/mutationCache.cjs.map +1 -1
- package/build/modern/mutationCache.d.cts +1 -1
- package/build/modern/mutationCache.d.ts +1 -1
- package/build/modern/mutationCache.js.map +1 -1
- package/build/modern/mutationObserver.cjs.map +1 -1
- package/build/modern/mutationObserver.d.cts +1 -1
- package/build/modern/mutationObserver.d.ts +1 -1
- package/build/modern/mutationObserver.js.map +1 -1
- package/build/modern/queriesObserver.cjs.map +1 -1
- package/build/modern/queriesObserver.d.cts +1 -1
- package/build/modern/queriesObserver.d.ts +1 -1
- package/build/modern/queriesObserver.js.map +1 -1
- package/build/modern/query.cjs +6 -4
- package/build/modern/query.cjs.map +1 -1
- package/build/modern/query.d.cts +1 -1
- package/build/modern/query.d.ts +1 -1
- package/build/modern/query.js +6 -4
- package/build/modern/query.js.map +1 -1
- package/build/modern/queryCache.cjs.map +1 -1
- package/build/modern/queryCache.d.cts +1 -1
- package/build/modern/queryCache.d.ts +1 -1
- package/build/modern/queryCache.js.map +1 -1
- package/build/modern/queryClient.cjs.map +1 -1
- package/build/modern/queryClient.d.cts +1 -1
- package/build/modern/queryClient.d.ts +1 -1
- package/build/modern/queryClient.js.map +1 -1
- package/build/modern/queryObserver.cjs.map +1 -1
- package/build/modern/queryObserver.d.cts +1 -1
- package/build/modern/queryObserver.d.ts +1 -1
- package/build/modern/queryObserver.js.map +1 -1
- package/build/modern/removable.cjs.map +1 -1
- package/build/modern/removable.js.map +1 -1
- package/build/modern/retryer.cjs.map +1 -1
- package/build/modern/retryer.d.cts +1 -1
- package/build/modern/retryer.d.ts +1 -1
- package/build/modern/retryer.js.map +1 -1
- package/build/modern/streamedQuery.cjs.map +1 -1
- package/build/modern/streamedQuery.d.cts +1 -1
- package/build/modern/streamedQuery.d.ts +1 -1
- package/build/modern/streamedQuery.js.map +1 -1
- package/build/modern/subscribable-D2lAzdDi.d.cts.map +1 -1
- package/build/modern/subscribable-D2lAzdDi.d.ts.map +1 -1
- package/build/modern/subscribable.cjs.map +1 -1
- package/build/modern/subscribable.js.map +1 -1
- package/build/modern/types.cjs.map +1 -1
- package/build/modern/types.d.cts +1 -1
- package/build/modern/types.d.ts +1 -1
- package/build/modern/types.js.map +1 -1
- package/build/modern/utils.cjs.map +1 -1
- package/build/modern/utils.d.cts +1 -1
- package/build/modern/utils.d.ts +1 -1
- package/build/modern/utils.js.map +1 -1
- package/package.json +1 -1
- package/src/hydration.ts +3 -3
- package/src/index.ts +98 -1
- package/src/infiniteQueryBehavior.ts +1 -1
- package/src/infiniteQueryObserver.ts +3 -3
- package/src/mutation.ts +4 -4
- package/src/mutationCache.ts +4 -4
- package/src/mutationObserver.ts +1 -1
- package/src/queriesObserver.ts +1 -1
- package/src/query.ts +10 -8
- package/src/queryCache.ts +5 -5
- package/src/queryClient.ts +6 -6
- package/src/queryObserver.ts +3 -3
- package/src/removable.ts +1 -1
- package/src/retryer.ts +1 -1
- package/src/streamedQuery.ts +1 -1
- package/src/subscribable.ts +4 -1
- package/src/types.ts +57 -56
- package/src/utils.ts +2 -2
- package/build/legacy/hydration-9_kOYxJM.d.ts.map +0 -1
- package/build/legacy/hydration-BIRJt69T.d.cts.map +0 -1
- package/build/modern/hydration-9_kOYxJM.d.ts.map +0 -1
- package/build/modern/hydration-BIRJt69T.d.cts.map +0 -1
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"hydration-Cbq_heQS.d.ts","names":["FailedAction","SuccessAction","ErrorAction","PauseAction","ContinueAction","Action","Action"],"sources":["../../src/retryer.ts","../../src/utils.ts","../../src/types.ts","../../src/queryObserver.ts","../../src/query.ts","../../src/queryCache.ts","../../src/queryClient.ts","../../src/mutationObserver.ts","../../src/mutationCache.ts","../../src/mutation.ts","../../src/hydration.ts"],"mappings":"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"}
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"hydration.cjs","names":["noop"],"sources":["../../src/hydration.ts"],"sourcesContent":["import { noop } from './utils'\nimport type {\n DefaultError,\n MutationKey,\n MutationMeta,\n MutationOptions,\n MutationScope,\n QueryKey,\n QueryMeta,\n QueryOptions,\n} from './types'\nimport type { QueryClient } from './queryClient'\nimport type { Query, QueryState } from './query'\nimport type { Mutation, MutationState } from './mutation'\n\n// TYPES\ntype TransformerFn = (data: any) => any\n\n/**\n * Reads the value of a promise synchronously if it has already resolved, e.g. a thenable that\n * resolves within its `then` call.\n * @param promise - The promise to read.\n * @returns An object with the resolved `data`, or `undefined` if the promise hasn't resolved\n * synchronously (or resolved with `undefined`).\n */\nfunction tryResolveSync(promise: PromiseLike<unknown>) {\n let data: unknown\n\n const thenResult = promise.then((result) => {\n data = result\n return result\n }, noop) as Promise<unknown> | undefined\n\n // .catch can be unavailable on certain kinds of thenable's\n // oxlint-disable-next-line typescript/no-unnecessary-condition\n thenResult?.catch?.(noop)\n\n if (data !== undefined) {\n return { data }\n }\n\n return undefined\n}\n\n/**\n * Options for `dehydrate`, controlling which queries/mutations are included in the resulting `DehydratedState` and\n * how their data/errors are transformed before being serialized (e.g. for embedding in server-rendered markup).\n */\nexport interface DehydrateOptions {\n /** Transforms a query's `data` before it is dehydrated. Useful for non-JSON-serializable data. */\n serializeData?: TransformerFn\n /** Predicate to decide whether a given `Mutation` should be dehydrated. Defaults to `defaultShouldDehydrateMutation`. */\n shouldDehydrateMutation?: (mutation: Mutation) => boolean\n /** Predicate to decide whether a given `Query` should be dehydrated. Defaults to `defaultShouldDehydrateQuery`. */\n shouldDehydrateQuery?: (query: Query) => boolean\n /**\n * Predicate to decide whether a query's error should be redacted before dehydration. Errors are redacted\n * (replaced with a generic `Error('redacted')`) unless this function is provided and returns `false` for the\n * given error, in which case the original error is kept.\n */\n shouldRedactErrors?: (error: unknown) => boolean\n}\n\n/**\n * Options for `hydrate`, controlling the default options applied to queries/mutations restored from a\n * `DehydratedState`, and how to reverse any transformation applied by `DehydrateOptions.serializeData`.\n */\nexport interface HydrateOptions {\n /** Options applied to the queries and mutations restored from the dehydrated state. */\n defaultOptions?: {\n /** Transforms a query's `data` after it is read from the dehydrated state, reversing `serializeData`. */\n deserializeData?: TransformerFn\n /** Default options merged into every query restored from the dehydrated state. */\n queries?: QueryOptions\n /** Default options merged into every mutation restored from the dehydrated state. */\n mutations?: MutationOptions<unknown, DefaultError, unknown, unknown>\n }\n}\n\ninterface DehydratedMutation {\n mutationKey?: MutationKey\n state: MutationState\n meta?: MutationMeta\n scope?: MutationScope\n}\n\ninterface DehydratedQuery {\n queryHash: string\n queryKey: QueryKey\n state: QueryState\n dehydratedAt: number\n promise?: Promise<unknown>\n meta?: QueryMeta\n queryType?: 'infinite'\n}\n\n/**\n * A serializable snapshot of a `QueryClient`'s cache, as produced by `dehydrate` and consumed by `hydrate`. Typically\n * transported from server to client (e.g. embedded in server-rendered markup) to seed the client's cache with data\n * that has already been fetched, avoiding a redundant fetch on the client.\n */\nexport interface DehydratedState {\n /**\n * The dehydrated mutations, by default only the paused ones.\n */\n mutations: Array<DehydratedMutation>\n /**\n * The dehydrated queries, by default only the successful ones.\n */\n queries: Array<DehydratedQuery>\n}\n\n// FUNCTIONS\n\n/**\n * Dehydrates a single `Mutation` into a serializable snapshot of its key, state, scope, and meta.\n * @param mutation - The mutation to dehydrate.\n * @returns The dehydrated mutation.\n */\nfunction dehydrateMutation(mutation: Mutation): DehydratedMutation {\n return {\n mutationKey: mutation.options.mutationKey,\n state: mutation.state,\n ...(mutation.options.scope && { scope: mutation.options.scope }),\n ...(mutation.meta && { meta: mutation.meta }),\n }\n}\n\n/**\n * Prepares the in-flight promise of a pending query for dehydration: applies `serializeData` to its\n * result, and redacts its rejection error unless `shouldRedactErrors` returns `false` for it.\n * @param query - The pending query whose promise is dehydrated.\n * @param serializeData - Optional transform applied to the resolved data.\n * @param shouldRedactErrors - Optional predicate; if it returns `false` for the rejection error,\n * that\n * error is kept as-is instead of being redacted.\n * @returns The transformed promise, or `undefined` if the query has no in-flight promise.\n */\nfunction dehydratePromise(\n query: Query,\n serializeData?: TransformerFn,\n shouldRedactErrors?: (error: unknown) => boolean,\n): Promise<unknown> | undefined {\n const promise = query.promise?.then(serializeData).catch((error) => {\n if (shouldRedactErrors?.(error) === false) {\n // Reject original error if it should not be redacted\n return Promise.reject(error)\n }\n // If not in production, log original error before rejecting redacted error\n if (process.env.NODE_ENV !== 'production') {\n console.error(\n `A query that was dehydrated as pending ended up rejecting. [${query.queryHash}]: ${error}; The error will be redacted in production builds`,\n )\n }\n return Promise.reject(new Error('redacted'))\n })\n\n // Avoid unhandled promise rejections\n // We need the promise we dehydrate to reject to get the correct result into\n // the query cache, but we also want to avoid unhandled promise rejections\n // in whatever environment the prefetches are happening in.\n promise?.catch(noop)\n\n return promise\n}\n\n/**\n * Dehydrates a single `Query` into a serializable `DehydratedQuery` snapshot. Note that most query config (e.g.\n * `queryFn`, `staleTime`) is not dehydrated but instead meant to be configured again when consuming the\n * de/rehydrated data, typically with `useQuery` on the client. If the query is still `pending`, its in-flight\n * promise is dehydrated too so it can be resumed on the other side instead of re-fetched.\n * @param query - The query to dehydrate.\n * @param serializeData - Optional transform applied to `query.state.data` before it is included in the snapshot.\n * @param shouldRedactErrors - Optional predicate; if it returns `false` for the promise's rejection error, that\n * error is kept as-is instead of being redacted.\n * @returns The dehydrated query.\n */\nexport function dehydrateQuery(\n query: Query,\n serializeData?: TransformerFn,\n shouldRedactErrors?: (error: unknown) => boolean,\n): DehydratedQuery {\n return {\n dehydratedAt: Date.now(),\n state: {\n ...query.state,\n ...(query.state.data !== undefined && {\n data: serializeData\n ? serializeData(query.state.data)\n : query.state.data,\n }),\n },\n queryKey: query.queryKey,\n queryHash: query.queryHash,\n ...(query.state.status === 'pending' && {\n promise: dehydratePromise(query, serializeData, shouldRedactErrors),\n }),\n ...(query.meta && { meta: query.meta }),\n ...(query.queryType && { queryType: query.queryType }),\n }\n}\n\n/**\n * The default `shouldDehydrateMutation` predicate used by `dehydrate`. Only dehydrates mutations that are\n * currently paused (e.g. paused by `networkMode` while offline).\n * @param mutation - The mutation to check.\n * @returns `true` if the mutation is paused.\n */\nexport function defaultShouldDehydrateMutation(mutation: Mutation) {\n return mutation.state.isPaused\n}\n\n/**\n * The default `shouldDehydrateQuery` predicate used by `dehydrate`. Only dehydrates queries whose status is\n * `'success'`.\n * @param query - The query to check.\n * @returns `true` if the query's status is `'success'`.\n */\nexport function defaultShouldDehydrateQuery(query: Query) {\n return query.state.status === 'success'\n}\n\n/**\n * Dehydrates a `QueryClient`'s cache (queries and mutations) into a plain, serializable `DehydratedState`,\n * typically to embed in server-rendered markup and later restore into a client-side `QueryClient` via `hydrate`.\n * Which queries/mutations are included, and how their data/errors are transformed, is controlled by `options`,\n * falling back to the client's `dehydrate` default options, and finally to `defaultShouldDehydrateQuery` /\n * `defaultShouldDehydrateMutation`.\n * @param client - The client whose cache is dehydrated.\n * @param options - Controls which queries and mutations are included and how their data and errors\n * are transformed. Each option falls back to the client's `defaultOptions.dehydrate`.\n * @returns The dehydrated state, with the included `queries` and `mutations`.\n * @example\n * ```ts\n * const queryClient = new QueryClient()\n *\n * await queryClient.prefetchQuery({\n * queryKey: ['posts'],\n * queryFn: getPosts,\n * })\n *\n * const dehydratedState = dehydrate(queryClient)\n * ```\n */\nexport function dehydrate(\n client: QueryClient,\n options: DehydrateOptions = {},\n): DehydratedState {\n const filterMutation =\n options.shouldDehydrateMutation ??\n client.getDefaultOptions().dehydrate?.shouldDehydrateMutation ??\n defaultShouldDehydrateMutation\n\n const mutations = client\n .getMutationCache()\n .getAll()\n .flatMap((mutation) =>\n filterMutation(mutation) ? [dehydrateMutation(mutation)] : [],\n )\n\n const filterQuery =\n options.shouldDehydrateQuery ??\n client.getDefaultOptions().dehydrate?.shouldDehydrateQuery ??\n defaultShouldDehydrateQuery\n\n const shouldRedactErrors =\n options.shouldRedactErrors ??\n client.getDefaultOptions().dehydrate?.shouldRedactErrors\n\n const serializeData =\n options.serializeData ?? client.getDefaultOptions().dehydrate?.serializeData\n\n const queries = client\n .getQueryCache()\n .getAll()\n .flatMap((query) =>\n filterQuery(query)\n ? [dehydrateQuery(query, serializeData, shouldRedactErrors)]\n : [],\n )\n\n return { mutations, queries }\n}\n\n/**\n * Restores a `DehydratedState` (as produced by `dehydrate`) into a `QueryClient`'s cache, typically to seed the\n * client with data already fetched on the server. `mutations` and `queries` are each optional on `dehydratedState`.\n * Queries not yet in the cache are built from the dehydrated snapshot; queries that already exist are only updated\n * when the dehydrated data is newer than what's already cached. Newly built queries have their `fetchStatus` reset\n * to `'idle'` so they don't hydrate stuck in a fetching state. If a dehydrated query still had an in-flight\n * promise, it is resumed via `query.fetch()` (reusing that promise as `initialPromise`) rather than re-invoking\n * `queryFn`.\n * @param client - The client whose cache is restored into.\n * @param dehydratedState - The dehydrated state, e.g. produced by `dehydrate` on the server.\n * @param options - `defaultOptions` merged into every restored query and mutation (on top of the\n * client's `defaultOptions.hydrate`), and `deserializeData` to reverse `serializeData`.\n * @example\n * ```ts\n * // dehydratedState was produced by `dehydrate` on the server\n * // and sent to the client, e.g. embedded in server-rendered markup.\n * const queryClient = new QueryClient()\n *\n * hydrate(queryClient, dehydratedState)\n * ```\n */\nexport function hydrate(\n client: QueryClient,\n dehydratedState: Partial<DehydratedState>,\n options?: HydrateOptions,\n): void {\n const mutationCache = client.getMutationCache()\n const queryCache = client.getQueryCache()\n const deserializeData =\n options?.defaultOptions?.deserializeData ??\n client.getDefaultOptions().hydrate?.deserializeData\n\n dehydratedState.mutations?.forEach(({ state, ...mutationOptions }) => {\n mutationCache.build(\n client,\n {\n ...client.getDefaultOptions().hydrate?.mutations,\n ...options?.defaultOptions?.mutations,\n ...mutationOptions,\n },\n state,\n )\n })\n\n dehydratedState.queries?.forEach(\n ({\n queryKey,\n state,\n queryHash,\n meta,\n promise,\n dehydratedAt,\n queryType,\n }) => {\n const syncData = promise ? tryResolveSync(promise) : undefined\n const rawData = state.data === undefined ? syncData?.data : state.data\n const data =\n rawData === undefined\n ? rawData\n : deserializeData\n ? deserializeData(rawData)\n : rawData\n\n let query = queryCache.get(queryHash)\n const existingQueryIsPending = query?.state.status === 'pending'\n const existingQueryIsFetching = query?.state.fetchStatus === 'fetching'\n\n // Do not hydrate if an existing query exists with newer data\n if (query) {\n const hasNewerSyncData =\n syncData && dehydratedAt > query.state.dataUpdatedAt\n if (\n state.dataUpdatedAt > query.state.dataUpdatedAt ||\n hasNewerSyncData\n ) {\n // Omit fetchStatus from dehydrated state so that query stays in its current fetchStatus\n const { fetchStatus: _ignored, ...serializedState } = state\n query.setState({\n ...serializedState,\n data,\n // If the query was pending at the moment of dehydration, but resolved to have data\n // before hydration, we can assume the query should be hydrated as successful.\n //\n // Since you can opt into dehydrating failed queries, and those can have data from\n // previous successful fetches, we make sure we only do this for pending queries.\n ...(state.status === 'pending' &&\n data !== undefined && {\n status: 'success' as const,\n dataUpdatedAt: dehydratedAt,\n // Preserve existing fetchStatus if the existing query is actively fetching.\n ...(!existingQueryIsFetching && {\n fetchStatus: 'idle' as const,\n }),\n }),\n })\n }\n } else {\n // Restore query\n query = queryCache.build(\n client,\n {\n ...client.getDefaultOptions().hydrate?.queries,\n ...options?.defaultOptions?.queries,\n queryKey,\n queryHash,\n meta,\n _type: queryType,\n },\n // Reset fetch status to idle to avoid\n // query being stuck in fetching state upon hydration\n {\n ...state,\n data,\n fetchStatus: 'idle',\n // Like above, if the query was pending at the moment of dehydration but has data,\n // we can assume it should be hydrated as successful.\n status:\n state.status === 'pending' && data !== undefined\n ? 'success'\n : state.status,\n ...(state.status === 'pending' &&\n data !== undefined && {\n dataUpdatedAt: dehydratedAt,\n }),\n },\n )\n }\n\n if (\n promise &&\n // If the data was synchronously available, there is no need to set up\n // a retryer and thus no reason to call fetch\n !syncData &&\n !existingQueryIsPending &&\n !existingQueryIsFetching &&\n // Only hydrate if dehydration is newer than any existing data,\n // this is always true for new queries\n dehydratedAt > query.state.dataUpdatedAt\n ) {\n // This doesn't actually fetch - it just creates a retryer\n // which will re-use the passed `initialPromise`\n query\n .fetch(undefined, {\n // RSC transformed promises are not thenable\n initialPromise: Promise.resolve(promise).then(deserializeData),\n })\n // Avoid unhandled promise rejections\n .catch(noop)\n }\n },\n )\n}\n"],"mappings":";;;;;;;;;;AAyBA,SAAS,eAAe,SAA+B;CACrD,IAAI;CASJ,QAP2B,MAAM,WAAW;EAC1C,OAAO;EACP,OAAO;CACT,GAAGA,cAAAA,IAIM,CAAC,EAAE,QAAQA,cAAAA,IAAI;CAExB,IAAI,SAAS,KAAA,GACX,OAAO,EAAE,KAAK;AAIlB;;;;;;AA6EA,SAAS,kBAAkB,UAAwC;CACjE,OAAO;EACL,aAAa,SAAS,QAAQ;EAC9B,OAAO,SAAS;EAChB,GAAI,SAAS,QAAQ,SAAS,EAAE,OAAO,SAAS,QAAQ,MAAM;EAC9D,GAAI,SAAS,QAAQ,EAAE,MAAM,SAAS,KAAK;CAC7C;AACF;;;;;;;;;;;AAYA,SAAS,iBACP,OACA,eACA,oBAC8B;CAC9B,MAAM,UAAU,MAAM,SAAS,KAAK,aAAa,CAAC,CAAC,OAAO,UAAU;EAClE,IAAI,qBAAqB,KAAK,MAAM,OAElC,OAAO,QAAQ,OAAO,KAAK;EAG7B,IAAI,QAAQ,IAAI,aAAa,cAC3B,QAAQ,MACN,+DAA+D,MAAM,UAAU,KAAK,MAAM,kDAC5F;EAEF,OAAO,QAAQ,uBAAO,IAAI,MAAM,UAAU,CAAC;CAC7C,CAAC;CAMD,SAAS,MAAMA,cAAAA,IAAI;CAEnB,OAAO;AACT;;;;;;;;;;;;AAaA,SAAgB,eACd,OACA,eACA,oBACiB;CACjB,OAAO;EACL,cAAc,KAAK,IAAI;EACvB,OAAO;GACL,GAAG,MAAM;GACT,GAAI,MAAM,MAAM,SAAS,KAAA,KAAa,EACpC,MAAM,gBACF,cAAc,MAAM,MAAM,IAAI,IAC9B,MAAM,MAAM,KAClB;EACF;EACA,UAAU,MAAM;EAChB,WAAW,MAAM;EACjB,GAAI,MAAM,MAAM,WAAW,aAAa,EACtC,SAAS,iBAAiB,OAAO,eAAe,kBAAkB,EACpE;EACA,GAAI,MAAM,QAAQ,EAAE,MAAM,MAAM,KAAK;EACrC,GAAI,MAAM,aAAa,EAAE,WAAW,MAAM,UAAU;CACtD;AACF;;;;;;;AAQA,SAAgB,+BAA+B,UAAoB;CACjE,OAAO,SAAS,MAAM;AACxB;;;;;;;AAQA,SAAgB,4BAA4B,OAAc;CACxD,OAAO,MAAM,MAAM,WAAW;AAChC;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgB,UACd,QACA,UAA4B,CAAC,GACZ;CACjB,MAAM,iBACJ,QAAQ,2BACR,OAAO,kBAAkB,CAAC,CAAC,WAAW,2BACtC;CAEF,MAAM,YAAY,OACf,iBAAiB,CAAC,CAClB,OAAO,CAAC,CACR,SAAS,aACR,eAAe,QAAQ,IAAI,CAAC,kBAAkB,QAAQ,CAAC,IAAI,CAAC,CAC9D;CAEF,MAAM,cACJ,QAAQ,wBACR,OAAO,kBAAkB,CAAC,CAAC,WAAW,wBACtC;CAEF,MAAM,qBACJ,QAAQ,sBACR,OAAO,kBAAkB,CAAC,CAAC,WAAW;CAExC,MAAM,gBACJ,QAAQ,iBAAiB,OAAO,kBAAkB,CAAC,CAAC,WAAW;CAWjE,OAAO;EAAE;EAAW,SATJ,OACb,cAAc,CAAC,CACf,OAAO,CAAC,CACR,SAAS,UACR,YAAY,KAAK,IACb,CAAC,eAAe,OAAO,eAAe,kBAAkB,CAAC,IACzD,CAAC,CAGiB;CAAE;AAC9B;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,QACd,QACA,iBACA,SACM;CACN,MAAM,gBAAgB,OAAO,iBAAiB;CAC9C,MAAM,aAAa,OAAO,cAAc;CACxC,MAAM,kBACJ,SAAS,gBAAgB,mBACzB,OAAO,kBAAkB,CAAC,CAAC,SAAS;CAEtC,gBAAgB,WAAW,SAAS,EAAE,OAAO,GAAG,sBAAsB;EACpE,cAAc,MACZ,QACA;GACE,GAAG,OAAO,kBAAkB,CAAC,CAAC,SAAS;GACvC,GAAG,SAAS,gBAAgB;GAC5B,GAAG;EACL,GACA,KACF;CACF,CAAC;CAED,gBAAgB,SAAS,SACtB,EACC,UACA,OACA,WACA,MACA,SACA,cACA,gBACI;EACJ,MAAM,WAAW,UAAU,eAAe,OAAO,IAAI,KAAA;EACrD,MAAM,UAAU,MAAM,SAAS,KAAA,IAAY,UAAU,OAAO,MAAM;EAClE,MAAM,OACJ,YAAY,KAAA,IACR,UACA,kBACE,gBAAgB,OAAO,IACvB;EAER,IAAI,QAAQ,WAAW,IAAI,SAAS;EACpC,MAAM,yBAAyB,OAAO,MAAM,WAAW;EACvD,MAAM,0BAA0B,OAAO,MAAM,gBAAgB;EAG7D,IAAI,OAAO;GACT,MAAM,mBACJ,YAAY,eAAe,MAAM,MAAM;GACzC,IACE,MAAM,gBAAgB,MAAM,MAAM,iBAClC,kBACA;IAEA,MAAM,EAAE,aAAa,UAAU,GAAG,oBAAoB;IACtD,MAAM,SAAS;KACb,GAAG;KACH;KAMA,GAAI,MAAM,WAAW,aACnB,SAAS,KAAA,KAAa;MACpB,QAAQ;MACR,eAAe;MAEf,GAAI,CAAC,2BAA2B,EAC9B,aAAa,OACf;KACF;IACJ,CAAC;GACH;EACF,OAEE,QAAQ,WAAW,MACjB,QACA;GACE,GAAG,OAAO,kBAAkB,CAAC,CAAC,SAAS;GACvC,GAAG,SAAS,gBAAgB;GAC5B;GACA;GACA;GACA,OAAO;EACT,GAGA;GACE,GAAG;GACH;GACA,aAAa;GAGb,QACE,MAAM,WAAW,aAAa,SAAS,KAAA,IACnC,YACA,MAAM;GACZ,GAAI,MAAM,WAAW,aACnB,SAAS,KAAA,KAAa,EACpB,eAAe,aACjB;EACJ,CACF;EAGF,IACE,WAGA,CAAC,YACD,CAAC,0BACD,CAAC,2BAGD,eAAe,MAAM,MAAM,eAI3B,MACG,MAAM,KAAA,GAAW,EAEhB,gBAAgB,QAAQ,QAAQ,OAAO,CAAC,CAAC,KAAK,eAAe,EAC/D,CAAC,CAAC,CAED,MAAMA,cAAAA,IAAI;CAEjB,CACF;AACF"}
|
|
1
|
+
{"version":3,"file":"hydration.cjs","names":["noop"],"sources":["../../src/hydration.ts"],"sourcesContent":["import { noop } from './utils'\nimport type { Mutation, MutationState } from './mutation'\nimport type { Query, QueryState } from './query'\nimport type { QueryClient } from './queryClient'\nimport type {\n DefaultError,\n MutationKey,\n MutationMeta,\n MutationOptions,\n MutationScope,\n QueryKey,\n QueryMeta,\n QueryOptions,\n} from './types'\n\n// TYPES\ntype TransformerFn = (data: any) => any\n\n/**\n * Reads the value of a promise synchronously if it has already resolved, e.g. a thenable that\n * resolves within its `then` call.\n * @param promise - The promise to read.\n * @returns An object with the resolved `data`, or `undefined` if the promise hasn't resolved\n * synchronously (or resolved with `undefined`).\n */\nfunction tryResolveSync(promise: PromiseLike<unknown>) {\n let data: unknown\n\n const thenResult = promise.then((result) => {\n data = result\n return result\n }, noop) as Promise<unknown> | undefined\n\n // .catch can be unavailable on certain kinds of thenable's\n // oxlint-disable-next-line typescript/no-unnecessary-condition\n thenResult?.catch?.(noop)\n\n if (data !== undefined) {\n return { data }\n }\n\n return undefined\n}\n\n/**\n * Options for `dehydrate`, controlling which queries/mutations are included in the resulting `DehydratedState` and\n * how their data/errors are transformed before being serialized (e.g. for embedding in server-rendered markup).\n */\nexport interface DehydrateOptions {\n /** Transforms a query's `data` before it is dehydrated. Useful for non-JSON-serializable data. */\n serializeData?: TransformerFn\n /** Predicate to decide whether a given `Mutation` should be dehydrated. Defaults to `defaultShouldDehydrateMutation`. */\n shouldDehydrateMutation?: (mutation: Mutation) => boolean\n /** Predicate to decide whether a given `Query` should be dehydrated. Defaults to `defaultShouldDehydrateQuery`. */\n shouldDehydrateQuery?: (query: Query) => boolean\n /**\n * Predicate to decide whether a query's error should be redacted before dehydration. Errors are redacted\n * (replaced with a generic `Error('redacted')`) unless this function is provided and returns `false` for the\n * given error, in which case the original error is kept.\n */\n shouldRedactErrors?: (error: unknown) => boolean\n}\n\n/**\n * Options for `hydrate`, controlling the default options applied to queries/mutations restored from a\n * `DehydratedState`, and how to reverse any transformation applied by `DehydrateOptions.serializeData`.\n */\nexport interface HydrateOptions {\n /** Options applied to the queries and mutations restored from the dehydrated state. */\n defaultOptions?: {\n /** Transforms a query's `data` after it is read from the dehydrated state, reversing `serializeData`. */\n deserializeData?: TransformerFn\n /** Default options merged into every query restored from the dehydrated state. */\n queries?: QueryOptions\n /** Default options merged into every mutation restored from the dehydrated state. */\n mutations?: MutationOptions<unknown, DefaultError, unknown, unknown>\n }\n}\n\ninterface DehydratedMutation {\n mutationKey?: MutationKey\n state: MutationState\n meta?: MutationMeta\n scope?: MutationScope\n}\n\ninterface DehydratedQuery {\n queryHash: string\n queryKey: QueryKey\n state: QueryState\n dehydratedAt: number\n promise?: Promise<unknown>\n meta?: QueryMeta\n queryType?: 'infinite'\n}\n\n/**\n * A serializable snapshot of a `QueryClient`'s cache, as produced by `dehydrate` and consumed by `hydrate`. Typically\n * transported from server to client (e.g. embedded in server-rendered markup) to seed the client's cache with data\n * that has already been fetched, avoiding a redundant fetch on the client.\n */\nexport interface DehydratedState {\n /**\n * The dehydrated mutations, by default only the paused ones.\n */\n mutations: Array<DehydratedMutation>\n /**\n * The dehydrated queries, by default only the successful ones.\n */\n queries: Array<DehydratedQuery>\n}\n\n// FUNCTIONS\n\n/**\n * Dehydrates a single `Mutation` into a serializable snapshot of its key, state, scope, and meta.\n * @param mutation - The mutation to dehydrate.\n * @returns The dehydrated mutation.\n */\nfunction dehydrateMutation(mutation: Mutation): DehydratedMutation {\n return {\n mutationKey: mutation.options.mutationKey,\n state: mutation.state,\n ...(mutation.options.scope && { scope: mutation.options.scope }),\n ...(mutation.meta && { meta: mutation.meta }),\n }\n}\n\n/**\n * Prepares the in-flight promise of a pending query for dehydration: applies `serializeData` to its\n * result, and redacts its rejection error unless `shouldRedactErrors` returns `false` for it.\n * @param query - The pending query whose promise is dehydrated.\n * @param serializeData - Optional transform applied to the resolved data.\n * @param shouldRedactErrors - Optional predicate; if it returns `false` for the rejection error,\n * that\n * error is kept as-is instead of being redacted.\n * @returns The transformed promise, or `undefined` if the query has no in-flight promise.\n */\nfunction dehydratePromise(\n query: Query,\n serializeData?: TransformerFn,\n shouldRedactErrors?: (error: unknown) => boolean,\n): Promise<unknown> | undefined {\n const promise = query.promise?.then(serializeData).catch((error) => {\n if (shouldRedactErrors?.(error) === false) {\n // Reject original error if it should not be redacted\n return Promise.reject(error)\n }\n // If not in production, log original error before rejecting redacted error\n if (process.env.NODE_ENV !== 'production') {\n console.error(\n `A query that was dehydrated as pending ended up rejecting. [${query.queryHash}]: ${error}; The error will be redacted in production builds`,\n )\n }\n return Promise.reject(new Error('redacted'))\n })\n\n // Avoid unhandled promise rejections\n // We need the promise we dehydrate to reject to get the correct result into\n // the query cache, but we also want to avoid unhandled promise rejections\n // in whatever environment the prefetches are happening in.\n promise?.catch(noop)\n\n return promise\n}\n\n/**\n * Dehydrates a single `Query` into a serializable `DehydratedQuery` snapshot. Note that most query config (e.g.\n * `queryFn`, `staleTime`) is not dehydrated but instead meant to be configured again when consuming the\n * de/rehydrated data, typically with `useQuery` on the client. If the query is still `pending`, its in-flight\n * promise is dehydrated too so it can be resumed on the other side instead of re-fetched.\n * @param query - The query to dehydrate.\n * @param serializeData - Optional transform applied to `query.state.data` before it is included in the snapshot.\n * @param shouldRedactErrors - Optional predicate; if it returns `false` for the promise's rejection error, that\n * error is kept as-is instead of being redacted.\n * @returns The dehydrated query.\n */\nexport function dehydrateQuery(\n query: Query,\n serializeData?: TransformerFn,\n shouldRedactErrors?: (error: unknown) => boolean,\n): DehydratedQuery {\n return {\n dehydratedAt: Date.now(),\n state: {\n ...query.state,\n ...(query.state.data !== undefined && {\n data: serializeData\n ? serializeData(query.state.data)\n : query.state.data,\n }),\n },\n queryKey: query.queryKey,\n queryHash: query.queryHash,\n ...(query.state.status === 'pending' && {\n promise: dehydratePromise(query, serializeData, shouldRedactErrors),\n }),\n ...(query.meta && { meta: query.meta }),\n ...(query.queryType && { queryType: query.queryType }),\n }\n}\n\n/**\n * The default `shouldDehydrateMutation` predicate used by `dehydrate`. Only dehydrates mutations that are\n * currently paused (e.g. paused by `networkMode` while offline).\n * @param mutation - The mutation to check.\n * @returns `true` if the mutation is paused.\n */\nexport function defaultShouldDehydrateMutation(mutation: Mutation) {\n return mutation.state.isPaused\n}\n\n/**\n * The default `shouldDehydrateQuery` predicate used by `dehydrate`. Only dehydrates queries whose status is\n * `'success'`.\n * @param query - The query to check.\n * @returns `true` if the query's status is `'success'`.\n */\nexport function defaultShouldDehydrateQuery(query: Query) {\n return query.state.status === 'success'\n}\n\n/**\n * Dehydrates a `QueryClient`'s cache (queries and mutations) into a plain, serializable `DehydratedState`,\n * typically to embed in server-rendered markup and later restore into a client-side `QueryClient` via `hydrate`.\n * Which queries/mutations are included, and how their data/errors are transformed, is controlled by `options`,\n * falling back to the client's `dehydrate` default options, and finally to `defaultShouldDehydrateQuery` /\n * `defaultShouldDehydrateMutation`.\n * @param client - The client whose cache is dehydrated.\n * @param options - Controls which queries and mutations are included and how their data and errors\n * are transformed. Each option falls back to the client's `defaultOptions.dehydrate`.\n * @returns The dehydrated state, with the included `queries` and `mutations`.\n * @example\n * ```ts\n * const queryClient = new QueryClient()\n *\n * await queryClient.prefetchQuery({\n * queryKey: ['posts'],\n * queryFn: getPosts,\n * })\n *\n * const dehydratedState = dehydrate(queryClient)\n * ```\n */\nexport function dehydrate(\n client: QueryClient,\n options: DehydrateOptions = {},\n): DehydratedState {\n const filterMutation =\n options.shouldDehydrateMutation ??\n client.getDefaultOptions().dehydrate?.shouldDehydrateMutation ??\n defaultShouldDehydrateMutation\n\n const mutations = client\n .getMutationCache()\n .getAll()\n .flatMap((mutation) =>\n filterMutation(mutation) ? [dehydrateMutation(mutation)] : [],\n )\n\n const filterQuery =\n options.shouldDehydrateQuery ??\n client.getDefaultOptions().dehydrate?.shouldDehydrateQuery ??\n defaultShouldDehydrateQuery\n\n const shouldRedactErrors =\n options.shouldRedactErrors ??\n client.getDefaultOptions().dehydrate?.shouldRedactErrors\n\n const serializeData =\n options.serializeData ?? client.getDefaultOptions().dehydrate?.serializeData\n\n const queries = client\n .getQueryCache()\n .getAll()\n .flatMap((query) =>\n filterQuery(query)\n ? [dehydrateQuery(query, serializeData, shouldRedactErrors)]\n : [],\n )\n\n return { mutations, queries }\n}\n\n/**\n * Restores a `DehydratedState` (as produced by `dehydrate`) into a `QueryClient`'s cache, typically to seed the\n * client with data already fetched on the server. `mutations` and `queries` are each optional on `dehydratedState`.\n * Queries not yet in the cache are built from the dehydrated snapshot; queries that already exist are only updated\n * when the dehydrated data is newer than what's already cached. Newly built queries have their `fetchStatus` reset\n * to `'idle'` so they don't hydrate stuck in a fetching state. If a dehydrated query still had an in-flight\n * promise, it is resumed via `query.fetch()` (reusing that promise as `initialPromise`) rather than re-invoking\n * `queryFn`.\n * @param client - The client whose cache is restored into.\n * @param dehydratedState - The dehydrated state, e.g. produced by `dehydrate` on the server.\n * @param options - `defaultOptions` merged into every restored query and mutation (on top of the\n * client's `defaultOptions.hydrate`), and `deserializeData` to reverse `serializeData`.\n * @example\n * ```ts\n * // dehydratedState was produced by `dehydrate` on the server\n * // and sent to the client, e.g. embedded in server-rendered markup.\n * const queryClient = new QueryClient()\n *\n * hydrate(queryClient, dehydratedState)\n * ```\n */\nexport function hydrate(\n client: QueryClient,\n dehydratedState: Partial<DehydratedState>,\n options?: HydrateOptions,\n): void {\n const mutationCache = client.getMutationCache()\n const queryCache = client.getQueryCache()\n const deserializeData =\n options?.defaultOptions?.deserializeData ??\n client.getDefaultOptions().hydrate?.deserializeData\n\n dehydratedState.mutations?.forEach(({ state, ...mutationOptions }) => {\n mutationCache.build(\n client,\n {\n ...client.getDefaultOptions().hydrate?.mutations,\n ...options?.defaultOptions?.mutations,\n ...mutationOptions,\n },\n state,\n )\n })\n\n dehydratedState.queries?.forEach(\n ({\n queryKey,\n state,\n queryHash,\n meta,\n promise,\n dehydratedAt,\n queryType,\n }) => {\n const syncData = promise ? tryResolveSync(promise) : undefined\n const rawData = state.data === undefined ? syncData?.data : state.data\n const data =\n rawData === undefined\n ? rawData\n : deserializeData\n ? deserializeData(rawData)\n : rawData\n\n let query = queryCache.get(queryHash)\n const existingQueryIsPending = query?.state.status === 'pending'\n const existingQueryIsFetching = query?.state.fetchStatus === 'fetching'\n\n // Do not hydrate if an existing query exists with newer data\n if (query) {\n const hasNewerSyncData =\n syncData && dehydratedAt > query.state.dataUpdatedAt\n if (\n state.dataUpdatedAt > query.state.dataUpdatedAt ||\n hasNewerSyncData\n ) {\n // Omit fetchStatus from dehydrated state so that query stays in its current fetchStatus\n const { fetchStatus: _ignored, ...serializedState } = state\n query.setState({\n ...serializedState,\n data,\n // If the query was pending at the moment of dehydration, but resolved to have data\n // before hydration, we can assume the query should be hydrated as successful.\n //\n // Since you can opt into dehydrating failed queries, and those can have data from\n // previous successful fetches, we make sure we only do this for pending queries.\n ...(state.status === 'pending' &&\n data !== undefined && {\n status: 'success' as const,\n dataUpdatedAt: dehydratedAt,\n // Preserve existing fetchStatus if the existing query is actively fetching.\n ...(!existingQueryIsFetching && {\n fetchStatus: 'idle' as const,\n }),\n }),\n })\n }\n } else {\n // Restore query\n query = queryCache.build(\n client,\n {\n ...client.getDefaultOptions().hydrate?.queries,\n ...options?.defaultOptions?.queries,\n queryKey,\n queryHash,\n meta,\n _type: queryType,\n },\n // Reset fetch status to idle to avoid\n // query being stuck in fetching state upon hydration\n {\n ...state,\n data,\n fetchStatus: 'idle',\n // Like above, if the query was pending at the moment of dehydration but has data,\n // we can assume it should be hydrated as successful.\n status:\n state.status === 'pending' && data !== undefined\n ? 'success'\n : state.status,\n ...(state.status === 'pending' &&\n data !== undefined && {\n dataUpdatedAt: dehydratedAt,\n }),\n },\n )\n }\n\n if (\n promise &&\n // If the data was synchronously available, there is no need to set up\n // a retryer and thus no reason to call fetch\n !syncData &&\n !existingQueryIsPending &&\n !existingQueryIsFetching &&\n // Only hydrate if dehydration is newer than any existing data,\n // this is always true for new queries\n dehydratedAt > query.state.dataUpdatedAt\n ) {\n // This doesn't actually fetch - it just creates a retryer\n // which will re-use the passed `initialPromise`\n query\n .fetch(undefined, {\n // RSC transformed promises are not thenable\n initialPromise: Promise.resolve(promise).then(deserializeData),\n })\n // Avoid unhandled promise rejections\n .catch(noop)\n }\n },\n )\n}\n"],"mappings":"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"}
|
|
@@ -1,2 +1,2 @@
|
|
|
1
|
-
import { a as defaultShouldDehydrateQuery, c as hydrate, i as defaultShouldDehydrateMutation, n as DehydratedState, o as dehydrate, r as HydrateOptions, s as dehydrateQuery, t as DehydrateOptions } from "./hydration-
|
|
1
|
+
import { a as defaultShouldDehydrateQuery, c as hydrate, i as defaultShouldDehydrateMutation, n as DehydratedState, o as dehydrate, r as HydrateOptions, s as dehydrateQuery, t as DehydrateOptions } from "./hydration-24GwbSaU.cjs";
|
|
2
2
|
export { DehydrateOptions, DehydratedState, HydrateOptions, defaultShouldDehydrateMutation, defaultShouldDehydrateQuery, dehydrate, dehydrateQuery, hydrate };
|
|
@@ -1,2 +1,2 @@
|
|
|
1
|
-
import { a as defaultShouldDehydrateQuery, c as hydrate, i as defaultShouldDehydrateMutation, n as DehydratedState, o as dehydrate, r as HydrateOptions, s as dehydrateQuery, t as DehydrateOptions } from "./hydration-
|
|
1
|
+
import { a as defaultShouldDehydrateQuery, c as hydrate, i as defaultShouldDehydrateMutation, n as DehydratedState, o as dehydrate, r as HydrateOptions, s as dehydrateQuery, t as DehydrateOptions } from "./hydration-Cbq_heQS.js";
|
|
2
2
|
export { DehydrateOptions, DehydratedState, HydrateOptions, defaultShouldDehydrateMutation, defaultShouldDehydrateQuery, dehydrate, dehydrateQuery, hydrate };
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"hydration.js","names":[],"sources":["../../src/hydration.ts"],"sourcesContent":["import { noop } from './utils'\nimport type {\n DefaultError,\n MutationKey,\n MutationMeta,\n MutationOptions,\n MutationScope,\n QueryKey,\n QueryMeta,\n QueryOptions,\n} from './types'\nimport type { QueryClient } from './queryClient'\nimport type { Query, QueryState } from './query'\nimport type { Mutation, MutationState } from './mutation'\n\n// TYPES\ntype TransformerFn = (data: any) => any\n\n/**\n * Reads the value of a promise synchronously if it has already resolved, e.g. a thenable that\n * resolves within its `then` call.\n * @param promise - The promise to read.\n * @returns An object with the resolved `data`, or `undefined` if the promise hasn't resolved\n * synchronously (or resolved with `undefined`).\n */\nfunction tryResolveSync(promise: PromiseLike<unknown>) {\n let data: unknown\n\n const thenResult = promise.then((result) => {\n data = result\n return result\n }, noop) as Promise<unknown> | undefined\n\n // .catch can be unavailable on certain kinds of thenable's\n // oxlint-disable-next-line typescript/no-unnecessary-condition\n thenResult?.catch?.(noop)\n\n if (data !== undefined) {\n return { data }\n }\n\n return undefined\n}\n\n/**\n * Options for `dehydrate`, controlling which queries/mutations are included in the resulting `DehydratedState` and\n * how their data/errors are transformed before being serialized (e.g. for embedding in server-rendered markup).\n */\nexport interface DehydrateOptions {\n /** Transforms a query's `data` before it is dehydrated. Useful for non-JSON-serializable data. */\n serializeData?: TransformerFn\n /** Predicate to decide whether a given `Mutation` should be dehydrated. Defaults to `defaultShouldDehydrateMutation`. */\n shouldDehydrateMutation?: (mutation: Mutation) => boolean\n /** Predicate to decide whether a given `Query` should be dehydrated. Defaults to `defaultShouldDehydrateQuery`. */\n shouldDehydrateQuery?: (query: Query) => boolean\n /**\n * Predicate to decide whether a query's error should be redacted before dehydration. Errors are redacted\n * (replaced with a generic `Error('redacted')`) unless this function is provided and returns `false` for the\n * given error, in which case the original error is kept.\n */\n shouldRedactErrors?: (error: unknown) => boolean\n}\n\n/**\n * Options for `hydrate`, controlling the default options applied to queries/mutations restored from a\n * `DehydratedState`, and how to reverse any transformation applied by `DehydrateOptions.serializeData`.\n */\nexport interface HydrateOptions {\n /** Options applied to the queries and mutations restored from the dehydrated state. */\n defaultOptions?: {\n /** Transforms a query's `data` after it is read from the dehydrated state, reversing `serializeData`. */\n deserializeData?: TransformerFn\n /** Default options merged into every query restored from the dehydrated state. */\n queries?: QueryOptions\n /** Default options merged into every mutation restored from the dehydrated state. */\n mutations?: MutationOptions<unknown, DefaultError, unknown, unknown>\n }\n}\n\ninterface DehydratedMutation {\n mutationKey?: MutationKey\n state: MutationState\n meta?: MutationMeta\n scope?: MutationScope\n}\n\ninterface DehydratedQuery {\n queryHash: string\n queryKey: QueryKey\n state: QueryState\n dehydratedAt: number\n promise?: Promise<unknown>\n meta?: QueryMeta\n queryType?: 'infinite'\n}\n\n/**\n * A serializable snapshot of a `QueryClient`'s cache, as produced by `dehydrate` and consumed by `hydrate`. Typically\n * transported from server to client (e.g. embedded in server-rendered markup) to seed the client's cache with data\n * that has already been fetched, avoiding a redundant fetch on the client.\n */\nexport interface DehydratedState {\n /**\n * The dehydrated mutations, by default only the paused ones.\n */\n mutations: Array<DehydratedMutation>\n /**\n * The dehydrated queries, by default only the successful ones.\n */\n queries: Array<DehydratedQuery>\n}\n\n// FUNCTIONS\n\n/**\n * Dehydrates a single `Mutation` into a serializable snapshot of its key, state, scope, and meta.\n * @param mutation - The mutation to dehydrate.\n * @returns The dehydrated mutation.\n */\nfunction dehydrateMutation(mutation: Mutation): DehydratedMutation {\n return {\n mutationKey: mutation.options.mutationKey,\n state: mutation.state,\n ...(mutation.options.scope && { scope: mutation.options.scope }),\n ...(mutation.meta && { meta: mutation.meta }),\n }\n}\n\n/**\n * Prepares the in-flight promise of a pending query for dehydration: applies `serializeData` to its\n * result, and redacts its rejection error unless `shouldRedactErrors` returns `false` for it.\n * @param query - The pending query whose promise is dehydrated.\n * @param serializeData - Optional transform applied to the resolved data.\n * @param shouldRedactErrors - Optional predicate; if it returns `false` for the rejection error,\n * that\n * error is kept as-is instead of being redacted.\n * @returns The transformed promise, or `undefined` if the query has no in-flight promise.\n */\nfunction dehydratePromise(\n query: Query,\n serializeData?: TransformerFn,\n shouldRedactErrors?: (error: unknown) => boolean,\n): Promise<unknown> | undefined {\n const promise = query.promise?.then(serializeData).catch((error) => {\n if (shouldRedactErrors?.(error) === false) {\n // Reject original error if it should not be redacted\n return Promise.reject(error)\n }\n // If not in production, log original error before rejecting redacted error\n if (process.env.NODE_ENV !== 'production') {\n console.error(\n `A query that was dehydrated as pending ended up rejecting. [${query.queryHash}]: ${error}; The error will be redacted in production builds`,\n )\n }\n return Promise.reject(new Error('redacted'))\n })\n\n // Avoid unhandled promise rejections\n // We need the promise we dehydrate to reject to get the correct result into\n // the query cache, but we also want to avoid unhandled promise rejections\n // in whatever environment the prefetches are happening in.\n promise?.catch(noop)\n\n return promise\n}\n\n/**\n * Dehydrates a single `Query` into a serializable `DehydratedQuery` snapshot. Note that most query config (e.g.\n * `queryFn`, `staleTime`) is not dehydrated but instead meant to be configured again when consuming the\n * de/rehydrated data, typically with `useQuery` on the client. If the query is still `pending`, its in-flight\n * promise is dehydrated too so it can be resumed on the other side instead of re-fetched.\n * @param query - The query to dehydrate.\n * @param serializeData - Optional transform applied to `query.state.data` before it is included in the snapshot.\n * @param shouldRedactErrors - Optional predicate; if it returns `false` for the promise's rejection error, that\n * error is kept as-is instead of being redacted.\n * @returns The dehydrated query.\n */\nexport function dehydrateQuery(\n query: Query,\n serializeData?: TransformerFn,\n shouldRedactErrors?: (error: unknown) => boolean,\n): DehydratedQuery {\n return {\n dehydratedAt: Date.now(),\n state: {\n ...query.state,\n ...(query.state.data !== undefined && {\n data: serializeData\n ? serializeData(query.state.data)\n : query.state.data,\n }),\n },\n queryKey: query.queryKey,\n queryHash: query.queryHash,\n ...(query.state.status === 'pending' && {\n promise: dehydratePromise(query, serializeData, shouldRedactErrors),\n }),\n ...(query.meta && { meta: query.meta }),\n ...(query.queryType && { queryType: query.queryType }),\n }\n}\n\n/**\n * The default `shouldDehydrateMutation` predicate used by `dehydrate`. Only dehydrates mutations that are\n * currently paused (e.g. paused by `networkMode` while offline).\n * @param mutation - The mutation to check.\n * @returns `true` if the mutation is paused.\n */\nexport function defaultShouldDehydrateMutation(mutation: Mutation) {\n return mutation.state.isPaused\n}\n\n/**\n * The default `shouldDehydrateQuery` predicate used by `dehydrate`. Only dehydrates queries whose status is\n * `'success'`.\n * @param query - The query to check.\n * @returns `true` if the query's status is `'success'`.\n */\nexport function defaultShouldDehydrateQuery(query: Query) {\n return query.state.status === 'success'\n}\n\n/**\n * Dehydrates a `QueryClient`'s cache (queries and mutations) into a plain, serializable `DehydratedState`,\n * typically to embed in server-rendered markup and later restore into a client-side `QueryClient` via `hydrate`.\n * Which queries/mutations are included, and how their data/errors are transformed, is controlled by `options`,\n * falling back to the client's `dehydrate` default options, and finally to `defaultShouldDehydrateQuery` /\n * `defaultShouldDehydrateMutation`.\n * @param client - The client whose cache is dehydrated.\n * @param options - Controls which queries and mutations are included and how their data and errors\n * are transformed. Each option falls back to the client's `defaultOptions.dehydrate`.\n * @returns The dehydrated state, with the included `queries` and `mutations`.\n * @example\n * ```ts\n * const queryClient = new QueryClient()\n *\n * await queryClient.prefetchQuery({\n * queryKey: ['posts'],\n * queryFn: getPosts,\n * })\n *\n * const dehydratedState = dehydrate(queryClient)\n * ```\n */\nexport function dehydrate(\n client: QueryClient,\n options: DehydrateOptions = {},\n): DehydratedState {\n const filterMutation =\n options.shouldDehydrateMutation ??\n client.getDefaultOptions().dehydrate?.shouldDehydrateMutation ??\n defaultShouldDehydrateMutation\n\n const mutations = client\n .getMutationCache()\n .getAll()\n .flatMap((mutation) =>\n filterMutation(mutation) ? [dehydrateMutation(mutation)] : [],\n )\n\n const filterQuery =\n options.shouldDehydrateQuery ??\n client.getDefaultOptions().dehydrate?.shouldDehydrateQuery ??\n defaultShouldDehydrateQuery\n\n const shouldRedactErrors =\n options.shouldRedactErrors ??\n client.getDefaultOptions().dehydrate?.shouldRedactErrors\n\n const serializeData =\n options.serializeData ?? client.getDefaultOptions().dehydrate?.serializeData\n\n const queries = client\n .getQueryCache()\n .getAll()\n .flatMap((query) =>\n filterQuery(query)\n ? [dehydrateQuery(query, serializeData, shouldRedactErrors)]\n : [],\n )\n\n return { mutations, queries }\n}\n\n/**\n * Restores a `DehydratedState` (as produced by `dehydrate`) into a `QueryClient`'s cache, typically to seed the\n * client with data already fetched on the server. `mutations` and `queries` are each optional on `dehydratedState`.\n * Queries not yet in the cache are built from the dehydrated snapshot; queries that already exist are only updated\n * when the dehydrated data is newer than what's already cached. Newly built queries have their `fetchStatus` reset\n * to `'idle'` so they don't hydrate stuck in a fetching state. If a dehydrated query still had an in-flight\n * promise, it is resumed via `query.fetch()` (reusing that promise as `initialPromise`) rather than re-invoking\n * `queryFn`.\n * @param client - The client whose cache is restored into.\n * @param dehydratedState - The dehydrated state, e.g. produced by `dehydrate` on the server.\n * @param options - `defaultOptions` merged into every restored query and mutation (on top of the\n * client's `defaultOptions.hydrate`), and `deserializeData` to reverse `serializeData`.\n * @example\n * ```ts\n * // dehydratedState was produced by `dehydrate` on the server\n * // and sent to the client, e.g. embedded in server-rendered markup.\n * const queryClient = new QueryClient()\n *\n * hydrate(queryClient, dehydratedState)\n * ```\n */\nexport function hydrate(\n client: QueryClient,\n dehydratedState: Partial<DehydratedState>,\n options?: HydrateOptions,\n): void {\n const mutationCache = client.getMutationCache()\n const queryCache = client.getQueryCache()\n const deserializeData =\n options?.defaultOptions?.deserializeData ??\n client.getDefaultOptions().hydrate?.deserializeData\n\n dehydratedState.mutations?.forEach(({ state, ...mutationOptions }) => {\n mutationCache.build(\n client,\n {\n ...client.getDefaultOptions().hydrate?.mutations,\n ...options?.defaultOptions?.mutations,\n ...mutationOptions,\n },\n state,\n )\n })\n\n dehydratedState.queries?.forEach(\n ({\n queryKey,\n state,\n queryHash,\n meta,\n promise,\n dehydratedAt,\n queryType,\n }) => {\n const syncData = promise ? tryResolveSync(promise) : undefined\n const rawData = state.data === undefined ? syncData?.data : state.data\n const data =\n rawData === undefined\n ? rawData\n : deserializeData\n ? deserializeData(rawData)\n : rawData\n\n let query = queryCache.get(queryHash)\n const existingQueryIsPending = query?.state.status === 'pending'\n const existingQueryIsFetching = query?.state.fetchStatus === 'fetching'\n\n // Do not hydrate if an existing query exists with newer data\n if (query) {\n const hasNewerSyncData =\n syncData && dehydratedAt > query.state.dataUpdatedAt\n if (\n state.dataUpdatedAt > query.state.dataUpdatedAt ||\n hasNewerSyncData\n ) {\n // Omit fetchStatus from dehydrated state so that query stays in its current fetchStatus\n const { fetchStatus: _ignored, ...serializedState } = state\n query.setState({\n ...serializedState,\n data,\n // If the query was pending at the moment of dehydration, but resolved to have data\n // before hydration, we can assume the query should be hydrated as successful.\n //\n // Since you can opt into dehydrating failed queries, and those can have data from\n // previous successful fetches, we make sure we only do this for pending queries.\n ...(state.status === 'pending' &&\n data !== undefined && {\n status: 'success' as const,\n dataUpdatedAt: dehydratedAt,\n // Preserve existing fetchStatus if the existing query is actively fetching.\n ...(!existingQueryIsFetching && {\n fetchStatus: 'idle' as const,\n }),\n }),\n })\n }\n } else {\n // Restore query\n query = queryCache.build(\n client,\n {\n ...client.getDefaultOptions().hydrate?.queries,\n ...options?.defaultOptions?.queries,\n queryKey,\n queryHash,\n meta,\n _type: queryType,\n },\n // Reset fetch status to idle to avoid\n // query being stuck in fetching state upon hydration\n {\n ...state,\n data,\n fetchStatus: 'idle',\n // Like above, if the query was pending at the moment of dehydration but has data,\n // we can assume it should be hydrated as successful.\n status:\n state.status === 'pending' && data !== undefined\n ? 'success'\n : state.status,\n ...(state.status === 'pending' &&\n data !== undefined && {\n dataUpdatedAt: dehydratedAt,\n }),\n },\n )\n }\n\n if (\n promise &&\n // If the data was synchronously available, there is no need to set up\n // a retryer and thus no reason to call fetch\n !syncData &&\n !existingQueryIsPending &&\n !existingQueryIsFetching &&\n // Only hydrate if dehydration is newer than any existing data,\n // this is always true for new queries\n dehydratedAt > query.state.dataUpdatedAt\n ) {\n // This doesn't actually fetch - it just creates a retryer\n // which will re-use the passed `initialPromise`\n query\n .fetch(undefined, {\n // RSC transformed promises are not thenable\n initialPromise: Promise.resolve(promise).then(deserializeData),\n })\n // Avoid unhandled promise rejections\n .catch(noop)\n }\n },\n )\n}\n"],"mappings":"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"}
|
|
1
|
+
{"version":3,"file":"hydration.js","names":[],"sources":["../../src/hydration.ts"],"sourcesContent":["import { noop } from './utils'\nimport type { Mutation, MutationState } from './mutation'\nimport type { Query, QueryState } from './query'\nimport type { QueryClient } from './queryClient'\nimport type {\n DefaultError,\n MutationKey,\n MutationMeta,\n MutationOptions,\n MutationScope,\n QueryKey,\n QueryMeta,\n QueryOptions,\n} from './types'\n\n// TYPES\ntype TransformerFn = (data: any) => any\n\n/**\n * Reads the value of a promise synchronously if it has already resolved, e.g. a thenable that\n * resolves within its `then` call.\n * @param promise - The promise to read.\n * @returns An object with the resolved `data`, or `undefined` if the promise hasn't resolved\n * synchronously (or resolved with `undefined`).\n */\nfunction tryResolveSync(promise: PromiseLike<unknown>) {\n let data: unknown\n\n const thenResult = promise.then((result) => {\n data = result\n return result\n }, noop) as Promise<unknown> | undefined\n\n // .catch can be unavailable on certain kinds of thenable's\n // oxlint-disable-next-line typescript/no-unnecessary-condition\n thenResult?.catch?.(noop)\n\n if (data !== undefined) {\n return { data }\n }\n\n return undefined\n}\n\n/**\n * Options for `dehydrate`, controlling which queries/mutations are included in the resulting `DehydratedState` and\n * how their data/errors are transformed before being serialized (e.g. for embedding in server-rendered markup).\n */\nexport interface DehydrateOptions {\n /** Transforms a query's `data` before it is dehydrated. Useful for non-JSON-serializable data. */\n serializeData?: TransformerFn\n /** Predicate to decide whether a given `Mutation` should be dehydrated. Defaults to `defaultShouldDehydrateMutation`. */\n shouldDehydrateMutation?: (mutation: Mutation) => boolean\n /** Predicate to decide whether a given `Query` should be dehydrated. Defaults to `defaultShouldDehydrateQuery`. */\n shouldDehydrateQuery?: (query: Query) => boolean\n /**\n * Predicate to decide whether a query's error should be redacted before dehydration. Errors are redacted\n * (replaced with a generic `Error('redacted')`) unless this function is provided and returns `false` for the\n * given error, in which case the original error is kept.\n */\n shouldRedactErrors?: (error: unknown) => boolean\n}\n\n/**\n * Options for `hydrate`, controlling the default options applied to queries/mutations restored from a\n * `DehydratedState`, and how to reverse any transformation applied by `DehydrateOptions.serializeData`.\n */\nexport interface HydrateOptions {\n /** Options applied to the queries and mutations restored from the dehydrated state. */\n defaultOptions?: {\n /** Transforms a query's `data` after it is read from the dehydrated state, reversing `serializeData`. */\n deserializeData?: TransformerFn\n /** Default options merged into every query restored from the dehydrated state. */\n queries?: QueryOptions\n /** Default options merged into every mutation restored from the dehydrated state. */\n mutations?: MutationOptions<unknown, DefaultError, unknown, unknown>\n }\n}\n\ninterface DehydratedMutation {\n mutationKey?: MutationKey\n state: MutationState\n meta?: MutationMeta\n scope?: MutationScope\n}\n\ninterface DehydratedQuery {\n queryHash: string\n queryKey: QueryKey\n state: QueryState\n dehydratedAt: number\n promise?: Promise<unknown>\n meta?: QueryMeta\n queryType?: 'infinite'\n}\n\n/**\n * A serializable snapshot of a `QueryClient`'s cache, as produced by `dehydrate` and consumed by `hydrate`. Typically\n * transported from server to client (e.g. embedded in server-rendered markup) to seed the client's cache with data\n * that has already been fetched, avoiding a redundant fetch on the client.\n */\nexport interface DehydratedState {\n /**\n * The dehydrated mutations, by default only the paused ones.\n */\n mutations: Array<DehydratedMutation>\n /**\n * The dehydrated queries, by default only the successful ones.\n */\n queries: Array<DehydratedQuery>\n}\n\n// FUNCTIONS\n\n/**\n * Dehydrates a single `Mutation` into a serializable snapshot of its key, state, scope, and meta.\n * @param mutation - The mutation to dehydrate.\n * @returns The dehydrated mutation.\n */\nfunction dehydrateMutation(mutation: Mutation): DehydratedMutation {\n return {\n mutationKey: mutation.options.mutationKey,\n state: mutation.state,\n ...(mutation.options.scope && { scope: mutation.options.scope }),\n ...(mutation.meta && { meta: mutation.meta }),\n }\n}\n\n/**\n * Prepares the in-flight promise of a pending query for dehydration: applies `serializeData` to its\n * result, and redacts its rejection error unless `shouldRedactErrors` returns `false` for it.\n * @param query - The pending query whose promise is dehydrated.\n * @param serializeData - Optional transform applied to the resolved data.\n * @param shouldRedactErrors - Optional predicate; if it returns `false` for the rejection error,\n * that\n * error is kept as-is instead of being redacted.\n * @returns The transformed promise, or `undefined` if the query has no in-flight promise.\n */\nfunction dehydratePromise(\n query: Query,\n serializeData?: TransformerFn,\n shouldRedactErrors?: (error: unknown) => boolean,\n): Promise<unknown> | undefined {\n const promise = query.promise?.then(serializeData).catch((error) => {\n if (shouldRedactErrors?.(error) === false) {\n // Reject original error if it should not be redacted\n return Promise.reject(error)\n }\n // If not in production, log original error before rejecting redacted error\n if (process.env.NODE_ENV !== 'production') {\n console.error(\n `A query that was dehydrated as pending ended up rejecting. [${query.queryHash}]: ${error}; The error will be redacted in production builds`,\n )\n }\n return Promise.reject(new Error('redacted'))\n })\n\n // Avoid unhandled promise rejections\n // We need the promise we dehydrate to reject to get the correct result into\n // the query cache, but we also want to avoid unhandled promise rejections\n // in whatever environment the prefetches are happening in.\n promise?.catch(noop)\n\n return promise\n}\n\n/**\n * Dehydrates a single `Query` into a serializable `DehydratedQuery` snapshot. Note that most query config (e.g.\n * `queryFn`, `staleTime`) is not dehydrated but instead meant to be configured again when consuming the\n * de/rehydrated data, typically with `useQuery` on the client. If the query is still `pending`, its in-flight\n * promise is dehydrated too so it can be resumed on the other side instead of re-fetched.\n * @param query - The query to dehydrate.\n * @param serializeData - Optional transform applied to `query.state.data` before it is included in the snapshot.\n * @param shouldRedactErrors - Optional predicate; if it returns `false` for the promise's rejection error, that\n * error is kept as-is instead of being redacted.\n * @returns The dehydrated query.\n */\nexport function dehydrateQuery(\n query: Query,\n serializeData?: TransformerFn,\n shouldRedactErrors?: (error: unknown) => boolean,\n): DehydratedQuery {\n return {\n dehydratedAt: Date.now(),\n state: {\n ...query.state,\n ...(query.state.data !== undefined && {\n data: serializeData\n ? serializeData(query.state.data)\n : query.state.data,\n }),\n },\n queryKey: query.queryKey,\n queryHash: query.queryHash,\n ...(query.state.status === 'pending' && {\n promise: dehydratePromise(query, serializeData, shouldRedactErrors),\n }),\n ...(query.meta && { meta: query.meta }),\n ...(query.queryType && { queryType: query.queryType }),\n }\n}\n\n/**\n * The default `shouldDehydrateMutation` predicate used by `dehydrate`. Only dehydrates mutations that are\n * currently paused (e.g. paused by `networkMode` while offline).\n * @param mutation - The mutation to check.\n * @returns `true` if the mutation is paused.\n */\nexport function defaultShouldDehydrateMutation(mutation: Mutation) {\n return mutation.state.isPaused\n}\n\n/**\n * The default `shouldDehydrateQuery` predicate used by `dehydrate`. Only dehydrates queries whose status is\n * `'success'`.\n * @param query - The query to check.\n * @returns `true` if the query's status is `'success'`.\n */\nexport function defaultShouldDehydrateQuery(query: Query) {\n return query.state.status === 'success'\n}\n\n/**\n * Dehydrates a `QueryClient`'s cache (queries and mutations) into a plain, serializable `DehydratedState`,\n * typically to embed in server-rendered markup and later restore into a client-side `QueryClient` via `hydrate`.\n * Which queries/mutations are included, and how their data/errors are transformed, is controlled by `options`,\n * falling back to the client's `dehydrate` default options, and finally to `defaultShouldDehydrateQuery` /\n * `defaultShouldDehydrateMutation`.\n * @param client - The client whose cache is dehydrated.\n * @param options - Controls which queries and mutations are included and how their data and errors\n * are transformed. Each option falls back to the client's `defaultOptions.dehydrate`.\n * @returns The dehydrated state, with the included `queries` and `mutations`.\n * @example\n * ```ts\n * const queryClient = new QueryClient()\n *\n * await queryClient.prefetchQuery({\n * queryKey: ['posts'],\n * queryFn: getPosts,\n * })\n *\n * const dehydratedState = dehydrate(queryClient)\n * ```\n */\nexport function dehydrate(\n client: QueryClient,\n options: DehydrateOptions = {},\n): DehydratedState {\n const filterMutation =\n options.shouldDehydrateMutation ??\n client.getDefaultOptions().dehydrate?.shouldDehydrateMutation ??\n defaultShouldDehydrateMutation\n\n const mutations = client\n .getMutationCache()\n .getAll()\n .flatMap((mutation) =>\n filterMutation(mutation) ? [dehydrateMutation(mutation)] : [],\n )\n\n const filterQuery =\n options.shouldDehydrateQuery ??\n client.getDefaultOptions().dehydrate?.shouldDehydrateQuery ??\n defaultShouldDehydrateQuery\n\n const shouldRedactErrors =\n options.shouldRedactErrors ??\n client.getDefaultOptions().dehydrate?.shouldRedactErrors\n\n const serializeData =\n options.serializeData ?? client.getDefaultOptions().dehydrate?.serializeData\n\n const queries = client\n .getQueryCache()\n .getAll()\n .flatMap((query) =>\n filterQuery(query)\n ? [dehydrateQuery(query, serializeData, shouldRedactErrors)]\n : [],\n )\n\n return { mutations, queries }\n}\n\n/**\n * Restores a `DehydratedState` (as produced by `dehydrate`) into a `QueryClient`'s cache, typically to seed the\n * client with data already fetched on the server. `mutations` and `queries` are each optional on `dehydratedState`.\n * Queries not yet in the cache are built from the dehydrated snapshot; queries that already exist are only updated\n * when the dehydrated data is newer than what's already cached. Newly built queries have their `fetchStatus` reset\n * to `'idle'` so they don't hydrate stuck in a fetching state. If a dehydrated query still had an in-flight\n * promise, it is resumed via `query.fetch()` (reusing that promise as `initialPromise`) rather than re-invoking\n * `queryFn`.\n * @param client - The client whose cache is restored into.\n * @param dehydratedState - The dehydrated state, e.g. produced by `dehydrate` on the server.\n * @param options - `defaultOptions` merged into every restored query and mutation (on top of the\n * client's `defaultOptions.hydrate`), and `deserializeData` to reverse `serializeData`.\n * @example\n * ```ts\n * // dehydratedState was produced by `dehydrate` on the server\n * // and sent to the client, e.g. embedded in server-rendered markup.\n * const queryClient = new QueryClient()\n *\n * hydrate(queryClient, dehydratedState)\n * ```\n */\nexport function hydrate(\n client: QueryClient,\n dehydratedState: Partial<DehydratedState>,\n options?: HydrateOptions,\n): void {\n const mutationCache = client.getMutationCache()\n const queryCache = client.getQueryCache()\n const deserializeData =\n options?.defaultOptions?.deserializeData ??\n client.getDefaultOptions().hydrate?.deserializeData\n\n dehydratedState.mutations?.forEach(({ state, ...mutationOptions }) => {\n mutationCache.build(\n client,\n {\n ...client.getDefaultOptions().hydrate?.mutations,\n ...options?.defaultOptions?.mutations,\n ...mutationOptions,\n },\n state,\n )\n })\n\n dehydratedState.queries?.forEach(\n ({\n queryKey,\n state,\n queryHash,\n meta,\n promise,\n dehydratedAt,\n queryType,\n }) => {\n const syncData = promise ? tryResolveSync(promise) : undefined\n const rawData = state.data === undefined ? syncData?.data : state.data\n const data =\n rawData === undefined\n ? rawData\n : deserializeData\n ? deserializeData(rawData)\n : rawData\n\n let query = queryCache.get(queryHash)\n const existingQueryIsPending = query?.state.status === 'pending'\n const existingQueryIsFetching = query?.state.fetchStatus === 'fetching'\n\n // Do not hydrate if an existing query exists with newer data\n if (query) {\n const hasNewerSyncData =\n syncData && dehydratedAt > query.state.dataUpdatedAt\n if (\n state.dataUpdatedAt > query.state.dataUpdatedAt ||\n hasNewerSyncData\n ) {\n // Omit fetchStatus from dehydrated state so that query stays in its current fetchStatus\n const { fetchStatus: _ignored, ...serializedState } = state\n query.setState({\n ...serializedState,\n data,\n // If the query was pending at the moment of dehydration, but resolved to have data\n // before hydration, we can assume the query should be hydrated as successful.\n //\n // Since you can opt into dehydrating failed queries, and those can have data from\n // previous successful fetches, we make sure we only do this for pending queries.\n ...(state.status === 'pending' &&\n data !== undefined && {\n status: 'success' as const,\n dataUpdatedAt: dehydratedAt,\n // Preserve existing fetchStatus if the existing query is actively fetching.\n ...(!existingQueryIsFetching && {\n fetchStatus: 'idle' as const,\n }),\n }),\n })\n }\n } else {\n // Restore query\n query = queryCache.build(\n client,\n {\n ...client.getDefaultOptions().hydrate?.queries,\n ...options?.defaultOptions?.queries,\n queryKey,\n queryHash,\n meta,\n _type: queryType,\n },\n // Reset fetch status to idle to avoid\n // query being stuck in fetching state upon hydration\n {\n ...state,\n data,\n fetchStatus: 'idle',\n // Like above, if the query was pending at the moment of dehydration but has data,\n // we can assume it should be hydrated as successful.\n status:\n state.status === 'pending' && data !== undefined\n ? 'success'\n : state.status,\n ...(state.status === 'pending' &&\n data !== undefined && {\n dataUpdatedAt: dehydratedAt,\n }),\n },\n )\n }\n\n if (\n promise &&\n // If the data was synchronously available, there is no need to set up\n // a retryer and thus no reason to call fetch\n !syncData &&\n !existingQueryIsPending &&\n !existingQueryIsFetching &&\n // Only hydrate if dehydration is newer than any existing data,\n // this is always true for new queries\n dehydratedAt > query.state.dataUpdatedAt\n ) {\n // This doesn't actually fetch - it just creates a retryer\n // which will re-use the passed `initialPromise`\n query\n .fetch(undefined, {\n // RSC transformed promises are not thenable\n initialPromise: Promise.resolve(promise).then(deserializeData),\n })\n // Avoid unhandled promise rejections\n .catch(noop)\n }\n },\n )\n}\n"],"mappings":"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"}
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"index.cjs","names":[],"sources":["../../src/index.ts"],"sourcesContent":["/* istanbul ignore file */\n\nexport { focusManager } from './focusManager'\nexport type { FocusManager } from './focusManager'\nexport { environmentManager } from './environmentManager'\nexport {\n defaultShouldDehydrateMutation,\n defaultShouldDehydrateQuery,\n dehydrate,\n dehydrateQuery,\n hydrate,\n} from './hydration'\nexport { InfiniteQueryObserver } from './infiniteQueryObserver'\nexport { MutationCache } from './mutationCache'\nexport type { MutationCacheNotifyEvent } from './mutationCache'\nexport { MutationObserver } from './mutationObserver'\nexport { defaultScheduler, notifyManager } from './notifyManager'\nexport { onlineManager } from './onlineManager'\nexport type { OnlineManager } from './onlineManager'\nexport { QueriesObserver } from './queriesObserver'\nexport { QueryCache } from './queryCache'\nexport type { QueryCacheNotifyEvent } from './queryCache'\nexport { QueryClient } from './queryClient'\nexport { QueryObserver } from './queryObserver'\nexport { CancelledError, isCancelledError } from './retryer'\nexport {\n timeoutManager,\n type ManagedTimerId,\n type TimeoutCallback,\n type TimeoutManager,\n type TimeoutProvider,\n} from './timeoutManager'\nexport {\n hashKey,\n isServer,\n keepPreviousData,\n matchMutation,\n matchQuery,\n noop,\n partialMatchKey,\n replaceEqualDeep,\n shouldThrowError,\n skipToken,\n} from './utils'\nexport type { MutationFilters, QueryFilters, SkipToken, Updater } from './utils'\n\nexport { streamedQuery as experimental_streamedQuery } from './streamedQuery'\n\n// Types\nexport type {\n DehydratedState,\n DehydrateOptions,\n HydrateOptions,\n} from './hydration'\nexport { Mutation } from './mutation'\nexport type { MutationState } from './mutation'\nexport type { MutationCacheConfig } from './mutationCache'\nexport type { QueriesObserverOptions } from './queriesObserver'\nexport { Query } from './query'\nexport type { QueryState } from './query'\nexport type { QueryCacheConfig } from './queryCache'\nexport
|
|
1
|
+
{"version":3,"file":"index.cjs","names":[],"sources":["../../src/index.ts"],"sourcesContent":["/* istanbul ignore file */\n\nexport { focusManager } from './focusManager'\nexport type { FocusManager } from './focusManager'\nexport { environmentManager } from './environmentManager'\nexport {\n defaultShouldDehydrateMutation,\n defaultShouldDehydrateQuery,\n dehydrate,\n dehydrateQuery,\n hydrate,\n} from './hydration'\nexport { InfiniteQueryObserver } from './infiniteQueryObserver'\nexport { MutationCache } from './mutationCache'\nexport type { MutationCacheNotifyEvent } from './mutationCache'\nexport { MutationObserver } from './mutationObserver'\nexport { defaultScheduler, notifyManager } from './notifyManager'\nexport { onlineManager } from './onlineManager'\nexport type { OnlineManager } from './onlineManager'\nexport { QueriesObserver } from './queriesObserver'\nexport { QueryCache } from './queryCache'\nexport type { QueryCacheNotifyEvent } from './queryCache'\nexport { QueryClient } from './queryClient'\nexport { QueryObserver } from './queryObserver'\nexport { CancelledError, isCancelledError } from './retryer'\nexport {\n timeoutManager,\n type ManagedTimerId,\n type TimeoutCallback,\n type TimeoutManager,\n type TimeoutProvider,\n} from './timeoutManager'\nexport {\n hashKey,\n isServer,\n keepPreviousData,\n matchMutation,\n matchQuery,\n noop,\n partialMatchKey,\n replaceEqualDeep,\n shouldThrowError,\n skipToken,\n} from './utils'\nexport type { MutationFilters, QueryFilters, SkipToken, Updater } from './utils'\n\nexport { streamedQuery as experimental_streamedQuery } from './streamedQuery'\n\n// Types\nexport type {\n DehydratedState,\n DehydrateOptions,\n HydrateOptions,\n} from './hydration'\nexport { Mutation } from './mutation'\nexport type { MutationState } from './mutation'\nexport type { MutationCacheConfig } from './mutationCache'\nexport type { QueriesObserverOptions } from './queriesObserver'\nexport { Query } from './query'\nexport type { QueryState } from './query'\nexport type { QueryCacheConfig } from './queryCache'\nexport { dataTagSymbol, dataTagErrorSymbol, unsetMarker } from './types'\nexport type {\n NonUndefinedGuard,\n DistributiveOmit,\n OmitKeyof,\n Override,\n Register,\n DefaultError,\n QueryKey,\n UnsetMarker,\n AnyDataTag,\n DataTag,\n QueryKeyWithDataTag,\n InferDataFromTag,\n InferErrorFromTag,\n QueryFunction,\n StaleTime,\n StaleTimeFunction,\n QueryBooleanOption,\n QueryPersister,\n QueryFunctionContext,\n InitialDataFunction,\n PlaceholderDataFunction,\n QueriesPlaceholderDataFunction,\n QueryKeyHashFunction,\n GetPreviousPageParamFunction,\n GetNextPageParamFunction,\n InfiniteData,\n QueryMeta,\n NetworkMode,\n NotifyOnChangeProps,\n QueryOptions,\n InitialPageParam,\n InfiniteQueryPageParamsOptions,\n ThrowOnError,\n QueryObserverOptions,\n WithRequired,\n DefaultedQueryObserverOptions,\n InfiniteQueryObserverOptions,\n DefaultedInfiniteQueryObserverOptions,\n QueryExecuteOptions,\n FetchQueryOptions,\n EnsureQueryDataOptions,\n EnsureInfiniteQueryDataOptions,\n InfiniteQueryExecuteOptions,\n FetchInfiniteQueryOptions,\n ResultOptions,\n RefetchOptions,\n InvalidateQueryFilters,\n RefetchQueryFilters,\n InvalidateOptions,\n ResetOptions,\n FetchNextPageOptions,\n FetchPreviousPageOptions,\n QueryStatus,\n FetchStatus,\n QueryObserverBaseResult,\n QueryObserverPendingResult,\n QueryObserverLoadingResult,\n QueryObserverLoadingErrorResult,\n QueryObserverRefetchErrorResult,\n QueryObserverSuccessResult,\n QueryObserverPlaceholderResult,\n DefinedQueryObserverResult,\n QueryObserverResult,\n InfiniteQueryObserverBaseResult,\n InfiniteQueryObserverPendingResult,\n InfiniteQueryObserverLoadingResult,\n InfiniteQueryObserverLoadingErrorResult,\n InfiniteQueryObserverRefetchErrorResult,\n InfiniteQueryObserverSuccessResult,\n InfiniteQueryObserverPlaceholderResult,\n DefinedInfiniteQueryObserverResult,\n InfiniteQueryObserverResult,\n MutationKey,\n MutationStatus,\n MutationScope,\n MutationMeta,\n MutationFunctionContext,\n MutationFunction,\n MutationOptions,\n MutationObserverOptions,\n MutateOptions,\n MutateFunctionRest,\n MutateFunction,\n MutationObserverBaseResult,\n MutationObserverIdleResult,\n MutationObserverLoadingResult,\n MutationObserverErrorResult,\n MutationObserverSuccessResult,\n MutationObserverResult,\n QueryClientConfig,\n DefaultOptions,\n CancelOptions,\n SetDataOptions,\n NotifyEventType,\n NotifyEvent,\n} from './types'\n"],"mappings":""}
|
package/build/modern/index.d.cts
CHANGED
|
@@ -1,10 +1,10 @@
|
|
|
1
1
|
import { environmentManager } from "./environmentManager.cjs";
|
|
2
2
|
import { FocusManager, focusManager } from "./focusManager.cjs";
|
|
3
|
-
import { $ as
|
|
3
|
+
import { $ as InfiniteData, $n as CancelledError, $t as QueryObserverOptions, At as MutationScope, B as DefinedQueryObserverResult, Bn as keepPreviousData, Bt as QueriesPlaceholderDataFunction, Cn as MutationFilters, Ct as MutationObserverErrorResult, D as Query, Dn as Updater, Dt as MutationObserverResult, En as SkipToken, Et as MutationObserverOptions, F as DefaultError, Ft as NotifyEventType, G as FetchNextPageOptions, Gt as QueryFunctionContext, H as EnsureInfiniteQueryDataOptions, Hn as matchQuery, Ht as QueryClientConfig, I as DefaultOptions, It as NotifyOnChangeProps, J as FetchStatus, Jt as QueryKeyWithDataTag, K as FetchPreviousPageOptions, Kn as replaceEqualDeep, Kt as QueryKey, L as DefaultedInfiniteQueryObserverOptions, Lt as OmitKeyof, M as AnyDataTag, Mt as NetworkMode, N as CancelOptions, Nt as NonUndefinedGuard, Ot as MutationObserverSuccessResult, P as DataTag, Pn as hashKey, Pt as NotifyEvent, Q as InferErrorFromTag, Qt as QueryObserverLoadingResult, R as DefaultedQueryObserverOptions, Rn as isServer, Rt as Override, St as MutationObserverBaseResult, Tt as MutationObserverLoadingResult, U as EnsureQueryDataOptions, Un as noop, Ut as QueryExecuteOptions, V as DistributiveOmit, Vn as matchMutation, Vt as QueryBooleanOption, W as FetchInfiniteQueryOptions, Wn as partialMatchKey, Wt as QueryFunction, X as GetPreviousPageParamFunction, Xn as skipToken, Xt as QueryObserverBaseResult, Y as GetNextPageParamFunction, Yn as shouldThrowError, Yt as QueryMeta, Z as InferDataFromTag, Zt as QueryObserverLoadingErrorResult, _ as QueryClient, _n as UnsetMarker, _t as MutateOptions, a as defaultShouldDehydrateQuery, an as QueryOptions, ar as isCancelledError, at as InfiniteQueryObserverPendingResult, b as QueryCacheNotifyEvent, bn as dataTagSymbol, bt as MutationKey, c as hydrate, cn as RefetchOptions, ct as InfiniteQueryObserverResult, d as MutationState, dn as ResetOptions, dt as InitialDataFunction, en as QueryObserverPendingResult, et as InfiniteQueryExecuteOptions, fn as ResultOptions, ft as InitialPageParam, g as MutationObserver, gn as ThrowOnError, gt as MutateFunctionRest, h as MutationCacheNotifyEvent, hn as StaleTimeFunction, ht as MutateFunction, i as defaultShouldDehydrateMutation, in as QueryObserverSuccessResult, it as InfiniteQueryObserverOptions, j as QueryObserver, jt as MutationStatus, k as QueryState, kt as MutationOptions, ln as RefetchQueryFilters, lt as InfiniteQueryObserverSuccessResult, m as MutationCacheConfig, mn as StaleTime, mt as InvalidateQueryFilters, n as DehydratedState, nn as QueryObserverRefetchErrorResult, nt as InfiniteQueryObserverLoadingErrorResult, o as dehydrate, on as QueryPersister, ot as InfiniteQueryObserverPlaceholderResult, p as MutationCache, pn as SetDataOptions, pt as InvalidateOptions, q as FetchQueryOptions, qt as QueryKeyHashFunction, r as HydrateOptions, rn as QueryObserverResult, rt as InfiniteQueryObserverLoadingResult, s as dehydrateQuery, sn as QueryStatus, st as InfiniteQueryObserverRefetchErrorResult, t as DehydrateOptions, tn as QueryObserverPlaceholderResult, tt as InfiniteQueryObserverBaseResult, u as Mutation, un as Register, ut as InfiniteQueryPageParamsOptions, v as QueryCache, vn as WithRequired, vt as MutationFunction, wn as QueryFilters, wt as MutationObserverIdleResult, xn as unsetMarker, xt as MutationMeta, y as QueryCacheConfig, yn as dataTagErrorSymbol, yt as MutationFunctionContext, z as DefinedInfiniteQueryObserverResult, zt as PlaceholderDataFunction } from "./hydration-24GwbSaU.cjs";
|
|
4
4
|
import { InfiniteQueryObserver } from "./infiniteQueryObserver.cjs";
|
|
5
5
|
import { defaultScheduler, notifyManager } from "./notifyManager.cjs";
|
|
6
6
|
import { OnlineManager, onlineManager } from "./onlineManager.cjs";
|
|
7
7
|
import { QueriesObserver, QueriesObserverOptions } from "./queriesObserver.cjs";
|
|
8
8
|
import { ManagedTimerId, TimeoutCallback, TimeoutManager, TimeoutProvider, timeoutManager } from "./timeoutManager.cjs";
|
|
9
9
|
import { streamedQuery } from "./streamedQuery.cjs";
|
|
10
|
-
export { AnyDataTag, CancelOptions, CancelledError, DataTag, DefaultError, DefaultOptions, DefaultedInfiniteQueryObserverOptions, DefaultedQueryObserverOptions, DefinedInfiniteQueryObserverResult, DefinedQueryObserverResult, type DehydrateOptions, type DehydratedState, DistributiveOmit, EnsureInfiniteQueryDataOptions, EnsureQueryDataOptions, FetchInfiniteQueryOptions, FetchNextPageOptions, FetchPreviousPageOptions, FetchQueryOptions, FetchStatus, type FocusManager, GetNextPageParamFunction, GetPreviousPageParamFunction, type HydrateOptions, InferDataFromTag, InferErrorFromTag, InfiniteData, InfiniteQueryExecuteOptions, InfiniteQueryObserver, InfiniteQueryObserverBaseResult, InfiniteQueryObserverLoadingErrorResult, InfiniteQueryObserverLoadingResult, InfiniteQueryObserverOptions, InfiniteQueryObserverPendingResult, InfiniteQueryObserverPlaceholderResult, InfiniteQueryObserverRefetchErrorResult, InfiniteQueryObserverResult, InfiniteQueryObserverSuccessResult, InfiniteQueryPageParamsOptions, InitialDataFunction, InitialPageParam, InvalidateOptions, InvalidateQueryFilters, type ManagedTimerId, MutateFunction, MutateFunctionRest, MutateOptions, Mutation, MutationCache, type MutationCacheConfig, type MutationCacheNotifyEvent, type MutationFilters, MutationFunction, MutationFunctionContext, MutationKey, MutationMeta, MutationObserver, MutationObserverBaseResult, MutationObserverErrorResult, MutationObserverIdleResult, MutationObserverLoadingResult, MutationObserverOptions, MutationObserverResult, MutationObserverSuccessResult, MutationOptions, MutationScope, type MutationState, MutationStatus, NetworkMode, NonUndefinedGuard, NotifyEvent, NotifyEventType, NotifyOnChangeProps, OmitKeyof, type OnlineManager, Override, PlaceholderDataFunction, QueriesObserver, type QueriesObserverOptions, QueriesPlaceholderDataFunction, Query, QueryBooleanOption, QueryCache, type QueryCacheConfig, type QueryCacheNotifyEvent, QueryClient, QueryClientConfig, QueryExecuteOptions, type QueryFilters, QueryFunction, QueryFunctionContext, QueryKey, QueryKeyHashFunction, QueryKeyWithDataTag, QueryMeta, QueryObserver, QueryObserverBaseResult, QueryObserverLoadingErrorResult, QueryObserverLoadingResult, QueryObserverOptions, QueryObserverPendingResult, QueryObserverPlaceholderResult, QueryObserverRefetchErrorResult, QueryObserverResult, QueryObserverSuccessResult, QueryOptions, QueryPersister, type QueryState, QueryStatus, RefetchOptions, RefetchQueryFilters, Register, ResetOptions, ResultOptions, SetDataOptions, type SkipToken, StaleTime, StaleTimeFunction, ThrowOnError, type TimeoutCallback, type TimeoutManager, type TimeoutProvider, UnsetMarker, type Updater, WithRequired, dataTagErrorSymbol, dataTagSymbol, defaultScheduler, defaultShouldDehydrateMutation, defaultShouldDehydrateQuery, dehydrate, dehydrateQuery, environmentManager, streamedQuery as experimental_streamedQuery, focusManager, hashKey, hydrate, isCancelledError, isServer, keepPreviousData, matchMutation, matchQuery, noop, notifyManager, onlineManager, partialMatchKey, replaceEqualDeep, shouldThrowError, skipToken, timeoutManager, unsetMarker };
|
|
10
|
+
export { type AnyDataTag, type CancelOptions, CancelledError, type DataTag, type DefaultError, type DefaultOptions, type DefaultedInfiniteQueryObserverOptions, type DefaultedQueryObserverOptions, type DefinedInfiniteQueryObserverResult, type DefinedQueryObserverResult, type DehydrateOptions, type DehydratedState, type DistributiveOmit, type EnsureInfiniteQueryDataOptions, type EnsureQueryDataOptions, type FetchInfiniteQueryOptions, type FetchNextPageOptions, type FetchPreviousPageOptions, type FetchQueryOptions, type FetchStatus, type FocusManager, type GetNextPageParamFunction, type GetPreviousPageParamFunction, type HydrateOptions, type InferDataFromTag, type InferErrorFromTag, type InfiniteData, type InfiniteQueryExecuteOptions, InfiniteQueryObserver, type InfiniteQueryObserverBaseResult, type InfiniteQueryObserverLoadingErrorResult, type InfiniteQueryObserverLoadingResult, type InfiniteQueryObserverOptions, type InfiniteQueryObserverPendingResult, type InfiniteQueryObserverPlaceholderResult, type InfiniteQueryObserverRefetchErrorResult, type InfiniteQueryObserverResult, type InfiniteQueryObserverSuccessResult, type InfiniteQueryPageParamsOptions, type InitialDataFunction, type InitialPageParam, type InvalidateOptions, type InvalidateQueryFilters, type ManagedTimerId, type MutateFunction, type MutateFunctionRest, type MutateOptions, Mutation, MutationCache, type MutationCacheConfig, type MutationCacheNotifyEvent, type MutationFilters, type MutationFunction, type MutationFunctionContext, type MutationKey, type MutationMeta, MutationObserver, type MutationObserverBaseResult, type MutationObserverErrorResult, type MutationObserverIdleResult, type MutationObserverLoadingResult, type MutationObserverOptions, type MutationObserverResult, type MutationObserverSuccessResult, type MutationOptions, type MutationScope, type MutationState, type MutationStatus, type NetworkMode, type NonUndefinedGuard, type NotifyEvent, type NotifyEventType, type NotifyOnChangeProps, type OmitKeyof, type OnlineManager, type Override, type PlaceholderDataFunction, QueriesObserver, type QueriesObserverOptions, type QueriesPlaceholderDataFunction, Query, type QueryBooleanOption, QueryCache, type QueryCacheConfig, type QueryCacheNotifyEvent, QueryClient, type QueryClientConfig, type QueryExecuteOptions, type QueryFilters, type QueryFunction, type QueryFunctionContext, type QueryKey, type QueryKeyHashFunction, type QueryKeyWithDataTag, type QueryMeta, QueryObserver, type QueryObserverBaseResult, type QueryObserverLoadingErrorResult, type QueryObserverLoadingResult, type QueryObserverOptions, type QueryObserverPendingResult, type QueryObserverPlaceholderResult, type QueryObserverRefetchErrorResult, type QueryObserverResult, type QueryObserverSuccessResult, type QueryOptions, type QueryPersister, type QueryState, type QueryStatus, type RefetchOptions, type RefetchQueryFilters, type Register, type ResetOptions, type ResultOptions, type SetDataOptions, type SkipToken, type StaleTime, type StaleTimeFunction, type ThrowOnError, type TimeoutCallback, type TimeoutManager, type TimeoutProvider, type UnsetMarker, type Updater, type WithRequired, dataTagErrorSymbol, dataTagSymbol, defaultScheduler, defaultShouldDehydrateMutation, defaultShouldDehydrateQuery, dehydrate, dehydrateQuery, environmentManager, streamedQuery as experimental_streamedQuery, focusManager, hashKey, hydrate, isCancelledError, isServer, keepPreviousData, matchMutation, matchQuery, noop, notifyManager, onlineManager, partialMatchKey, replaceEqualDeep, shouldThrowError, skipToken, timeoutManager, unsetMarker };
|
package/build/modern/index.d.ts
CHANGED
|
@@ -1,10 +1,10 @@
|
|
|
1
1
|
import { environmentManager } from "./environmentManager.js";
|
|
2
2
|
import { FocusManager, focusManager } from "./focusManager.js";
|
|
3
|
-
import { $ as
|
|
3
|
+
import { $ as InfiniteData, $n as CancelledError, $t as QueryObserverOptions, At as MutationScope, B as DefinedQueryObserverResult, Bn as keepPreviousData, Bt as QueriesPlaceholderDataFunction, Cn as MutationFilters, Ct as MutationObserverErrorResult, D as Query, Dn as Updater, Dt as MutationObserverResult, En as SkipToken, Et as MutationObserverOptions, F as DefaultError, Ft as NotifyEventType, G as FetchNextPageOptions, Gt as QueryFunctionContext, H as EnsureInfiniteQueryDataOptions, Hn as matchQuery, Ht as QueryClientConfig, I as DefaultOptions, It as NotifyOnChangeProps, J as FetchStatus, Jt as QueryKeyWithDataTag, K as FetchPreviousPageOptions, Kn as replaceEqualDeep, Kt as QueryKey, L as DefaultedInfiniteQueryObserverOptions, Lt as OmitKeyof, M as AnyDataTag, Mt as NetworkMode, N as CancelOptions, Nt as NonUndefinedGuard, Ot as MutationObserverSuccessResult, P as DataTag, Pn as hashKey, Pt as NotifyEvent, Q as InferErrorFromTag, Qt as QueryObserverLoadingResult, R as DefaultedQueryObserverOptions, Rn as isServer, Rt as Override, St as MutationObserverBaseResult, Tt as MutationObserverLoadingResult, U as EnsureQueryDataOptions, Un as noop, Ut as QueryExecuteOptions, V as DistributiveOmit, Vn as matchMutation, Vt as QueryBooleanOption, W as FetchInfiniteQueryOptions, Wn as partialMatchKey, Wt as QueryFunction, X as GetPreviousPageParamFunction, Xn as skipToken, Xt as QueryObserverBaseResult, Y as GetNextPageParamFunction, Yn as shouldThrowError, Yt as QueryMeta, Z as InferDataFromTag, Zt as QueryObserverLoadingErrorResult, _ as QueryClient, _n as UnsetMarker, _t as MutateOptions, a as defaultShouldDehydrateQuery, an as QueryOptions, ar as isCancelledError, at as InfiniteQueryObserverPendingResult, b as QueryCacheNotifyEvent, bn as dataTagSymbol, bt as MutationKey, c as hydrate, cn as RefetchOptions, ct as InfiniteQueryObserverResult, d as MutationState, dn as ResetOptions, dt as InitialDataFunction, en as QueryObserverPendingResult, et as InfiniteQueryExecuteOptions, fn as ResultOptions, ft as InitialPageParam, g as MutationObserver, gn as ThrowOnError, gt as MutateFunctionRest, h as MutationCacheNotifyEvent, hn as StaleTimeFunction, ht as MutateFunction, i as defaultShouldDehydrateMutation, in as QueryObserverSuccessResult, it as InfiniteQueryObserverOptions, j as QueryObserver, jt as MutationStatus, k as QueryState, kt as MutationOptions, ln as RefetchQueryFilters, lt as InfiniteQueryObserverSuccessResult, m as MutationCacheConfig, mn as StaleTime, mt as InvalidateQueryFilters, n as DehydratedState, nn as QueryObserverRefetchErrorResult, nt as InfiniteQueryObserverLoadingErrorResult, o as dehydrate, on as QueryPersister, ot as InfiniteQueryObserverPlaceholderResult, p as MutationCache, pn as SetDataOptions, pt as InvalidateOptions, q as FetchQueryOptions, qt as QueryKeyHashFunction, r as HydrateOptions, rn as QueryObserverResult, rt as InfiniteQueryObserverLoadingResult, s as dehydrateQuery, sn as QueryStatus, st as InfiniteQueryObserverRefetchErrorResult, t as DehydrateOptions, tn as QueryObserverPlaceholderResult, tt as InfiniteQueryObserverBaseResult, u as Mutation, un as Register, ut as InfiniteQueryPageParamsOptions, v as QueryCache, vn as WithRequired, vt as MutationFunction, wn as QueryFilters, wt as MutationObserverIdleResult, xn as unsetMarker, xt as MutationMeta, y as QueryCacheConfig, yn as dataTagErrorSymbol, yt as MutationFunctionContext, z as DefinedInfiniteQueryObserverResult, zt as PlaceholderDataFunction } from "./hydration-Cbq_heQS.js";
|
|
4
4
|
import { InfiniteQueryObserver } from "./infiniteQueryObserver.js";
|
|
5
5
|
import { defaultScheduler, notifyManager } from "./notifyManager.js";
|
|
6
6
|
import { OnlineManager, onlineManager } from "./onlineManager.js";
|
|
7
7
|
import { QueriesObserver, QueriesObserverOptions } from "./queriesObserver.js";
|
|
8
8
|
import { ManagedTimerId, TimeoutCallback, TimeoutManager, TimeoutProvider, timeoutManager } from "./timeoutManager.js";
|
|
9
9
|
import { streamedQuery } from "./streamedQuery.js";
|
|
10
|
-
export { AnyDataTag, CancelOptions, CancelledError, DataTag, DefaultError, DefaultOptions, DefaultedInfiniteQueryObserverOptions, DefaultedQueryObserverOptions, DefinedInfiniteQueryObserverResult, DefinedQueryObserverResult, type DehydrateOptions, type DehydratedState, DistributiveOmit, EnsureInfiniteQueryDataOptions, EnsureQueryDataOptions, FetchInfiniteQueryOptions, FetchNextPageOptions, FetchPreviousPageOptions, FetchQueryOptions, FetchStatus, type FocusManager, GetNextPageParamFunction, GetPreviousPageParamFunction, type HydrateOptions, InferDataFromTag, InferErrorFromTag, InfiniteData, InfiniteQueryExecuteOptions, InfiniteQueryObserver, InfiniteQueryObserverBaseResult, InfiniteQueryObserverLoadingErrorResult, InfiniteQueryObserverLoadingResult, InfiniteQueryObserverOptions, InfiniteQueryObserverPendingResult, InfiniteQueryObserverPlaceholderResult, InfiniteQueryObserverRefetchErrorResult, InfiniteQueryObserverResult, InfiniteQueryObserverSuccessResult, InfiniteQueryPageParamsOptions, InitialDataFunction, InitialPageParam, InvalidateOptions, InvalidateQueryFilters, type ManagedTimerId, MutateFunction, MutateFunctionRest, MutateOptions, Mutation, MutationCache, type MutationCacheConfig, type MutationCacheNotifyEvent, type MutationFilters, MutationFunction, MutationFunctionContext, MutationKey, MutationMeta, MutationObserver, MutationObserverBaseResult, MutationObserverErrorResult, MutationObserverIdleResult, MutationObserverLoadingResult, MutationObserverOptions, MutationObserverResult, MutationObserverSuccessResult, MutationOptions, MutationScope, type MutationState, MutationStatus, NetworkMode, NonUndefinedGuard, NotifyEvent, NotifyEventType, NotifyOnChangeProps, OmitKeyof, type OnlineManager, Override, PlaceholderDataFunction, QueriesObserver, type QueriesObserverOptions, QueriesPlaceholderDataFunction, Query, QueryBooleanOption, QueryCache, type QueryCacheConfig, type QueryCacheNotifyEvent, QueryClient, QueryClientConfig, QueryExecuteOptions, type QueryFilters, QueryFunction, QueryFunctionContext, QueryKey, QueryKeyHashFunction, QueryKeyWithDataTag, QueryMeta, QueryObserver, QueryObserverBaseResult, QueryObserverLoadingErrorResult, QueryObserverLoadingResult, QueryObserverOptions, QueryObserverPendingResult, QueryObserverPlaceholderResult, QueryObserverRefetchErrorResult, QueryObserverResult, QueryObserverSuccessResult, QueryOptions, QueryPersister, type QueryState, QueryStatus, RefetchOptions, RefetchQueryFilters, Register, ResetOptions, ResultOptions, SetDataOptions, type SkipToken, StaleTime, StaleTimeFunction, ThrowOnError, type TimeoutCallback, type TimeoutManager, type TimeoutProvider, UnsetMarker, type Updater, WithRequired, dataTagErrorSymbol, dataTagSymbol, defaultScheduler, defaultShouldDehydrateMutation, defaultShouldDehydrateQuery, dehydrate, dehydrateQuery, environmentManager, streamedQuery as experimental_streamedQuery, focusManager, hashKey, hydrate, isCancelledError, isServer, keepPreviousData, matchMutation, matchQuery, noop, notifyManager, onlineManager, partialMatchKey, replaceEqualDeep, shouldThrowError, skipToken, timeoutManager, unsetMarker };
|
|
10
|
+
export { type AnyDataTag, type CancelOptions, CancelledError, type DataTag, type DefaultError, type DefaultOptions, type DefaultedInfiniteQueryObserverOptions, type DefaultedQueryObserverOptions, type DefinedInfiniteQueryObserverResult, type DefinedQueryObserverResult, type DehydrateOptions, type DehydratedState, type DistributiveOmit, type EnsureInfiniteQueryDataOptions, type EnsureQueryDataOptions, type FetchInfiniteQueryOptions, type FetchNextPageOptions, type FetchPreviousPageOptions, type FetchQueryOptions, type FetchStatus, type FocusManager, type GetNextPageParamFunction, type GetPreviousPageParamFunction, type HydrateOptions, type InferDataFromTag, type InferErrorFromTag, type InfiniteData, type InfiniteQueryExecuteOptions, InfiniteQueryObserver, type InfiniteQueryObserverBaseResult, type InfiniteQueryObserverLoadingErrorResult, type InfiniteQueryObserverLoadingResult, type InfiniteQueryObserverOptions, type InfiniteQueryObserverPendingResult, type InfiniteQueryObserverPlaceholderResult, type InfiniteQueryObserverRefetchErrorResult, type InfiniteQueryObserverResult, type InfiniteQueryObserverSuccessResult, type InfiniteQueryPageParamsOptions, type InitialDataFunction, type InitialPageParam, type InvalidateOptions, type InvalidateQueryFilters, type ManagedTimerId, type MutateFunction, type MutateFunctionRest, type MutateOptions, Mutation, MutationCache, type MutationCacheConfig, type MutationCacheNotifyEvent, type MutationFilters, type MutationFunction, type MutationFunctionContext, type MutationKey, type MutationMeta, MutationObserver, type MutationObserverBaseResult, type MutationObserverErrorResult, type MutationObserverIdleResult, type MutationObserverLoadingResult, type MutationObserverOptions, type MutationObserverResult, type MutationObserverSuccessResult, type MutationOptions, type MutationScope, type MutationState, type MutationStatus, type NetworkMode, type NonUndefinedGuard, type NotifyEvent, type NotifyEventType, type NotifyOnChangeProps, type OmitKeyof, type OnlineManager, type Override, type PlaceholderDataFunction, QueriesObserver, type QueriesObserverOptions, type QueriesPlaceholderDataFunction, Query, type QueryBooleanOption, QueryCache, type QueryCacheConfig, type QueryCacheNotifyEvent, QueryClient, type QueryClientConfig, type QueryExecuteOptions, type QueryFilters, type QueryFunction, type QueryFunctionContext, type QueryKey, type QueryKeyHashFunction, type QueryKeyWithDataTag, type QueryMeta, QueryObserver, type QueryObserverBaseResult, type QueryObserverLoadingErrorResult, type QueryObserverLoadingResult, type QueryObserverOptions, type QueryObserverPendingResult, type QueryObserverPlaceholderResult, type QueryObserverRefetchErrorResult, type QueryObserverResult, type QueryObserverSuccessResult, type QueryOptions, type QueryPersister, type QueryState, type QueryStatus, type RefetchOptions, type RefetchQueryFilters, type Register, type ResetOptions, type ResultOptions, type SetDataOptions, type SkipToken, type StaleTime, type StaleTimeFunction, type ThrowOnError, type TimeoutCallback, type TimeoutManager, type TimeoutProvider, type UnsetMarker, type Updater, type WithRequired, dataTagErrorSymbol, dataTagSymbol, defaultScheduler, defaultShouldDehydrateMutation, defaultShouldDehydrateQuery, dehydrate, dehydrateQuery, environmentManager, streamedQuery as experimental_streamedQuery, focusManager, hashKey, hydrate, isCancelledError, isServer, keepPreviousData, matchMutation, matchQuery, noop, notifyManager, onlineManager, partialMatchKey, replaceEqualDeep, shouldThrowError, skipToken, timeoutManager, unsetMarker };
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"index.js","names":[],"sources":["../../src/index.ts"],"sourcesContent":["/* istanbul ignore file */\n\nexport { focusManager } from './focusManager'\nexport type { FocusManager } from './focusManager'\nexport { environmentManager } from './environmentManager'\nexport {\n defaultShouldDehydrateMutation,\n defaultShouldDehydrateQuery,\n dehydrate,\n dehydrateQuery,\n hydrate,\n} from './hydration'\nexport { InfiniteQueryObserver } from './infiniteQueryObserver'\nexport { MutationCache } from './mutationCache'\nexport type { MutationCacheNotifyEvent } from './mutationCache'\nexport { MutationObserver } from './mutationObserver'\nexport { defaultScheduler, notifyManager } from './notifyManager'\nexport { onlineManager } from './onlineManager'\nexport type { OnlineManager } from './onlineManager'\nexport { QueriesObserver } from './queriesObserver'\nexport { QueryCache } from './queryCache'\nexport type { QueryCacheNotifyEvent } from './queryCache'\nexport { QueryClient } from './queryClient'\nexport { QueryObserver } from './queryObserver'\nexport { CancelledError, isCancelledError } from './retryer'\nexport {\n timeoutManager,\n type ManagedTimerId,\n type TimeoutCallback,\n type TimeoutManager,\n type TimeoutProvider,\n} from './timeoutManager'\nexport {\n hashKey,\n isServer,\n keepPreviousData,\n matchMutation,\n matchQuery,\n noop,\n partialMatchKey,\n replaceEqualDeep,\n shouldThrowError,\n skipToken,\n} from './utils'\nexport type { MutationFilters, QueryFilters, SkipToken, Updater } from './utils'\n\nexport { streamedQuery as experimental_streamedQuery } from './streamedQuery'\n\n// Types\nexport type {\n DehydratedState,\n DehydrateOptions,\n HydrateOptions,\n} from './hydration'\nexport { Mutation } from './mutation'\nexport type { MutationState } from './mutation'\nexport type { MutationCacheConfig } from './mutationCache'\nexport type { QueriesObserverOptions } from './queriesObserver'\nexport { Query } from './query'\nexport type { QueryState } from './query'\nexport type { QueryCacheConfig } from './queryCache'\nexport
|
|
1
|
+
{"version":3,"file":"index.js","names":[],"sources":["../../src/index.ts"],"sourcesContent":["/* istanbul ignore file */\n\nexport { focusManager } from './focusManager'\nexport type { FocusManager } from './focusManager'\nexport { environmentManager } from './environmentManager'\nexport {\n defaultShouldDehydrateMutation,\n defaultShouldDehydrateQuery,\n dehydrate,\n dehydrateQuery,\n hydrate,\n} from './hydration'\nexport { InfiniteQueryObserver } from './infiniteQueryObserver'\nexport { MutationCache } from './mutationCache'\nexport type { MutationCacheNotifyEvent } from './mutationCache'\nexport { MutationObserver } from './mutationObserver'\nexport { defaultScheduler, notifyManager } from './notifyManager'\nexport { onlineManager } from './onlineManager'\nexport type { OnlineManager } from './onlineManager'\nexport { QueriesObserver } from './queriesObserver'\nexport { QueryCache } from './queryCache'\nexport type { QueryCacheNotifyEvent } from './queryCache'\nexport { QueryClient } from './queryClient'\nexport { QueryObserver } from './queryObserver'\nexport { CancelledError, isCancelledError } from './retryer'\nexport {\n timeoutManager,\n type ManagedTimerId,\n type TimeoutCallback,\n type TimeoutManager,\n type TimeoutProvider,\n} from './timeoutManager'\nexport {\n hashKey,\n isServer,\n keepPreviousData,\n matchMutation,\n matchQuery,\n noop,\n partialMatchKey,\n replaceEqualDeep,\n shouldThrowError,\n skipToken,\n} from './utils'\nexport type { MutationFilters, QueryFilters, SkipToken, Updater } from './utils'\n\nexport { streamedQuery as experimental_streamedQuery } from './streamedQuery'\n\n// Types\nexport type {\n DehydratedState,\n DehydrateOptions,\n HydrateOptions,\n} from './hydration'\nexport { Mutation } from './mutation'\nexport type { MutationState } from './mutation'\nexport type { MutationCacheConfig } from './mutationCache'\nexport type { QueriesObserverOptions } from './queriesObserver'\nexport { Query } from './query'\nexport type { QueryState } from './query'\nexport type { QueryCacheConfig } from './queryCache'\nexport { dataTagSymbol, dataTagErrorSymbol, unsetMarker } from './types'\nexport type {\n NonUndefinedGuard,\n DistributiveOmit,\n OmitKeyof,\n Override,\n Register,\n DefaultError,\n QueryKey,\n UnsetMarker,\n AnyDataTag,\n DataTag,\n QueryKeyWithDataTag,\n InferDataFromTag,\n InferErrorFromTag,\n QueryFunction,\n StaleTime,\n StaleTimeFunction,\n QueryBooleanOption,\n QueryPersister,\n QueryFunctionContext,\n InitialDataFunction,\n PlaceholderDataFunction,\n QueriesPlaceholderDataFunction,\n QueryKeyHashFunction,\n GetPreviousPageParamFunction,\n GetNextPageParamFunction,\n InfiniteData,\n QueryMeta,\n NetworkMode,\n NotifyOnChangeProps,\n QueryOptions,\n InitialPageParam,\n InfiniteQueryPageParamsOptions,\n ThrowOnError,\n QueryObserverOptions,\n WithRequired,\n DefaultedQueryObserverOptions,\n InfiniteQueryObserverOptions,\n DefaultedInfiniteQueryObserverOptions,\n QueryExecuteOptions,\n FetchQueryOptions,\n EnsureQueryDataOptions,\n EnsureInfiniteQueryDataOptions,\n InfiniteQueryExecuteOptions,\n FetchInfiniteQueryOptions,\n ResultOptions,\n RefetchOptions,\n InvalidateQueryFilters,\n RefetchQueryFilters,\n InvalidateOptions,\n ResetOptions,\n FetchNextPageOptions,\n FetchPreviousPageOptions,\n QueryStatus,\n FetchStatus,\n QueryObserverBaseResult,\n QueryObserverPendingResult,\n QueryObserverLoadingResult,\n QueryObserverLoadingErrorResult,\n QueryObserverRefetchErrorResult,\n QueryObserverSuccessResult,\n QueryObserverPlaceholderResult,\n DefinedQueryObserverResult,\n QueryObserverResult,\n InfiniteQueryObserverBaseResult,\n InfiniteQueryObserverPendingResult,\n InfiniteQueryObserverLoadingResult,\n InfiniteQueryObserverLoadingErrorResult,\n InfiniteQueryObserverRefetchErrorResult,\n InfiniteQueryObserverSuccessResult,\n InfiniteQueryObserverPlaceholderResult,\n DefinedInfiniteQueryObserverResult,\n InfiniteQueryObserverResult,\n MutationKey,\n MutationStatus,\n MutationScope,\n MutationMeta,\n MutationFunctionContext,\n MutationFunction,\n MutationOptions,\n MutationObserverOptions,\n MutateOptions,\n MutateFunctionRest,\n MutateFunction,\n MutationObserverBaseResult,\n MutationObserverIdleResult,\n MutationObserverLoadingResult,\n MutationObserverErrorResult,\n MutationObserverSuccessResult,\n MutationObserverResult,\n QueryClientConfig,\n DefaultOptions,\n CancelOptions,\n SetDataOptions,\n NotifyEventType,\n NotifyEvent,\n} from './types'\n"],"mappings":""}
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"infiniteQueryBehavior.cjs","names":["fetchSignal","ensureQueryFn","addToStart","addToEnd"],"sources":["../../src/infiniteQueryBehavior.ts"],"sourcesContent":["import {\n addConsumeAwareSignal,\n addToEnd,\n addToStart,\n ensureQueryFn,\n fetchSignal,\n} from './utils'\nimport type {
|
|
1
|
+
{"version":3,"file":"infiniteQueryBehavior.cjs","names":["fetchSignal","ensureQueryFn","addToStart","addToEnd"],"sources":["../../src/infiniteQueryBehavior.ts"],"sourcesContent":["import {\n addConsumeAwareSignal,\n addToEnd,\n addToStart,\n ensureQueryFn,\n fetchSignal,\n} from './utils'\nimport type { QueryBehavior } from './query'\nimport type {\n InfiniteData,\n InfiniteQueryPageParamsOptions,\n OmitKeyof,\n QueryFunctionContext,\n QueryKey,\n} from './types'\nimport type { FetchSignalContext } from './utils'\n\n/**\n * Creates the behavior that fetches the pages of an infinite query: the next or previous page for\n * `fetchNextPage`/`fetchPreviousPage`, or all pages again from the start on a refetch.\n * @param pages - The number of pages to fetch from the start when all pages are fetched again,\n * e.g. from the `pages` option of `queryClient.infiniteQuery`. Defaults to the number of cached\n * pages.\n * @returns The query behavior to set on an infinite query.\n */\nexport function infiniteQueryBehavior<TQueryFnData, TError, TData, TPageParam>(\n pages?: number,\n): QueryBehavior<TQueryFnData, TError, InfiniteData<TData, TPageParam>> {\n return {\n onFetch: (context, query) => {\n const options = context.options as InfiniteQueryPageParamsOptions<TData>\n const direction = context.fetchOptions?.meta?.fetchMore?.direction\n const oldPages = context.state.data?.pages || []\n const oldPageParams = context.state.data?.pageParams || []\n let result: InfiniteData<unknown> = { pages: [], pageParams: [] }\n let currentPage = 0\n\n const fetchFn = async () => {\n let cancelled = false\n const signalContext: FetchSignalContext = context\n const addSignalProperty = (object: object) => {\n addConsumeAwareSignal(\n object,\n () => context.signal,\n () => (cancelled = true),\n signalContext[fetchSignal],\n )\n }\n\n const queryFn = ensureQueryFn(context.options, context.fetchOptions)\n\n // Create function to fetch a page\n const fetchPage = async (\n data: InfiniteData<unknown>,\n param: unknown,\n previous?: boolean,\n ): Promise<InfiniteData<unknown>> => {\n if (cancelled) {\n return Promise.reject(context.signal.reason)\n }\n\n if (param == null && data.pages.length) {\n return Promise.resolve(data)\n }\n\n const createQueryFnContext = () => {\n const queryFnContext: OmitKeyof<\n QueryFunctionContext<QueryKey, unknown>,\n 'signal'\n > = {\n client: context.client,\n queryKey: context.queryKey,\n pageParam: param,\n direction: previous ? 'backward' : 'forward',\n meta: context.options.meta,\n }\n addSignalProperty(queryFnContext)\n return queryFnContext as QueryFunctionContext<QueryKey, unknown>\n }\n\n const queryFnContext = createQueryFnContext()\n\n const page = await queryFn(queryFnContext)\n\n const { maxPages } = context.options\n const addTo = previous ? addToStart : addToEnd\n\n return {\n pages: addTo(data.pages, page, maxPages),\n pageParams: addTo(data.pageParams, param, maxPages),\n }\n }\n\n // fetch next / previous page?\n if (direction && oldPages.length) {\n const previous = direction === 'backward'\n const pageParamFn = previous ? getPreviousPageParam : getNextPageParam\n const oldData = {\n pages: oldPages,\n pageParams: oldPageParams,\n }\n const param = pageParamFn(options, oldData)\n\n result = await fetchPage(oldData, param, previous)\n } else {\n const remainingPages = pages ?? oldPages.length\n\n // Fetch all pages\n do {\n const param =\n currentPage === 0\n ? oldPageParams[0] === undefined\n ? options.initialPageParam\n : oldPageParams[0]\n : getNextPageParam(options, result)\n if (currentPage > 0 && param == null) {\n break\n }\n result = await fetchPage(result, param)\n currentPage++\n } while (currentPage < remainingPages)\n }\n\n return result\n }\n if (context.options.persister) {\n context.fetchFn = () => {\n return context.options.persister?.(\n fetchFn as any,\n {\n client: context.client,\n queryKey: context.queryKey,\n meta: context.options.meta,\n signal: context.signal,\n },\n query,\n )\n }\n } else {\n context.fetchFn = fetchFn\n }\n },\n }\n}\n\n/**\n * Computes the page param of the page after the last one, with the `getNextPageParam` option.\n * @param options - The infinite query options.\n * @param data - The current pages and page params.\n * @returns The next page param, or `undefined` if there are no pages yet.\n */\nfunction getNextPageParam(\n options: InfiniteQueryPageParamsOptions<any>,\n { pages, pageParams }: InfiniteData<unknown>,\n): unknown | undefined {\n const lastIndex = pages.length - 1\n return pages.length > 0\n ? options.getNextPageParam(\n pages[lastIndex],\n pages,\n pageParams[lastIndex],\n pageParams,\n )\n : undefined\n}\n\n/**\n * Computes the page param of the page before the first one, with the `getPreviousPageParam`\n * option.\n * @param options - The infinite query options.\n * @param data - The current pages and page params.\n * @returns The previous page param, or `undefined` if there are no pages yet or no\n * `getPreviousPageParam` option.\n */\nfunction getPreviousPageParam(\n options: InfiniteQueryPageParamsOptions<any>,\n { pages, pageParams }: InfiniteData<unknown>,\n): unknown | undefined {\n return pages.length > 0\n ? options.getPreviousPageParam?.(pages[0], pages, pageParams[0], pageParams)\n : undefined\n}\n\n/**\n * Checks if there is a next page.\n * @param options - The infinite query options with `getNextPageParam`.\n * @param data - The current pages and page params.\n * @returns `true` if `getNextPageParam` returns a value other than `null` or `undefined`.\n */\nexport function hasNextPage(\n options: InfiniteQueryPageParamsOptions<any, any>,\n data?: InfiniteData<unknown>,\n): boolean {\n if (!data) return false\n return getNextPageParam(options, data) != null\n}\n\n/**\n * Checks if there is a previous page.\n * @param options - The infinite query options with `getPreviousPageParam`.\n * @param data - The current pages and page params.\n * @returns `true` if `getPreviousPageParam` is set and returns a value other than `null` or\n * `undefined`.\n */\nexport function hasPreviousPage(\n options: InfiniteQueryPageParamsOptions<any, any>,\n data?: InfiniteData<unknown>,\n): boolean {\n if (!data || !options.getPreviousPageParam) return false\n return getPreviousPageParam(options, data) != null\n}\n"],"mappings":"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"}
|
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import {
|
|
1
|
+
import { $ as InfiniteData, O as QueryBehavior, ut as InfiniteQueryPageParamsOptions } from "./hydration-24GwbSaU.cjs";
|
|
2
2
|
/**
|
|
3
3
|
* Creates the behavior that fetches the pages of an infinite query: the next or previous page for
|
|
4
4
|
* `fetchNextPage`/`fetchPreviousPage`, or all pages again from the start on a refetch.
|
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import {
|
|
1
|
+
import { $ as InfiniteData, O as QueryBehavior, ut as InfiniteQueryPageParamsOptions } from "./hydration-Cbq_heQS.js";
|
|
2
2
|
/**
|
|
3
3
|
* Creates the behavior that fetches the pages of an infinite query: the next or previous page for
|
|
4
4
|
* `fetchNextPage`/`fetchPreviousPage`, or all pages again from the start on a refetch.
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"infiniteQueryBehavior.js","names":[],"sources":["../../src/infiniteQueryBehavior.ts"],"sourcesContent":["import {\n addConsumeAwareSignal,\n addToEnd,\n addToStart,\n ensureQueryFn,\n fetchSignal,\n} from './utils'\nimport type {
|
|
1
|
+
{"version":3,"file":"infiniteQueryBehavior.js","names":[],"sources":["../../src/infiniteQueryBehavior.ts"],"sourcesContent":["import {\n addConsumeAwareSignal,\n addToEnd,\n addToStart,\n ensureQueryFn,\n fetchSignal,\n} from './utils'\nimport type { QueryBehavior } from './query'\nimport type {\n InfiniteData,\n InfiniteQueryPageParamsOptions,\n OmitKeyof,\n QueryFunctionContext,\n QueryKey,\n} from './types'\nimport type { FetchSignalContext } from './utils'\n\n/**\n * Creates the behavior that fetches the pages of an infinite query: the next or previous page for\n * `fetchNextPage`/`fetchPreviousPage`, or all pages again from the start on a refetch.\n * @param pages - The number of pages to fetch from the start when all pages are fetched again,\n * e.g. from the `pages` option of `queryClient.infiniteQuery`. Defaults to the number of cached\n * pages.\n * @returns The query behavior to set on an infinite query.\n */\nexport function infiniteQueryBehavior<TQueryFnData, TError, TData, TPageParam>(\n pages?: number,\n): QueryBehavior<TQueryFnData, TError, InfiniteData<TData, TPageParam>> {\n return {\n onFetch: (context, query) => {\n const options = context.options as InfiniteQueryPageParamsOptions<TData>\n const direction = context.fetchOptions?.meta?.fetchMore?.direction\n const oldPages = context.state.data?.pages || []\n const oldPageParams = context.state.data?.pageParams || []\n let result: InfiniteData<unknown> = { pages: [], pageParams: [] }\n let currentPage = 0\n\n const fetchFn = async () => {\n let cancelled = false\n const signalContext: FetchSignalContext = context\n const addSignalProperty = (object: object) => {\n addConsumeAwareSignal(\n object,\n () => context.signal,\n () => (cancelled = true),\n signalContext[fetchSignal],\n )\n }\n\n const queryFn = ensureQueryFn(context.options, context.fetchOptions)\n\n // Create function to fetch a page\n const fetchPage = async (\n data: InfiniteData<unknown>,\n param: unknown,\n previous?: boolean,\n ): Promise<InfiniteData<unknown>> => {\n if (cancelled) {\n return Promise.reject(context.signal.reason)\n }\n\n if (param == null && data.pages.length) {\n return Promise.resolve(data)\n }\n\n const createQueryFnContext = () => {\n const queryFnContext: OmitKeyof<\n QueryFunctionContext<QueryKey, unknown>,\n 'signal'\n > = {\n client: context.client,\n queryKey: context.queryKey,\n pageParam: param,\n direction: previous ? 'backward' : 'forward',\n meta: context.options.meta,\n }\n addSignalProperty(queryFnContext)\n return queryFnContext as QueryFunctionContext<QueryKey, unknown>\n }\n\n const queryFnContext = createQueryFnContext()\n\n const page = await queryFn(queryFnContext)\n\n const { maxPages } = context.options\n const addTo = previous ? addToStart : addToEnd\n\n return {\n pages: addTo(data.pages, page, maxPages),\n pageParams: addTo(data.pageParams, param, maxPages),\n }\n }\n\n // fetch next / previous page?\n if (direction && oldPages.length) {\n const previous = direction === 'backward'\n const pageParamFn = previous ? getPreviousPageParam : getNextPageParam\n const oldData = {\n pages: oldPages,\n pageParams: oldPageParams,\n }\n const param = pageParamFn(options, oldData)\n\n result = await fetchPage(oldData, param, previous)\n } else {\n const remainingPages = pages ?? oldPages.length\n\n // Fetch all pages\n do {\n const param =\n currentPage === 0\n ? oldPageParams[0] === undefined\n ? options.initialPageParam\n : oldPageParams[0]\n : getNextPageParam(options, result)\n if (currentPage > 0 && param == null) {\n break\n }\n result = await fetchPage(result, param)\n currentPage++\n } while (currentPage < remainingPages)\n }\n\n return result\n }\n if (context.options.persister) {\n context.fetchFn = () => {\n return context.options.persister?.(\n fetchFn as any,\n {\n client: context.client,\n queryKey: context.queryKey,\n meta: context.options.meta,\n signal: context.signal,\n },\n query,\n )\n }\n } else {\n context.fetchFn = fetchFn\n }\n },\n }\n}\n\n/**\n * Computes the page param of the page after the last one, with the `getNextPageParam` option.\n * @param options - The infinite query options.\n * @param data - The current pages and page params.\n * @returns The next page param, or `undefined` if there are no pages yet.\n */\nfunction getNextPageParam(\n options: InfiniteQueryPageParamsOptions<any>,\n { pages, pageParams }: InfiniteData<unknown>,\n): unknown | undefined {\n const lastIndex = pages.length - 1\n return pages.length > 0\n ? options.getNextPageParam(\n pages[lastIndex],\n pages,\n pageParams[lastIndex],\n pageParams,\n )\n : undefined\n}\n\n/**\n * Computes the page param of the page before the first one, with the `getPreviousPageParam`\n * option.\n * @param options - The infinite query options.\n * @param data - The current pages and page params.\n * @returns The previous page param, or `undefined` if there are no pages yet or no\n * `getPreviousPageParam` option.\n */\nfunction getPreviousPageParam(\n options: InfiniteQueryPageParamsOptions<any>,\n { pages, pageParams }: InfiniteData<unknown>,\n): unknown | undefined {\n return pages.length > 0\n ? options.getPreviousPageParam?.(pages[0], pages, pageParams[0], pageParams)\n : undefined\n}\n\n/**\n * Checks if there is a next page.\n * @param options - The infinite query options with `getNextPageParam`.\n * @param data - The current pages and page params.\n * @returns `true` if `getNextPageParam` returns a value other than `null` or `undefined`.\n */\nexport function hasNextPage(\n options: InfiniteQueryPageParamsOptions<any, any>,\n data?: InfiniteData<unknown>,\n): boolean {\n if (!data) return false\n return getNextPageParam(options, data) != null\n}\n\n/**\n * Checks if there is a previous page.\n * @param options - The infinite query options with `getPreviousPageParam`.\n * @param data - The current pages and page params.\n * @returns `true` if `getPreviousPageParam` is set and returns a value other than `null` or\n * `undefined`.\n */\nexport function hasPreviousPage(\n options: InfiniteQueryPageParamsOptions<any, any>,\n data?: InfiniteData<unknown>,\n): boolean {\n if (!data || !options.getPreviousPageParam) return false\n return getPreviousPageParam(options, data) != null\n}\n"],"mappings":"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"}
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"infiniteQueryObserver.cjs","names":["QueryObserver","hasNextPage","hasPreviousPage"],"sources":["../../src/infiniteQueryObserver.ts"],"sourcesContent":["import { QueryObserver } from './queryObserver'\nimport {
|
|
1
|
+
{"version":3,"file":"infiniteQueryObserver.cjs","names":["QueryObserver","hasNextPage","hasPreviousPage"],"sources":["../../src/infiniteQueryObserver.ts"],"sourcesContent":["import { hasNextPage, hasPreviousPage } from './infiniteQueryBehavior'\nimport { QueryObserver } from './queryObserver'\nimport type { Query } from './query'\nimport type { QueryClient } from './queryClient'\nimport type { Subscribable } from './subscribable'\nimport type {\n DefaultError,\n DefaultedInfiniteQueryObserverOptions,\n FetchNextPageOptions,\n FetchPreviousPageOptions,\n InfiniteData,\n InfiniteQueryObserverBaseResult,\n InfiniteQueryObserverOptions,\n InfiniteQueryObserverResult,\n QueryKey,\n} from './types'\n\ntype InfiniteQueryObserverListener<TData, TError> = (\n result: InfiniteQueryObserverResult<TData, TError>,\n) => void\n\n/**\n * An `InfiniteQueryObserver` extends `QueryObserver` to observe and switch\n * between infinite queries. It augments the base `QueryObserverResult` with\n * infinite-query-specific fields and methods, such as `hasNextPage` and\n * `fetchNextPage`, and is the primitive that framework adapters (e.g.\n * `useInfiniteQuery`) build their hooks on top of.\n * @example\n * ```ts\n * const observer = new InfiniteQueryObserver(queryClient, {\n * queryKey: ['projects'],\n * queryFn: ({ pageParam }) => fetchProjects(pageParam),\n * initialPageParam: 0,\n * getNextPageParam: (lastPage) => lastPage.nextCursor,\n * })\n *\n * const unsubscribe = observer.subscribe((result) => console.log(result))\n * ```\n */\nexport class InfiniteQueryObserver<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> extends QueryObserver<\n TQueryFnData,\n TError,\n TData,\n InfiniteData<TQueryFnData, TPageParam>,\n TQueryKey\n> {\n // Type override\n override subscribe!: Subscribable<\n InfiniteQueryObserverListener<TData, TError>\n >['subscribe']\n\n // Type override\n override getCurrentResult!: ReplaceReturnType<\n QueryObserver<\n TQueryFnData,\n TError,\n TData,\n InfiniteData<TQueryFnData, TPageParam>,\n TQueryKey\n >['getCurrentResult'],\n InfiniteQueryObserverResult<TData, TError>\n >\n\n // Type override\n protected override fetch!: ReplaceReturnType<\n QueryObserver<\n TQueryFnData,\n TError,\n TData,\n InfiniteData<TQueryFnData, TPageParam>,\n TQueryKey\n >['fetch'],\n Promise<InfiniteQueryObserverResult<TData, TError>>\n >\n\n constructor(\n client: QueryClient,\n options: InfiniteQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n ) {\n super(client, options)\n }\n\n protected override bindMethods(): void {\n super.bindMethods()\n this.fetchNextPage = this.fetchNextPage.bind(this)\n this.fetchPreviousPage = this.fetchPreviousPage.bind(this)\n }\n\n /**\n * Updates the observer's options. Behaves the same as\n * `QueryObserver.setOptions`, additionally marking the options as\n * belonging to an infinite query before delegating to the base\n * implementation.\n * @param options - The new infinite query observer options.\n */\n override setOptions(\n options: InfiniteQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n ): void {\n options._type = 'infinite'\n super.setOptions(options)\n }\n\n /**\n * The infinite-query counterpart of {@link QueryObserver#getOptimisticResult}, marking the\n * options as an infinite query before delegating to it. Called by framework adapters (e.g.\n * `useInfiniteQuery`) ahead of subscribing, to compute the current `InfiniteQueryObserverResult`\n * synchronously.\n * @param options - The defaulted infinite query observer options to compute the result for.\n * @returns The result for the given options.\n */\n override getOptimisticResult(\n options: DefaultedInfiniteQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n ): InfiniteQueryObserverResult<TData, TError> {\n options._type = 'infinite'\n return super.getOptimisticResult(options) as InfiniteQueryObserverResult<\n TData,\n TError\n >\n }\n\n /**\n * Fetches the next page of the infinite query and returns a promise that\n * resolves with the resulting `InfiniteQueryObserverResult`. The page\n * param used for the fetch is determined by `getNextPageParam`, which\n * receives the current pages/page params and whose result also determines\n * `hasNextPage`.\n * @param options - Set `cancelRefetch` to `false` to ignore the call while a fetch is running,\n * and `throwOnError` to `true` to reject when the fetch fails.\n * @returns A promise that resolves with the result after the next page is fetched. With\n * `cancelRefetch: false`, a running fetch is reused instead, so the next page may not be fetched.\n * @see {@link InfiniteQueryObserver#fetchPreviousPage}\n * @example\n * ```ts\n * const { hasNextPage } = observer.getCurrentResult()\n *\n * if (hasNextPage) {\n * await observer.fetchNextPage()\n * }\n * ```\n */\n fetchNextPage(\n options?: FetchNextPageOptions,\n ): Promise<InfiniteQueryObserverResult<TData, TError>> {\n return this.fetch({\n ...options,\n meta: {\n fetchMore: { direction: 'forward' },\n },\n })\n }\n\n /**\n * Fetches the previous page of the infinite query and returns a promise\n * that resolves with the resulting `InfiniteQueryObserverResult`. The page\n * param used for the fetch is determined by `getPreviousPageParam`, which\n * receives the current pages/page params and whose result also determines\n * `hasPreviousPage`.\n * @param options - Set `cancelRefetch` to `false` to ignore the call while a fetch is running,\n * and `throwOnError` to `true` to reject when the fetch fails.\n * @returns A promise that resolves with the result after the previous page is fetched. With\n * `cancelRefetch: false`, a running fetch is reused instead, so the previous page may not be fetched.\n * @see {@link InfiniteQueryObserver#fetchNextPage}\n * @example\n * ```ts\n * const { hasPreviousPage } = observer.getCurrentResult()\n *\n * if (hasPreviousPage) {\n * await observer.fetchPreviousPage()\n * }\n * ```\n */\n fetchPreviousPage(\n options?: FetchPreviousPageOptions,\n ): Promise<InfiniteQueryObserverResult<TData, TError>> {\n return this.fetch({\n ...options,\n meta: {\n fetchMore: { direction: 'backward' },\n },\n })\n }\n\n protected override createResult(\n query: Query<\n TQueryFnData,\n TError,\n InfiniteData<TQueryFnData, TPageParam>,\n TQueryKey\n >,\n options: InfiniteQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n ): InfiniteQueryObserverResult<TData, TError> {\n const { state } = query\n const parentResult = super.createResult(query, options)\n\n const { isFetching, isRefetching, isError, isRefetchError } = parentResult\n const fetchDirection = state.fetchMeta?.fetchMore?.direction\n\n const isFetchNextPageError = isError && fetchDirection === 'forward'\n const isFetchingNextPage = isFetching && fetchDirection === 'forward'\n\n const isFetchPreviousPageError = isError && fetchDirection === 'backward'\n const isFetchingPreviousPage = isFetching && fetchDirection === 'backward'\n\n const result: InfiniteQueryObserverBaseResult<TData, TError> = {\n ...parentResult,\n fetchNextPage: this.fetchNextPage,\n fetchPreviousPage: this.fetchPreviousPage,\n hasNextPage: hasNextPage(options, state.data),\n hasPreviousPage: hasPreviousPage(options, state.data),\n isFetchNextPageError,\n isFetchingNextPage,\n isFetchPreviousPageError,\n isFetchingPreviousPage,\n isRefetchError:\n isRefetchError && !isFetchNextPageError && !isFetchPreviousPageError,\n isRefetching:\n isRefetching && !isFetchingNextPage && !isFetchingPreviousPage,\n }\n\n return result as InfiniteQueryObserverResult<TData, TError>\n }\n}\n\ntype ReplaceReturnType<\n TFunction extends (...args: Array<any>) => unknown,\n TReturn,\n> = (...args: Parameters<TFunction>) => TReturn\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAuCA,IAAa,wBAAb,cAMUA,sBAAAA,cAMR;CA8BA,YACE,QACA,SAOA;EACA,MAAM,QAAQ,OAAO;CACvB;CAEA,cAAuC;EACrC,MAAM,YAAY;EAClB,KAAK,gBAAgB,KAAK,cAAc,KAAK,IAAI;EACjD,KAAK,oBAAoB,KAAK,kBAAkB,KAAK,IAAI;CAC3D;;;;;;;;CASA,WACE,SAOM;EACN,QAAQ,QAAQ;EAChB,MAAM,WAAW,OAAO;CAC1B;;;;;;;;;CAUA,oBACE,SAO4C;EAC5C,QAAQ,QAAQ;EAChB,OAAO,MAAM,oBAAoB,OAAO;CAI1C;;;;;;;;;;;;;;;;;;;;;CAsBA,cACE,SACqD;EACrD,OAAO,KAAK,MAAM;GAChB,GAAG;GACH,MAAM,EACJ,WAAW,EAAE,WAAW,UAAU,EACpC;EACF,CAAC;CACH;;;;;;;;;;;;;;;;;;;;;CAsBA,kBACE,SACqD;EACrD,OAAO,KAAK,MAAM;GAChB,GAAG;GACH,MAAM,EACJ,WAAW,EAAE,WAAW,WAAW,EACrC;EACF,CAAC;CACH;CAEA,aACE,OAMA,SAO4C;EAC5C,MAAM,EAAE,UAAU;EAClB,MAAM,eAAe,MAAM,aAAa,OAAO,OAAO;EAEtD,MAAM,EAAE,YAAY,cAAc,SAAS,mBAAmB;EAC9D,MAAM,iBAAiB,MAAM,WAAW,WAAW;EAEnD,MAAM,uBAAuB,WAAW,mBAAmB;EAC3D,MAAM,qBAAqB,cAAc,mBAAmB;EAE5D,MAAM,2BAA2B,WAAW,mBAAmB;EAC/D,MAAM,yBAAyB,cAAc,mBAAmB;EAkBhE,OAAO;GAfL,GAAG;GACH,eAAe,KAAK;GACpB,mBAAmB,KAAK;GACxB,aAAaC,8BAAAA,YAAY,SAAS,MAAM,IAAI;GAC5C,iBAAiBC,8BAAAA,gBAAgB,SAAS,MAAM,IAAI;GACpD;GACA;GACA;GACA;GACA,gBACE,kBAAkB,CAAC,wBAAwB,CAAC;GAC9C,cACE,gBAAgB,CAAC,sBAAsB,CAAC;EAGhC;CACd;AACF"}
|