@tanstack/query-core 5.103.1 → 5.103.3

package/build/modern/hydration.d.cts

@@ -1,2 +1,2 @@
-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-DwR10Hi-.cjs";
+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-Br9VIGXa.cjs";
 export { DehydrateOptions, DehydratedState, HydrateOptions, defaultShouldDehydrateMutation, defaultShouldDehydrateQuery, dehydrate, dehydrateQuery, hydrate };

package/build/modern/hydration.d.ts

@@ -1,2 +1,2 @@
-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-Cq7QYAzB.js";
+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-B9t5w6NC.js";
 export { DehydrateOptions, DehydratedState, HydrateOptions, defaultShouldDehydrateMutation, defaultShouldDehydrateQuery, dehydrate, dehydrateQuery, hydrate };

package/build/modern/hydration.js.map

@@ -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\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  // eslint-disable-next-line @typescript-eslint/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  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  mutations: Array<DehydratedMutation>\n  queries: Array<DehydratedQuery>\n}\n\n// FUNCTIONS\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\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 */\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 */\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 */\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 * @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 * @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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"}
+{"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\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  // eslint-disable-next-line @typescript-eslint/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  mutations: Array<DehydratedMutation>\n  queries: Array<DehydratedQuery>\n}\n\n// FUNCTIONS\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\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 */\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 */\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 */\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 * @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 * @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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"}

package/build/modern/index.d.cts

@@ -1,6 +1,6 @@
 import { environmentManager } from "./environmentManager.cjs";
 import { FocusManager, focusManager } from "./focusManager.cjs";
-import { $ as MutationObserverBaseResult, $n as Query, $t as CancelledError, A as InfiniteData, An as noop, At as QueryObserverOptions, B as InfiniteQueryObserverSuccessResult, Bt as RefetchQueryFilters, C as FetchPreviousPageOptions, Ct as QueryKey, D as GetPreviousPageParamFunction, Dn as keepPreviousData, Dt as QueryObserverBaseResult, E as GetNextPageParamFunction, Et as QueryMeta, F as InfiniteQueryObserverOptions, Ft as QueryObserverSuccessResult, G as InvalidateQueryFilters, Gn as MutationCacheConfig, Gt as StaleTime, H as InitialDataFunction, Hn as MutationState, Ht as ResetOptions, I as InfiniteQueryObserverPendingResult, In as shouldThrowError, It as QueryOptions, J as MutateOptions, Jt as UnsetMarker, K as MutateFunction, Kn as MutationCacheNotifyEvent, Kt as StaleTimeFunction, L as InfiniteQueryObserverPlaceholderResult, Ln as skipToken, Lt as QueryPersister, M as InfiniteQueryObserverBaseResult, Mt as QueryObserverPlaceholderResult, N as InfiniteQueryObserverLoadingErrorResult, Nn as replaceEqualDeep, Nt as QueryObserverRefetchErrorResult, O as InferDataFromTag, On as matchMutation, Ot as QueryObserverLoadingErrorResult, P as InfiniteQueryObserverLoadingResult, Pt as QueryObserverResult, Q as MutationMeta, Qt as unsetMarker, R as InfiniteQueryObserverRefetchErrorResult, Rt as QueryStatus, S as FetchNextPageOptions, St as QueryFunctionContext, T as FetchStatus, Tn as isServer, Tt as QueryKeyWithDataTag, U as InitialPageParam, Ut as ResultOptions, V as InfiniteQueryPageParamsOptions, Vn as Mutation, Vt as Register, W as InvalidateOptions, Wn as MutationCache, Wt as SetDataOptions, X as MutationFunctionContext, Xt as dataTagErrorSymbol, Y as MutationFunction, Yt as WithRequired, Z as MutationKey, Zt as dataTagSymbol, _ as DefinedQueryObserverResult, _t as QueriesPlaceholderDataFunction, a as defaultShouldDehydrateQuery, an as isCancelledError, at as MutationObserverSuccessResult, b as EnsureQueryDataOptions, bt as QueryExecuteOptions, c as hydrate, cn as QueryCacheConfig, ct as MutationStatus, d as DataTag, dn as MutationFilters, dt as NotifyEvent, et as MutationObserverErrorResult, f as DefaultError, fn as QueryFilters, ft as NotifyEventType, g as DefinedInfiniteQueryObserverResult, gt as PlaceholderDataFunction, h as DefaultedQueryObserverOptions, hn as Updater, ht as Override, i as defaultShouldDehydrateMutation, it as MutationObserverResult, j as InfiniteQueryExecuteOptions, jn as partialMatchKey, jt as QueryObserverPendingResult, k as InferErrorFromTag, kn as matchQuery, kt as QueryObserverLoadingResult, l as AnyDataTag, ln as QueryCacheNotifyEvent, lt as NetworkMode, m as DefaultedInfiniteQueryObserverOptions, mn as SkipToken, mt as OmitKeyof, n as DehydratedState, nt as MutationObserverLoadingResult, o as dehydrate, on as QueryClient, ot as MutationOptions, p as DefaultOptions, pt as NotifyOnChangeProps, q as MutateFunctionRest, qn as MutationObserver, qt as ThrowOnError, r as HydrateOptions, rr as QueryObserver, rt as MutationObserverOptions, s as dehydrateQuery, sn as QueryCache, st as MutationScope, t as DehydrateOptions, tr as QueryState, tt as MutationObserverIdleResult, u as CancelOptions, ut as NonUndefinedGuard, v as DistributiveOmit, vt as QueryBooleanOption, w as FetchQueryOptions, wt as QueryKeyHashFunction, x as FetchInfiniteQueryOptions, xn as hashKey, xt as QueryFunction, y as EnsureInfiniteQueryDataOptions, yt as QueryClientConfig, z as InfiniteQueryObserverResult, zt as RefetchOptions } from "./hydration-DwR10Hi-.cjs";
+import { $ as MutationObserverBaseResult, $n as Query, $t as CancelledError, A as InfiniteData, An as noop, At as QueryObserverOptions, B as InfiniteQueryObserverSuccessResult, Bt as RefetchQueryFilters, C as FetchPreviousPageOptions, Ct as QueryKey, D as GetPreviousPageParamFunction, Dn as keepPreviousData, Dt as QueryObserverBaseResult, E as GetNextPageParamFunction, Et as QueryMeta, F as InfiniteQueryObserverOptions, Ft as QueryObserverSuccessResult, G as InvalidateQueryFilters, Gn as MutationCacheConfig, Gt as StaleTime, H as InitialDataFunction, Hn as MutationState, Ht as ResetOptions, I as InfiniteQueryObserverPendingResult, In as shouldThrowError, It as QueryOptions, J as MutateOptions, Jt as UnsetMarker, K as MutateFunction, Kn as MutationCacheNotifyEvent, Kt as StaleTimeFunction, L as InfiniteQueryObserverPlaceholderResult, Ln as skipToken, Lt as QueryPersister, M as InfiniteQueryObserverBaseResult, Mt as QueryObserverPlaceholderResult, N as InfiniteQueryObserverLoadingErrorResult, Nn as replaceEqualDeep, Nt as QueryObserverRefetchErrorResult, O as InferDataFromTag, On as matchMutation, Ot as QueryObserverLoadingErrorResult, P as InfiniteQueryObserverLoadingResult, Pt as QueryObserverResult, Q as MutationMeta, Qt as unsetMarker, R as InfiniteQueryObserverRefetchErrorResult, Rt as QueryStatus, S as FetchNextPageOptions, St as QueryFunctionContext, T as FetchStatus, Tn as isServer, Tt as QueryKeyWithDataTag, U as InitialPageParam, Ut as ResultOptions, V as InfiniteQueryPageParamsOptions, Vn as Mutation, Vt as Register, W as InvalidateOptions, Wn as MutationCache, Wt as SetDataOptions, X as MutationFunctionContext, Xt as dataTagErrorSymbol, Y as MutationFunction, Yt as WithRequired, Z as MutationKey, Zt as dataTagSymbol, _ as DefinedQueryObserverResult, _t as QueriesPlaceholderDataFunction, a as defaultShouldDehydrateQuery, an as isCancelledError, at as MutationObserverSuccessResult, b as EnsureQueryDataOptions, bt as QueryExecuteOptions, c as hydrate, cn as QueryCacheConfig, ct as MutationStatus, d as DataTag, dn as MutationFilters, dt as NotifyEvent, et as MutationObserverErrorResult, f as DefaultError, fn as QueryFilters, ft as NotifyEventType, g as DefinedInfiniteQueryObserverResult, gt as PlaceholderDataFunction, h as DefaultedQueryObserverOptions, hn as Updater, ht as Override, i as defaultShouldDehydrateMutation, it as MutationObserverResult, j as InfiniteQueryExecuteOptions, jn as partialMatchKey, jt as QueryObserverPendingResult, k as InferErrorFromTag, kn as matchQuery, kt as QueryObserverLoadingResult, l as AnyDataTag, ln as QueryCacheNotifyEvent, lt as NetworkMode, m as DefaultedInfiniteQueryObserverOptions, mn as SkipToken, mt as OmitKeyof, n as DehydratedState, nt as MutationObserverLoadingResult, o as dehydrate, on as QueryClient, ot as MutationOptions, p as DefaultOptions, pt as NotifyOnChangeProps, q as MutateFunctionRest, qn as MutationObserver, qt as ThrowOnError, r as HydrateOptions, rr as QueryObserver, rt as MutationObserverOptions, s as dehydrateQuery, sn as QueryCache, st as MutationScope, t as DehydrateOptions, tr as QueryState, tt as MutationObserverIdleResult, u as CancelOptions, ut as NonUndefinedGuard, v as DistributiveOmit, vt as QueryBooleanOption, w as FetchQueryOptions, wt as QueryKeyHashFunction, x as FetchInfiniteQueryOptions, xn as hashKey, xt as QueryFunction, y as EnsureInfiniteQueryDataOptions, yt as QueryClientConfig, z as InfiniteQueryObserverResult, zt as RefetchOptions } from "./hydration-Br9VIGXa.cjs";
 import { InfiniteQueryObserver } from "./infiniteQueryObserver.cjs";
 import { defaultScheduler, notifyManager } from "./notifyManager.cjs";
 import { OnlineManager, onlineManager } from "./onlineManager.cjs";

package/build/modern/index.d.ts

@@ -1,6 +1,6 @@
 import { environmentManager } from "./environmentManager.js";
 import { FocusManager, focusManager } from "./focusManager.js";
-import { $ as MutationObserverBaseResult, $n as Query, $t as CancelledError, A as InfiniteData, An as noop, At as QueryObserverOptions, B as InfiniteQueryObserverSuccessResult, Bt as RefetchQueryFilters, C as FetchPreviousPageOptions, Ct as QueryKey, D as GetPreviousPageParamFunction, Dn as keepPreviousData, Dt as QueryObserverBaseResult, E as GetNextPageParamFunction, Et as QueryMeta, F as InfiniteQueryObserverOptions, Ft as QueryObserverSuccessResult, G as InvalidateQueryFilters, Gn as MutationCacheConfig, Gt as StaleTime, H as InitialDataFunction, Hn as MutationState, Ht as ResetOptions, I as InfiniteQueryObserverPendingResult, In as shouldThrowError, It as QueryOptions, J as MutateOptions, Jt as UnsetMarker, K as MutateFunction, Kn as MutationCacheNotifyEvent, Kt as StaleTimeFunction, L as InfiniteQueryObserverPlaceholderResult, Ln as skipToken, Lt as QueryPersister, M as InfiniteQueryObserverBaseResult, Mt as QueryObserverPlaceholderResult, N as InfiniteQueryObserverLoadingErrorResult, Nn as replaceEqualDeep, Nt as QueryObserverRefetchErrorResult, O as InferDataFromTag, On as matchMutation, Ot as QueryObserverLoadingErrorResult, P as InfiniteQueryObserverLoadingResult, Pt as QueryObserverResult, Q as MutationMeta, Qt as unsetMarker, R as InfiniteQueryObserverRefetchErrorResult, Rt as QueryStatus, S as FetchNextPageOptions, St as QueryFunctionContext, T as FetchStatus, Tn as isServer, Tt as QueryKeyWithDataTag, U as InitialPageParam, Ut as ResultOptions, V as InfiniteQueryPageParamsOptions, Vn as Mutation, Vt as Register, W as InvalidateOptions, Wn as MutationCache, Wt as SetDataOptions, X as MutationFunctionContext, Xt as dataTagErrorSymbol, Y as MutationFunction, Yt as WithRequired, Z as MutationKey, Zt as dataTagSymbol, _ as DefinedQueryObserverResult, _t as QueriesPlaceholderDataFunction, a as defaultShouldDehydrateQuery, an as isCancelledError, at as MutationObserverSuccessResult, b as EnsureQueryDataOptions, bt as QueryExecuteOptions, c as hydrate, cn as QueryCacheConfig, ct as MutationStatus, d as DataTag, dn as MutationFilters, dt as NotifyEvent, et as MutationObserverErrorResult, f as DefaultError, fn as QueryFilters, ft as NotifyEventType, g as DefinedInfiniteQueryObserverResult, gt as PlaceholderDataFunction, h as DefaultedQueryObserverOptions, hn as Updater, ht as Override, i as defaultShouldDehydrateMutation, it as MutationObserverResult, j as InfiniteQueryExecuteOptions, jn as partialMatchKey, jt as QueryObserverPendingResult, k as InferErrorFromTag, kn as matchQuery, kt as QueryObserverLoadingResult, l as AnyDataTag, ln as QueryCacheNotifyEvent, lt as NetworkMode, m as DefaultedInfiniteQueryObserverOptions, mn as SkipToken, mt as OmitKeyof, n as DehydratedState, nt as MutationObserverLoadingResult, o as dehydrate, on as QueryClient, ot as MutationOptions, p as DefaultOptions, pt as NotifyOnChangeProps, q as MutateFunctionRest, qn as MutationObserver, qt as ThrowOnError, r as HydrateOptions, rr as QueryObserver, rt as MutationObserverOptions, s as dehydrateQuery, sn as QueryCache, st as MutationScope, t as DehydrateOptions, tr as QueryState, tt as MutationObserverIdleResult, u as CancelOptions, ut as NonUndefinedGuard, v as DistributiveOmit, vt as QueryBooleanOption, w as FetchQueryOptions, wt as QueryKeyHashFunction, x as FetchInfiniteQueryOptions, xn as hashKey, xt as QueryFunction, y as EnsureInfiniteQueryDataOptions, yt as QueryClientConfig, z as InfiniteQueryObserverResult, zt as RefetchOptions } from "./hydration-Cq7QYAzB.js";
+import { $ as MutationObserverBaseResult, $n as Query, $t as CancelledError, A as InfiniteData, An as noop, At as QueryObserverOptions, B as InfiniteQueryObserverSuccessResult, Bt as RefetchQueryFilters, C as FetchPreviousPageOptions, Ct as QueryKey, D as GetPreviousPageParamFunction, Dn as keepPreviousData, Dt as QueryObserverBaseResult, E as GetNextPageParamFunction, Et as QueryMeta, F as InfiniteQueryObserverOptions, Ft as QueryObserverSuccessResult, G as InvalidateQueryFilters, Gn as MutationCacheConfig, Gt as StaleTime, H as InitialDataFunction, Hn as MutationState, Ht as ResetOptions, I as InfiniteQueryObserverPendingResult, In as shouldThrowError, It as QueryOptions, J as MutateOptions, Jt as UnsetMarker, K as MutateFunction, Kn as MutationCacheNotifyEvent, Kt as StaleTimeFunction, L as InfiniteQueryObserverPlaceholderResult, Ln as skipToken, Lt as QueryPersister, M as InfiniteQueryObserverBaseResult, Mt as QueryObserverPlaceholderResult, N as InfiniteQueryObserverLoadingErrorResult, Nn as replaceEqualDeep, Nt as QueryObserverRefetchErrorResult, O as InferDataFromTag, On as matchMutation, Ot as QueryObserverLoadingErrorResult, P as InfiniteQueryObserverLoadingResult, Pt as QueryObserverResult, Q as MutationMeta, Qt as unsetMarker, R as InfiniteQueryObserverRefetchErrorResult, Rt as QueryStatus, S as FetchNextPageOptions, St as QueryFunctionContext, T as FetchStatus, Tn as isServer, Tt as QueryKeyWithDataTag, U as InitialPageParam, Ut as ResultOptions, V as InfiniteQueryPageParamsOptions, Vn as Mutation, Vt as Register, W as InvalidateOptions, Wn as MutationCache, Wt as SetDataOptions, X as MutationFunctionContext, Xt as dataTagErrorSymbol, Y as MutationFunction, Yt as WithRequired, Z as MutationKey, Zt as dataTagSymbol, _ as DefinedQueryObserverResult, _t as QueriesPlaceholderDataFunction, a as defaultShouldDehydrateQuery, an as isCancelledError, at as MutationObserverSuccessResult, b as EnsureQueryDataOptions, bt as QueryExecuteOptions, c as hydrate, cn as QueryCacheConfig, ct as MutationStatus, d as DataTag, dn as MutationFilters, dt as NotifyEvent, et as MutationObserverErrorResult, f as DefaultError, fn as QueryFilters, ft as NotifyEventType, g as DefinedInfiniteQueryObserverResult, gt as PlaceholderDataFunction, h as DefaultedQueryObserverOptions, hn as Updater, ht as Override, i as defaultShouldDehydrateMutation, it as MutationObserverResult, j as InfiniteQueryExecuteOptions, jn as partialMatchKey, jt as QueryObserverPendingResult, k as InferErrorFromTag, kn as matchQuery, kt as QueryObserverLoadingResult, l as AnyDataTag, ln as QueryCacheNotifyEvent, lt as NetworkMode, m as DefaultedInfiniteQueryObserverOptions, mn as SkipToken, mt as OmitKeyof, n as DehydratedState, nt as MutationObserverLoadingResult, o as dehydrate, on as QueryClient, ot as MutationOptions, p as DefaultOptions, pt as NotifyOnChangeProps, q as MutateFunctionRest, qn as MutationObserver, qt as ThrowOnError, r as HydrateOptions, rr as QueryObserver, rt as MutationObserverOptions, s as dehydrateQuery, sn as QueryCache, st as MutationScope, t as DehydrateOptions, tr as QueryState, tt as MutationObserverIdleResult, u as CancelOptions, ut as NonUndefinedGuard, v as DistributiveOmit, vt as QueryBooleanOption, w as FetchQueryOptions, wt as QueryKeyHashFunction, x as FetchInfiniteQueryOptions, xn as hashKey, xt as QueryFunction, y as EnsureInfiniteQueryDataOptions, yt as QueryClientConfig, z as InfiniteQueryObserverResult, zt as RefetchOptions } from "./hydration-B9t5w6NC.js";
 import { InfiniteQueryObserver } from "./infiniteQueryObserver.js";
 import { defaultScheduler, notifyManager } from "./notifyManager.js";
 import { OnlineManager, onlineManager } from "./onlineManager.js";

package/build/modern/infiniteQueryBehavior.d.cts

@@ -1,4 +1,4 @@
-import { A as InfiniteData, V as InfiniteQueryPageParamsOptions, er as QueryBehavior } from "./hydration-DwR10Hi-.cjs";
+import { A as InfiniteData, V as InfiniteQueryPageParamsOptions, er as QueryBehavior } from "./hydration-Br9VIGXa.cjs";
 //#region src/infiniteQueryBehavior.d.ts
 declare function infiniteQueryBehavior<TQueryFnData, TError, TData, TPageParam>(pages?: number): QueryBehavior<TQueryFnData, TError, InfiniteData<TData, TPageParam>>;
 /**

package/build/modern/infiniteQueryBehavior.d.ts

@@ -1,4 +1,4 @@
-import { A as InfiniteData, V as InfiniteQueryPageParamsOptions, er as QueryBehavior } from "./hydration-Cq7QYAzB.js";
+import { A as InfiniteData, V as InfiniteQueryPageParamsOptions, er as QueryBehavior } from "./hydration-B9t5w6NC.js";
 //#region src/infiniteQueryBehavior.d.ts
 declare function infiniteQueryBehavior<TQueryFnData, TError, TData, TPageParam>(pages?: number): QueryBehavior<TQueryFnData, TError, InfiniteData<TData, TPageParam>>;
 /**

package/build/modern/infiniteQueryObserver.d.cts

@@ -1,5 +1,5 @@
-import { t as Subscribable } from "./subscribable-CbifVTKz.cjs";
-import { $n as Query, A as InfiniteData, C as FetchPreviousPageOptions, Ct as QueryKey, F as InfiniteQueryObserverOptions, S as FetchNextPageOptions, f as DefaultError, m as DefaultedInfiniteQueryObserverOptions, on as QueryClient, rr as QueryObserver, z as InfiniteQueryObserverResult } from "./hydration-DwR10Hi-.cjs";
+import { t as Subscribable } from "./subscribable-CysQ0tne.cjs";
+import { $n as Query, A as InfiniteData, C as FetchPreviousPageOptions, Ct as QueryKey, F as InfiniteQueryObserverOptions, S as FetchNextPageOptions, f as DefaultError, m as DefaultedInfiniteQueryObserverOptions, on as QueryClient, rr as QueryObserver, z as InfiniteQueryObserverResult } from "./hydration-Br9VIGXa.cjs";
 //#region src/infiniteQueryObserver.d.ts
 type InfiniteQueryObserverListener<TData, TError> = (result: InfiniteQueryObserverResult<TData, TError>) => void;
 /**

package/build/modern/infiniteQueryObserver.d.ts

@@ -1,5 +1,5 @@
-import { t as Subscribable } from "./subscribable-CbifVTKz.js";
-import { $n as Query, A as InfiniteData, C as FetchPreviousPageOptions, Ct as QueryKey, F as InfiniteQueryObserverOptions, S as FetchNextPageOptions, f as DefaultError, m as DefaultedInfiniteQueryObserverOptions, on as QueryClient, rr as QueryObserver, z as InfiniteQueryObserverResult } from "./hydration-Cq7QYAzB.js";
+import { t as Subscribable } from "./subscribable-CysQ0tne.js";
+import { $n as Query, A as InfiniteData, C as FetchPreviousPageOptions, Ct as QueryKey, F as InfiniteQueryObserverOptions, S as FetchNextPageOptions, f as DefaultError, m as DefaultedInfiniteQueryObserverOptions, on as QueryClient, rr as QueryObserver, z as InfiniteQueryObserverResult } from "./hydration-B9t5w6NC.js";
 //#region src/infiniteQueryObserver.d.ts
 type InfiniteQueryObserverListener<TData, TError> = (result: InfiniteQueryObserverResult<TData, TError>) => void;
 /**

package/build/modern/mutation.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"mutation.cjs","names":["Removable","#client","#mutationCache","#observers","#retryer","#dispatch","createRetryer"],"sources":["../../src/mutation.ts"],"sourcesContent":["import { notifyManager } from './notifyManager'\nimport { Removable } from './removable'\nimport { createRetryer } from './retryer'\nimport type {\n  DefaultError,\n  MutationFunctionContext,\n  MutationMeta,\n  MutationOptions,\n  MutationStatus,\n} from './types'\nimport type { MutationCache } from './mutationCache'\nimport type { MutationObserver } from './mutationObserver'\nimport type { Retryer } from './retryer'\nimport type { QueryClient } from './queryClient'\n\n// TYPES\n\ninterface MutationConfig<TData, TError, TVariables, TOnMutateResult> {\n  client: QueryClient\n  mutationId: number\n  mutationCache: MutationCache\n  options: MutationOptions<TData, TError, TVariables, TOnMutateResult>\n  state?: MutationState<TData, TError, TVariables, TOnMutateResult>\n}\n\n/**\n * The raw state stored on a `Mutation` instance. This is the underlying state\n * that observer results (e.g. `MutationObserverResult`) are derived from.\n */\nexport interface MutationState<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = unknown,\n  TOnMutateResult = unknown,\n> {\n  /**\n   * The value returned by `onMutate`, if defined. Passed to `onSuccess`,\n   * `onError` and `onSettled` as the mutation's context.\n   */\n  context: TOnMutateResult | undefined\n  /**\n   * The last successfully resolved data for the mutation.\n   */\n  data: TData | undefined\n  /**\n   * The error object for the mutation, if the last attempt resulted in an error.\n   * - Defaults to `null`.\n   */\n  error: TError | null\n  /**\n   * The number of times the mutation function has failed for the current attempt.\n   */\n  failureCount: number\n  /**\n   * The reason the current attempt failed, as reported by the retryer.\n   */\n  failureReason: TError | null\n  /**\n   * Whether the mutation is currently paused (see network mode), or is\n   * waiting for another mutation with the same `scope` to finish.\n   */\n  isPaused: boolean\n  /**\n   * The status of the mutation.\n   */\n  status: MutationStatus\n  /**\n   * The variables the mutation was last called with.\n   */\n  variables: TVariables | undefined\n  /**\n   * The timestamp for when the mutation was submitted.\n   */\n  submittedAt: number\n}\n\ninterface FailedAction<TError> {\n  type: 'failed'\n  failureCount: number\n  error: TError | null\n}\n\ninterface PendingAction<TVariables, TOnMutateResult> {\n  type: 'pending'\n  isPaused: boolean\n  variables?: TVariables\n  context?: TOnMutateResult\n}\n\ninterface SuccessAction<TData> {\n  type: 'success'\n  data: TData\n}\n\ninterface ErrorAction<TError> {\n  type: 'error'\n  error: TError\n}\n\ninterface PauseAction {\n  type: 'pause'\n}\n\ninterface ContinueAction {\n  type: 'continue'\n}\n\nexport type Action<TData, TError, TVariables, TOnMutateResult> =\n  | ContinueAction\n  | ErrorAction<TError>\n  | FailedAction<TError>\n  | PendingAction<TVariables, TOnMutateResult>\n  | PauseAction\n  | SuccessAction<TData>\n\n// CLASS\n\n/**\n * Represents a single mutation attempt. A `Mutation` holds the mutation's\n * options, state (data/error/status), and the `MutationObserver`s currently\n * subscribed to it.\n *\n * Instances are created and managed internally by `MutationCache`; application\n * code typically interacts with mutations indirectly through `QueryClient` or\n * a framework hook like `useMutation`. Direct access to a `Mutation` instance\n * is possible via `mutationCache.find()`/`getAll()` for inspecting cache state.\n *\n * @example\n * ```ts\n * const mutationCache = queryClient.getMutationCache()\n *\n * const mutation = mutationCache.find({ mutationKey: ['addPost'] })\n * ```\n */\nexport class Mutation<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = unknown,\n  TOnMutateResult = unknown,\n> extends Removable {\n  state: MutationState<TData, TError, TVariables, TOnMutateResult>\n  options!: MutationOptions<TData, TError, TVariables, TOnMutateResult>\n  readonly mutationId: number\n\n  #client: QueryClient\n  #observers: Array<\n    MutationObserver<TData, TError, TVariables, TOnMutateResult>\n  >\n  #mutationCache: MutationCache\n  #retryer?: Retryer<TData>\n\n  constructor(\n    config: MutationConfig<TData, TError, TVariables, TOnMutateResult>,\n  ) {\n    super()\n\n    this.#client = config.client\n    this.mutationId = config.mutationId\n    this.#mutationCache = config.mutationCache\n    this.#observers = []\n    this.state = config.state || getDefaultState()\n\n    this.setOptions(config.options)\n    this.scheduleGc()\n  }\n\n  /** @internal */\n  setOptions(\n    options: MutationOptions<TData, TError, TVariables, TOnMutateResult>,\n  ): void {\n    this.options = options\n\n    this.updateGcTime(this.options.gcTime)\n  }\n\n  /**\n   * The `meta` object passed in the mutation's options, if any.\n   */\n  get meta(): MutationMeta | undefined {\n    return this.options.meta\n  }\n\n  /** @internal */\n  addObserver(observer: MutationObserver<any, any, any, any>): void {\n    if (!this.#observers.includes(observer)) {\n      this.#observers.push(observer)\n\n      // Stop the mutation from being garbage collected\n      this.clearGcTimeout()\n\n      this.#mutationCache.notify({\n        type: 'observerAdded',\n        mutation: this,\n        observer,\n      })\n    }\n  }\n\n  /** @internal */\n  removeObserver(observer: MutationObserver<any, any, any, any>): void {\n    this.#observers = this.#observers.filter((x) => x !== observer)\n\n    this.scheduleGc()\n\n    this.#mutationCache.notify({\n      type: 'observerRemoved',\n      mutation: this,\n      observer,\n    })\n  }\n\n  protected optionalRemove() {\n    if (!this.#observers.length) {\n      if (this.state.status === 'pending') {\n        this.scheduleGc()\n      } else {\n        this.#mutationCache.remove(this)\n      }\n    }\n  }\n\n  /**\n   * Resumes a mutation that is currently paused or was restored from a\n   * dehydrated, still-`pending` state.\n   *\n   * - If this mutation has an active retryer (it paused mid-attempt, e.g. due\n   *   to the network mode or scope-based queuing), its retryer is resumed.\n   * - Otherwise, if the mutation's status is still `pending` (e.g. it was\n   *   dehydrated while an attempt was in flight and never got a retryer in\n   *   this instance), `execute` is called again with the last known variables.\n   * - Otherwise the mutation has already settled and this resolves immediately\n   *   without running anything again.\n   *\n   * @example\n   * ```ts\n   * // typically driven by reconnect handling, e.g. queryClient.resumePausedMutations()\n   * const mutation = mutationCache.find({ mutationKey: ['addPost'] })\n   * await mutation?.continue()\n   * ```\n   *\n   * @see {@link Mutation#execute}\n   */\n  continue(): Promise<unknown> {\n    return (\n      this.#retryer?.continue() ??\n      // continuing a mutation assumes that variables are set, mutation must have been dehydrated before.\n      // a settled mutation has no retryer to continue and must not run again\n      (this.state.status === 'pending'\n        ? this.execute(this.state.variables!)\n        : Promise.resolve())\n    )\n  }\n\n  /**\n   * Runs the mutation function for the given variables through a retryer, and\n   * drives the mutation's state and lifecycle callbacks through to settlement.\n   *\n   * If this mutation's state is already `pending` when `execute` is called\n   * (i.e. it was restored, still in-flight, from a dehydrated state), the\n   * `onMutate` step is skipped and a `continue` action is dispatched to\n   * unpause it; otherwise a `pending` action is dispatched first, then the\n   * mutation cache's `onMutate` and the mutation's own `onMutate` option are\n   * awaited in that order, and the resulting context is stored.\n   *\n   * The mutation function is then run (subject to `retry`/`retryDelay`/\n   * `networkMode`, and to the mutation cache's scope-based serialization).\n   * On success, the cache's `onSuccess`/`onSettled` callbacks run before the\n   * mutation's own `onSuccess`/`onSettled` options, a `success` action is\n   * dispatched, and the resolved data is returned. On failure, the same\n   * cache-then-option ordering is used for `onError`/`onSettled`, but each of\n   * those four callbacks is individually caught so that a throwing callback\n   * cannot mask the original error; an `error` action is then dispatched and\n   * the original error is re-thrown.\n   *\n   * @example\n   * ```ts\n   * // Called internally by `MutationObserver.mutate` and `Mutation.continue` —\n   * // applications normally trigger mutations through those, not this method.\n   * const data = await mutation.execute(variables)\n   * ```\n   *\n   * @see {@link Mutation#continue}\n   */\n  async execute(variables: TVariables): Promise<TData> {\n    const onContinue = () => {\n      this.#dispatch({ type: 'continue' })\n    }\n\n    const mutationFnContext = {\n      client: this.#client,\n      meta: this.options.meta,\n      mutationKey: this.options.mutationKey,\n    } satisfies MutationFunctionContext\n\n    const retryer = (this.#retryer = createRetryer({\n      fn: () => {\n        if (!this.options.mutationFn) {\n          return Promise.reject(new Error('No mutationFn found'))\n        }\n\n        return this.options.mutationFn(variables, mutationFnContext)\n      },\n      onFail: (failureCount, error) => {\n        this.#dispatch({ type: 'failed', failureCount, error })\n      },\n      onPause: () => {\n        this.#dispatch({ type: 'pause' })\n      },\n      onContinue,\n      retry: this.options.retry ?? 0,\n      retryDelay: this.options.retryDelay,\n      networkMode: this.options.networkMode,\n      canRun: () => this.#mutationCache.canRun(this),\n    }))\n\n    const restored = this.state.status === 'pending'\n    const isPaused = !retryer.canStart()\n\n    try {\n      if (restored) {\n        // Dispatch continue action to unpause restored mutation\n        onContinue()\n      } else {\n        this.#dispatch({ type: 'pending', variables, isPaused })\n        // Notify cache callback\n        if (this.#mutationCache.config.onMutate) {\n          await this.#mutationCache.config.onMutate(\n            variables,\n            this as Mutation<unknown, unknown, unknown, unknown>,\n            mutationFnContext,\n          )\n        }\n        const context = await this.options.onMutate?.(\n          variables,\n          mutationFnContext,\n        )\n        if (context !== this.state.context) {\n          this.#dispatch({\n            type: 'pending',\n            context,\n            variables,\n            isPaused,\n          })\n        }\n      }\n      const data = await retryer.start()\n\n      // Notify cache callback\n      await this.#mutationCache.config.onSuccess?.(\n        data,\n        variables,\n        this.state.context,\n        this as Mutation<unknown, unknown, unknown, unknown>,\n        mutationFnContext,\n      )\n\n      await this.options.onSuccess?.(\n        data,\n        variables,\n        this.state.context!,\n        mutationFnContext,\n      )\n\n      // Notify cache callback\n      await this.#mutationCache.config.onSettled?.(\n        data,\n        null,\n        this.state.variables,\n        this.state.context,\n        this as Mutation<unknown, unknown, unknown, unknown>,\n        mutationFnContext,\n      )\n\n      await this.options.onSettled?.(\n        data,\n        null,\n        variables,\n        this.state.context,\n        mutationFnContext,\n      )\n\n      this.#dispatch({ type: 'success', data })\n      return data\n    } catch (error) {\n      try {\n        // Notify cache callback\n        await this.#mutationCache.config.onError?.(\n          error as any,\n          variables,\n          this.state.context,\n          this as Mutation<unknown, unknown, unknown, unknown>,\n          mutationFnContext,\n        )\n      } catch (e) {\n        void Promise.reject(e)\n      }\n\n      try {\n        await this.options.onError?.(\n          error as TError,\n          variables,\n          this.state.context,\n          mutationFnContext,\n        )\n      } catch (e) {\n        void Promise.reject(e)\n      }\n\n      try {\n        // Notify cache callback\n        await this.#mutationCache.config.onSettled?.(\n          undefined,\n          error as any,\n          this.state.variables,\n          this.state.context,\n          this as Mutation<unknown, unknown, unknown, unknown>,\n          mutationFnContext,\n        )\n      } catch (e) {\n        void Promise.reject(e)\n      }\n\n      try {\n        await this.options.onSettled?.(\n          undefined,\n          error as TError,\n          variables,\n          this.state.context,\n          mutationFnContext,\n        )\n      } catch (e) {\n        void Promise.reject(e)\n      }\n\n      this.#dispatch({ type: 'error', error: error as TError })\n      throw error\n    } finally {\n      // The settled retryer's promise would otherwise pin this mutation's\n      // result, variables and context for as long as the cache keeps it\n      if (this.#retryer === retryer) {\n        this.#retryer = undefined\n      }\n      this.#mutationCache.runNext(this)\n    }\n  }\n\n  #dispatch(action: Action<TData, TError, TVariables, TOnMutateResult>): void {\n    const reducer = (\n      state: MutationState<TData, TError, TVariables, TOnMutateResult>,\n    ): MutationState<TData, TError, TVariables, TOnMutateResult> => {\n      switch (action.type) {\n        case 'failed':\n          return {\n            ...state,\n            failureCount: action.failureCount,\n            failureReason: action.error,\n          }\n        case 'pause':\n          return {\n            ...state,\n            isPaused: true,\n          }\n        case 'continue':\n          return {\n            ...state,\n            isPaused: false,\n          }\n        case 'pending':\n          return {\n            ...state,\n            context: action.context,\n            data: undefined,\n            failureCount: 0,\n            failureReason: null,\n            error: null,\n            isPaused: action.isPaused,\n            status: 'pending',\n            variables: action.variables,\n            submittedAt: Date.now(),\n          }\n        case 'success':\n          return {\n            ...state,\n            data: action.data,\n            failureCount: 0,\n            failureReason: null,\n            error: null,\n            status: 'success',\n            isPaused: false,\n          }\n        case 'error':\n          return {\n            ...state,\n            data: undefined,\n            error: action.error,\n            failureCount: state.failureCount + 1,\n            failureReason: action.error,\n            isPaused: false,\n            status: 'error',\n          }\n      }\n    }\n    this.state = reducer(this.state)\n\n    notifyManager.batch(() => {\n      this.#observers.forEach((observer) => {\n        observer.onMutationUpdate(action)\n      })\n      this.#mutationCache.notify({\n        mutation: this,\n        type: 'updated',\n        action,\n      })\n    })\n  }\n}\n\nexport function getDefaultState<\n  TData,\n  TError,\n  TVariables,\n  TOnMutateResult,\n>(): MutationState<TData, TError, TVariables, TOnMutateResult> {\n  return {\n    context: undefined,\n    data: undefined,\n    error: null,\n    failureCount: 0,\n    failureReason: null,\n    isPaused: false,\n    status: 'idle',\n    variables: undefined,\n    submittedAt: 0,\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"mutation.cjs","names":["Removable","createRetryer"],"sources":["../../src/mutation.ts"],"sourcesContent":["import { notifyManager } from './notifyManager'\nimport { Removable } from './removable'\nimport { createRetryer } from './retryer'\nimport type {\n  DefaultError,\n  MutationFunctionContext,\n  MutationMeta,\n  MutationOptions,\n  MutationStatus,\n} from './types'\nimport type { MutationCache } from './mutationCache'\nimport type { MutationObserver } from './mutationObserver'\nimport type { Retryer } from './retryer'\nimport type { QueryClient } from './queryClient'\n\n// TYPES\n\ninterface MutationConfig<TData, TError, TVariables, TOnMutateResult> {\n  client: QueryClient\n  mutationId: number\n  mutationCache: MutationCache\n  options: MutationOptions<TData, TError, TVariables, TOnMutateResult>\n  state?: MutationState<TData, TError, TVariables, TOnMutateResult>\n}\n\n/**\n * The raw state stored on a `Mutation` instance. This is the underlying state\n * that observer results (e.g. `MutationObserverResult`) are derived from.\n */\nexport interface MutationState<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = unknown,\n  TOnMutateResult = unknown,\n> {\n  /**\n   * The value returned by `onMutate`, if defined. Passed to `onSuccess`,\n   * `onError` and `onSettled` as the mutation's context.\n   */\n  context: TOnMutateResult | undefined\n  /**\n   * The last successfully resolved data for the mutation.\n   */\n  data: TData | undefined\n  /**\n   * The error object for the mutation, if the last attempt resulted in an error.\n   * - Defaults to `null`.\n   */\n  error: TError | null\n  /**\n   * The number of times the mutation function has failed for the current attempt.\n   */\n  failureCount: number\n  /**\n   * The reason the current attempt failed, as reported by the retryer.\n   */\n  failureReason: TError | null\n  /**\n   * Whether the mutation is currently paused (see network mode), or is\n   * waiting for another mutation with the same `scope` to finish.\n   */\n  isPaused: boolean\n  /**\n   * The status of the mutation.\n   */\n  status: MutationStatus\n  /**\n   * The variables the mutation was last called with.\n   */\n  variables: TVariables | undefined\n  /**\n   * The timestamp for when the mutation was submitted.\n   */\n  submittedAt: number\n}\n\ninterface FailedAction<TError> {\n  type: 'failed'\n  failureCount: number\n  error: TError | null\n}\n\ninterface PendingAction<TVariables, TOnMutateResult> {\n  type: 'pending'\n  isPaused: boolean\n  variables?: TVariables\n  context?: TOnMutateResult\n}\n\ninterface SuccessAction<TData> {\n  type: 'success'\n  data: TData\n}\n\ninterface ErrorAction<TError> {\n  type: 'error'\n  error: TError\n}\n\ninterface PauseAction {\n  type: 'pause'\n}\n\ninterface ContinueAction {\n  type: 'continue'\n}\n\nexport type Action<TData, TError, TVariables, TOnMutateResult> =\n  | ContinueAction\n  | ErrorAction<TError>\n  | FailedAction<TError>\n  | PendingAction<TVariables, TOnMutateResult>\n  | PauseAction\n  | SuccessAction<TData>\n\n// CLASS\n\n/**\n * Represents a single mutation attempt. A `Mutation` holds the mutation's\n * options, state (data/error/status), and the `MutationObserver`s currently\n * subscribed to it.\n *\n * Instances are created and managed internally by `MutationCache`; application\n * code typically interacts with mutations indirectly through `QueryClient` or\n * a framework hook like `useMutation`. Direct access to a `Mutation` instance\n * is possible via `mutationCache.find()`/`getAll()` for inspecting cache state.\n *\n * @example\n * ```ts\n * const mutationCache = queryClient.getMutationCache()\n *\n * const mutation = mutationCache.find({ mutationKey: ['addPost'] })\n * ```\n */\nexport class Mutation<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = unknown,\n  TOnMutateResult = unknown,\n> extends Removable {\n  state: MutationState<TData, TError, TVariables, TOnMutateResult>\n  options!: MutationOptions<TData, TError, TVariables, TOnMutateResult>\n  readonly mutationId: number\n\n  #client: QueryClient\n  #observers: Array<\n    MutationObserver<TData, TError, TVariables, TOnMutateResult>\n  >\n  #mutationCache: MutationCache\n  #retryer?: Retryer<TData>\n\n  constructor(\n    config: MutationConfig<TData, TError, TVariables, TOnMutateResult>,\n  ) {\n    super()\n\n    this.#client = config.client\n    this.mutationId = config.mutationId\n    this.#mutationCache = config.mutationCache\n    this.#observers = []\n    this.state = config.state || getDefaultState()\n\n    this.setOptions(config.options)\n    this.scheduleGc()\n  }\n\n  /** @internal */\n  setOptions(\n    options: MutationOptions<TData, TError, TVariables, TOnMutateResult>,\n  ): void {\n    this.options = options\n\n    this.updateGcTime(this.options.gcTime)\n  }\n\n  /**\n   * The `meta` object passed in the mutation's options, if any.\n   */\n  get meta(): MutationMeta | undefined {\n    return this.options.meta\n  }\n\n  /** @internal */\n  addObserver(observer: MutationObserver<any, any, any, any>): void {\n    if (!this.#observers.includes(observer)) {\n      this.#observers.push(observer)\n\n      // Stop the mutation from being garbage collected\n      this.clearGcTimeout()\n\n      this.#mutationCache.notify({\n        type: 'observerAdded',\n        mutation: this,\n        observer,\n      })\n    }\n  }\n\n  /** @internal */\n  removeObserver(observer: MutationObserver<any, any, any, any>): void {\n    this.#observers = this.#observers.filter((x) => x !== observer)\n\n    this.scheduleGc()\n\n    this.#mutationCache.notify({\n      type: 'observerRemoved',\n      mutation: this,\n      observer,\n    })\n  }\n\n  protected optionalRemove() {\n    if (!this.#observers.length) {\n      if (this.state.status === 'pending') {\n        this.scheduleGc()\n      } else {\n        this.#mutationCache.remove(this)\n      }\n    }\n  }\n\n  /**\n   * Resumes a mutation that is currently paused or was restored from a\n   * dehydrated, still-`pending` state.\n   *\n   * - If this mutation has an active retryer (it paused mid-attempt, e.g. due\n   *   to the network mode or scope-based queuing), its retryer is resumed.\n   * - Otherwise, if the mutation's status is still `pending` (e.g. it was\n   *   dehydrated while an attempt was in flight and never got a retryer in\n   *   this instance), `execute` is called again with the last known variables.\n   * - Otherwise the mutation has already settled and this resolves immediately\n   *   without running anything again.\n   *\n   * @example\n   * ```ts\n   * // typically driven by reconnect handling, e.g. queryClient.resumePausedMutations()\n   * const mutation = mutationCache.find({ mutationKey: ['addPost'] })\n   * await mutation?.continue()\n   * ```\n   *\n   * @see {@link Mutation#execute}\n   */\n  continue(): Promise<unknown> {\n    return (\n      this.#retryer?.continue() ??\n      // continuing a mutation assumes that variables are set, mutation must have been dehydrated before.\n      // a settled mutation has no retryer to continue and must not run again\n      (this.state.status === 'pending'\n        ? this.execute(this.state.variables!)\n        : Promise.resolve())\n    )\n  }\n\n  /**\n   * Runs the mutation function for the given variables through a retryer, and\n   * drives the mutation's state and lifecycle callbacks through to settlement.\n   *\n   * If this mutation's state is already `pending` when `execute` is called\n   * (i.e. it was restored, still in-flight, from a dehydrated state), the\n   * `onMutate` step is skipped and a `continue` action is dispatched to\n   * unpause it; otherwise a `pending` action is dispatched first, then the\n   * mutation cache's `onMutate` and the mutation's own `onMutate` option are\n   * awaited in that order, and the resulting context is stored.\n   *\n   * The mutation function is then run (subject to `retry`/`retryDelay`/\n   * `networkMode`, and to the mutation cache's scope-based serialization).\n   * On success, the cache's `onSuccess`/`onSettled` callbacks run before the\n   * mutation's own `onSuccess`/`onSettled` options, a `success` action is\n   * dispatched, and the resolved data is returned. On failure, the same\n   * cache-then-option ordering is used for `onError`/`onSettled`, but each of\n   * those four callbacks is individually caught so that a throwing callback\n   * cannot mask the original error; an `error` action is then dispatched and\n   * the original error is re-thrown.\n   *\n   * @example\n   * ```ts\n   * // Called internally by `MutationObserver.mutate` and `Mutation.continue` —\n   * // applications normally trigger mutations through those, not this method.\n   * const data = await mutation.execute(variables)\n   * ```\n   *\n   * @see {@link Mutation#continue}\n   */\n  async execute(variables: TVariables): Promise<TData> {\n    const onContinue = () => {\n      this.#dispatch({ type: 'continue' })\n    }\n\n    const mutationFnContext = {\n      client: this.#client,\n      meta: this.options.meta,\n      mutationKey: this.options.mutationKey,\n    } satisfies MutationFunctionContext\n\n    const retryer = (this.#retryer = createRetryer({\n      fn: () => {\n        if (!this.options.mutationFn) {\n          return Promise.reject(new Error('No mutationFn found'))\n        }\n\n        return this.options.mutationFn(variables, mutationFnContext)\n      },\n      onFail: (failureCount, error) => {\n        this.#dispatch({ type: 'failed', failureCount, error })\n      },\n      onPause: () => {\n        this.#dispatch({ type: 'pause' })\n      },\n      onContinue,\n      retry: this.options.retry ?? 0,\n      retryDelay: this.options.retryDelay,\n      networkMode: this.options.networkMode,\n      canRun: () => this.#mutationCache.canRun(this),\n    }))\n\n    const restored = this.state.status === 'pending'\n    const isPaused = !retryer.canStart()\n\n    try {\n      if (restored) {\n        // Dispatch continue action to unpause restored mutation\n        onContinue()\n      } else {\n        this.#dispatch({ type: 'pending', variables, isPaused })\n        // Notify cache callback\n        if (this.#mutationCache.config.onMutate) {\n          await this.#mutationCache.config.onMutate(\n            variables,\n            this as Mutation<unknown, unknown, unknown, unknown>,\n            mutationFnContext,\n          )\n        }\n        const context = await this.options.onMutate?.(\n          variables,\n          mutationFnContext,\n        )\n        if (context !== this.state.context) {\n          this.#dispatch({\n            type: 'pending',\n            context,\n            variables,\n            isPaused,\n          })\n        }\n      }\n      const data = await retryer.start()\n\n      // Notify cache callback\n      await this.#mutationCache.config.onSuccess?.(\n        data,\n        variables,\n        this.state.context,\n        this as Mutation<unknown, unknown, unknown, unknown>,\n        mutationFnContext,\n      )\n\n      await this.options.onSuccess?.(\n        data,\n        variables,\n        this.state.context!,\n        mutationFnContext,\n      )\n\n      // Notify cache callback\n      await this.#mutationCache.config.onSettled?.(\n        data,\n        null,\n        this.state.variables,\n        this.state.context,\n        this as Mutation<unknown, unknown, unknown, unknown>,\n        mutationFnContext,\n      )\n\n      await this.options.onSettled?.(\n        data,\n        null,\n        variables,\n        this.state.context,\n        mutationFnContext,\n      )\n\n      this.#dispatch({ type: 'success', data })\n      return data\n    } catch (error) {\n      try {\n        // Notify cache callback\n        await this.#mutationCache.config.onError?.(\n          error as any,\n          variables,\n          this.state.context,\n          this as Mutation<unknown, unknown, unknown, unknown>,\n          mutationFnContext,\n        )\n      } catch (e) {\n        void Promise.reject(e)\n      }\n\n      try {\n        await this.options.onError?.(\n          error as TError,\n          variables,\n          this.state.context,\n          mutationFnContext,\n        )\n      } catch (e) {\n        void Promise.reject(e)\n      }\n\n      try {\n        // Notify cache callback\n        await this.#mutationCache.config.onSettled?.(\n          undefined,\n          error as any,\n          this.state.variables,\n          this.state.context,\n          this as Mutation<unknown, unknown, unknown, unknown>,\n          mutationFnContext,\n        )\n      } catch (e) {\n        void Promise.reject(e)\n      }\n\n      try {\n        await this.options.onSettled?.(\n          undefined,\n          error as TError,\n          variables,\n          this.state.context,\n          mutationFnContext,\n        )\n      } catch (e) {\n        void Promise.reject(e)\n      }\n\n      this.#dispatch({ type: 'error', error: error as TError })\n      throw error\n    } finally {\n      // The settled retryer's promise would otherwise pin this mutation's\n      // result, variables and context for as long as the cache keeps it\n      if (this.#retryer === retryer) {\n        this.#retryer = undefined\n      }\n      this.#mutationCache.runNext(this)\n    }\n  }\n\n  #dispatch(action: Action<TData, TError, TVariables, TOnMutateResult>): void {\n    const reducer = (\n      state: MutationState<TData, TError, TVariables, TOnMutateResult>,\n    ): MutationState<TData, TError, TVariables, TOnMutateResult> => {\n      switch (action.type) {\n        case 'failed':\n          return {\n            ...state,\n            failureCount: action.failureCount,\n            failureReason: action.error,\n          }\n        case 'pause':\n          return {\n            ...state,\n            isPaused: true,\n          }\n        case 'continue':\n          return {\n            ...state,\n            isPaused: false,\n          }\n        case 'pending':\n          return {\n            ...state,\n            context: action.context,\n            data: undefined,\n            failureCount: 0,\n            failureReason: null,\n            error: null,\n            isPaused: action.isPaused,\n            status: 'pending',\n            variables: action.variables,\n            submittedAt: Date.now(),\n          }\n        case 'success':\n          return {\n            ...state,\n            data: action.data,\n            failureCount: 0,\n            failureReason: null,\n            error: null,\n            status: 'success',\n            isPaused: false,\n          }\n        case 'error':\n          return {\n            ...state,\n            data: undefined,\n            error: action.error,\n            failureCount: state.failureCount + 1,\n            failureReason: action.error,\n            isPaused: false,\n            status: 'error',\n          }\n      }\n    }\n    this.state = reducer(this.state)\n\n    notifyManager.batch(() => {\n      this.#observers.forEach((observer) => {\n        observer.onMutationUpdate(action)\n      })\n      this.#mutationCache.notify({\n        mutation: this,\n        type: 'updated',\n        action,\n      })\n    })\n  }\n}\n\nexport function getDefaultState<\n  TData,\n  TError,\n  TVariables,\n  TOnMutateResult,\n>(): MutationState<TData, TError, TVariables, TOnMutateResult> {\n  return {\n    context: undefined,\n    data: undefined,\n    error: null,\n    failureCount: 0,\n    failureReason: null,\n    isPaused: false,\n    status: 'idle',\n    variables: undefined,\n    submittedAt: 0,\n  }\n}\n"],"mappings":"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"}

package/build/modern/mutation.d.cts

@@ -1,2 +1,2 @@
-import { Bn as Action, Hn as MutationState, Un as getDefaultState, Vn as Mutation } from "./hydration-DwR10Hi-.cjs";
+import { Bn as Action, Hn as MutationState, Un as getDefaultState, Vn as Mutation } from "./hydration-Br9VIGXa.cjs";
 export { Action, Mutation, MutationState, getDefaultState };

package/build/modern/mutation.d.ts

@@ -1,2 +1,2 @@
-import { Bn as Action, Hn as MutationState, Un as getDefaultState, Vn as Mutation } from "./hydration-Cq7QYAzB.js";
+import { Bn as Action, Hn as MutationState, Un as getDefaultState, Vn as Mutation } from "./hydration-B9t5w6NC.js";
 export { Action, Mutation, MutationState, getDefaultState };

package/build/modern/mutation.js.map

@@ -1 +1 @@
-{"version":3,"file":"mutation.js","names":["#client","#mutationCache","#observers","#retryer","#dispatch"],"sources":["../../src/mutation.ts"],"sourcesContent":["import { notifyManager } from './notifyManager'\nimport { Removable } from './removable'\nimport { createRetryer } from './retryer'\nimport type {\n  DefaultError,\n  MutationFunctionContext,\n  MutationMeta,\n  MutationOptions,\n  MutationStatus,\n} from './types'\nimport type { MutationCache } from './mutationCache'\nimport type { MutationObserver } from './mutationObserver'\nimport type { Retryer } from './retryer'\nimport type { QueryClient } from './queryClient'\n\n// TYPES\n\ninterface MutationConfig<TData, TError, TVariables, TOnMutateResult> {\n  client: QueryClient\n  mutationId: number\n  mutationCache: MutationCache\n  options: MutationOptions<TData, TError, TVariables, TOnMutateResult>\n  state?: MutationState<TData, TError, TVariables, TOnMutateResult>\n}\n\n/**\n * The raw state stored on a `Mutation` instance. This is the underlying state\n * that observer results (e.g. `MutationObserverResult`) are derived from.\n */\nexport interface MutationState<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = unknown,\n  TOnMutateResult = unknown,\n> {\n  /**\n   * The value returned by `onMutate`, if defined. Passed to `onSuccess`,\n   * `onError` and `onSettled` as the mutation's context.\n   */\n  context: TOnMutateResult | undefined\n  /**\n   * The last successfully resolved data for the mutation.\n   */\n  data: TData | undefined\n  /**\n   * The error object for the mutation, if the last attempt resulted in an error.\n   * - Defaults to `null`.\n   */\n  error: TError | null\n  /**\n   * The number of times the mutation function has failed for the current attempt.\n   */\n  failureCount: number\n  /**\n   * The reason the current attempt failed, as reported by the retryer.\n   */\n  failureReason: TError | null\n  /**\n   * Whether the mutation is currently paused (see network mode), or is\n   * waiting for another mutation with the same `scope` to finish.\n   */\n  isPaused: boolean\n  /**\n   * The status of the mutation.\n   */\n  status: MutationStatus\n  /**\n   * The variables the mutation was last called with.\n   */\n  variables: TVariables | undefined\n  /**\n   * The timestamp for when the mutation was submitted.\n   */\n  submittedAt: number\n}\n\ninterface FailedAction<TError> {\n  type: 'failed'\n  failureCount: number\n  error: TError | null\n}\n\ninterface PendingAction<TVariables, TOnMutateResult> {\n  type: 'pending'\n  isPaused: boolean\n  variables?: TVariables\n  context?: TOnMutateResult\n}\n\ninterface SuccessAction<TData> {\n  type: 'success'\n  data: TData\n}\n\ninterface ErrorAction<TError> {\n  type: 'error'\n  error: TError\n}\n\ninterface PauseAction {\n  type: 'pause'\n}\n\ninterface ContinueAction {\n  type: 'continue'\n}\n\nexport type Action<TData, TError, TVariables, TOnMutateResult> =\n  | ContinueAction\n  | ErrorAction<TError>\n  | FailedAction<TError>\n  | PendingAction<TVariables, TOnMutateResult>\n  | PauseAction\n  | SuccessAction<TData>\n\n// CLASS\n\n/**\n * Represents a single mutation attempt. A `Mutation` holds the mutation's\n * options, state (data/error/status), and the `MutationObserver`s currently\n * subscribed to it.\n *\n * Instances are created and managed internally by `MutationCache`; application\n * code typically interacts with mutations indirectly through `QueryClient` or\n * a framework hook like `useMutation`. Direct access to a `Mutation` instance\n * is possible via `mutationCache.find()`/`getAll()` for inspecting cache state.\n *\n * @example\n * ```ts\n * const mutationCache = queryClient.getMutationCache()\n *\n * const mutation = mutationCache.find({ mutationKey: ['addPost'] })\n * ```\n */\nexport class Mutation<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = unknown,\n  TOnMutateResult = unknown,\n> extends Removable {\n  state: MutationState<TData, TError, TVariables, TOnMutateResult>\n  options!: MutationOptions<TData, TError, TVariables, TOnMutateResult>\n  readonly mutationId: number\n\n  #client: QueryClient\n  #observers: Array<\n    MutationObserver<TData, TError, TVariables, TOnMutateResult>\n  >\n  #mutationCache: MutationCache\n  #retryer?: Retryer<TData>\n\n  constructor(\n    config: MutationConfig<TData, TError, TVariables, TOnMutateResult>,\n  ) {\n    super()\n\n    this.#client = config.client\n    this.mutationId = config.mutationId\n    this.#mutationCache = config.mutationCache\n    this.#observers = []\n    this.state = config.state || getDefaultState()\n\n    this.setOptions(config.options)\n    this.scheduleGc()\n  }\n\n  /** @internal */\n  setOptions(\n    options: MutationOptions<TData, TError, TVariables, TOnMutateResult>,\n  ): void {\n    this.options = options\n\n    this.updateGcTime(this.options.gcTime)\n  }\n\n  /**\n   * The `meta` object passed in the mutation's options, if any.\n   */\n  get meta(): MutationMeta | undefined {\n    return this.options.meta\n  }\n\n  /** @internal */\n  addObserver(observer: MutationObserver<any, any, any, any>): void {\n    if (!this.#observers.includes(observer)) {\n      this.#observers.push(observer)\n\n      // Stop the mutation from being garbage collected\n      this.clearGcTimeout()\n\n      this.#mutationCache.notify({\n        type: 'observerAdded',\n        mutation: this,\n        observer,\n      })\n    }\n  }\n\n  /** @internal */\n  removeObserver(observer: MutationObserver<any, any, any, any>): void {\n    this.#observers = this.#observers.filter((x) => x !== observer)\n\n    this.scheduleGc()\n\n    this.#mutationCache.notify({\n      type: 'observerRemoved',\n      mutation: this,\n      observer,\n    })\n  }\n\n  protected optionalRemove() {\n    if (!this.#observers.length) {\n      if (this.state.status === 'pending') {\n        this.scheduleGc()\n      } else {\n        this.#mutationCache.remove(this)\n      }\n    }\n  }\n\n  /**\n   * Resumes a mutation that is currently paused or was restored from a\n   * dehydrated, still-`pending` state.\n   *\n   * - If this mutation has an active retryer (it paused mid-attempt, e.g. due\n   *   to the network mode or scope-based queuing), its retryer is resumed.\n   * - Otherwise, if the mutation's status is still `pending` (e.g. it was\n   *   dehydrated while an attempt was in flight and never got a retryer in\n   *   this instance), `execute` is called again with the last known variables.\n   * - Otherwise the mutation has already settled and this resolves immediately\n   *   without running anything again.\n   *\n   * @example\n   * ```ts\n   * // typically driven by reconnect handling, e.g. queryClient.resumePausedMutations()\n   * const mutation = mutationCache.find({ mutationKey: ['addPost'] })\n   * await mutation?.continue()\n   * ```\n   *\n   * @see {@link Mutation#execute}\n   */\n  continue(): Promise<unknown> {\n    return (\n      this.#retryer?.continue() ??\n      // continuing a mutation assumes that variables are set, mutation must have been dehydrated before.\n      // a settled mutation has no retryer to continue and must not run again\n      (this.state.status === 'pending'\n        ? this.execute(this.state.variables!)\n        : Promise.resolve())\n    )\n  }\n\n  /**\n   * Runs the mutation function for the given variables through a retryer, and\n   * drives the mutation's state and lifecycle callbacks through to settlement.\n   *\n   * If this mutation's state is already `pending` when `execute` is called\n   * (i.e. it was restored, still in-flight, from a dehydrated state), the\n   * `onMutate` step is skipped and a `continue` action is dispatched to\n   * unpause it; otherwise a `pending` action is dispatched first, then the\n   * mutation cache's `onMutate` and the mutation's own `onMutate` option are\n   * awaited in that order, and the resulting context is stored.\n   *\n   * The mutation function is then run (subject to `retry`/`retryDelay`/\n   * `networkMode`, and to the mutation cache's scope-based serialization).\n   * On success, the cache's `onSuccess`/`onSettled` callbacks run before the\n   * mutation's own `onSuccess`/`onSettled` options, a `success` action is\n   * dispatched, and the resolved data is returned. On failure, the same\n   * cache-then-option ordering is used for `onError`/`onSettled`, but each of\n   * those four callbacks is individually caught so that a throwing callback\n   * cannot mask the original error; an `error` action is then dispatched and\n   * the original error is re-thrown.\n   *\n   * @example\n   * ```ts\n   * // Called internally by `MutationObserver.mutate` and `Mutation.continue` —\n   * // applications normally trigger mutations through those, not this method.\n   * const data = await mutation.execute(variables)\n   * ```\n   *\n   * @see {@link Mutation#continue}\n   */\n  async execute(variables: TVariables): Promise<TData> {\n    const onContinue = () => {\n      this.#dispatch({ type: 'continue' })\n    }\n\n    const mutationFnContext = {\n      client: this.#client,\n      meta: this.options.meta,\n      mutationKey: this.options.mutationKey,\n    } satisfies MutationFunctionContext\n\n    const retryer = (this.#retryer = createRetryer({\n      fn: () => {\n        if (!this.options.mutationFn) {\n          return Promise.reject(new Error('No mutationFn found'))\n        }\n\n        return this.options.mutationFn(variables, mutationFnContext)\n      },\n      onFail: (failureCount, error) => {\n        this.#dispatch({ type: 'failed', failureCount, error })\n      },\n      onPause: () => {\n        this.#dispatch({ type: 'pause' })\n      },\n      onContinue,\n      retry: this.options.retry ?? 0,\n      retryDelay: this.options.retryDelay,\n      networkMode: this.options.networkMode,\n      canRun: () => this.#mutationCache.canRun(this),\n    }))\n\n    const restored = this.state.status === 'pending'\n    const isPaused = !retryer.canStart()\n\n    try {\n      if (restored) {\n        // Dispatch continue action to unpause restored mutation\n        onContinue()\n      } else {\n        this.#dispatch({ type: 'pending', variables, isPaused })\n        // Notify cache callback\n        if (this.#mutationCache.config.onMutate) {\n          await this.#mutationCache.config.onMutate(\n            variables,\n            this as Mutation<unknown, unknown, unknown, unknown>,\n            mutationFnContext,\n          )\n        }\n        const context = await this.options.onMutate?.(\n          variables,\n          mutationFnContext,\n        )\n        if (context !== this.state.context) {\n          this.#dispatch({\n            type: 'pending',\n            context,\n            variables,\n            isPaused,\n          })\n        }\n      }\n      const data = await retryer.start()\n\n      // Notify cache callback\n      await this.#mutationCache.config.onSuccess?.(\n        data,\n        variables,\n        this.state.context,\n        this as Mutation<unknown, unknown, unknown, unknown>,\n        mutationFnContext,\n      )\n\n      await this.options.onSuccess?.(\n        data,\n        variables,\n        this.state.context!,\n        mutationFnContext,\n      )\n\n      // Notify cache callback\n      await this.#mutationCache.config.onSettled?.(\n        data,\n        null,\n        this.state.variables,\n        this.state.context,\n        this as Mutation<unknown, unknown, unknown, unknown>,\n        mutationFnContext,\n      )\n\n      await this.options.onSettled?.(\n        data,\n        null,\n        variables,\n        this.state.context,\n        mutationFnContext,\n      )\n\n      this.#dispatch({ type: 'success', data })\n      return data\n    } catch (error) {\n      try {\n        // Notify cache callback\n        await this.#mutationCache.config.onError?.(\n          error as any,\n          variables,\n          this.state.context,\n          this as Mutation<unknown, unknown, unknown, unknown>,\n          mutationFnContext,\n        )\n      } catch (e) {\n        void Promise.reject(e)\n      }\n\n      try {\n        await this.options.onError?.(\n          error as TError,\n          variables,\n          this.state.context,\n          mutationFnContext,\n        )\n      } catch (e) {\n        void Promise.reject(e)\n      }\n\n      try {\n        // Notify cache callback\n        await this.#mutationCache.config.onSettled?.(\n          undefined,\n          error as any,\n          this.state.variables,\n          this.state.context,\n          this as Mutation<unknown, unknown, unknown, unknown>,\n          mutationFnContext,\n        )\n      } catch (e) {\n        void Promise.reject(e)\n      }\n\n      try {\n        await this.options.onSettled?.(\n          undefined,\n          error as TError,\n          variables,\n          this.state.context,\n          mutationFnContext,\n        )\n      } catch (e) {\n        void Promise.reject(e)\n      }\n\n      this.#dispatch({ type: 'error', error: error as TError })\n      throw error\n    } finally {\n      // The settled retryer's promise would otherwise pin this mutation's\n      // result, variables and context for as long as the cache keeps it\n      if (this.#retryer === retryer) {\n        this.#retryer = undefined\n      }\n      this.#mutationCache.runNext(this)\n    }\n  }\n\n  #dispatch(action: Action<TData, TError, TVariables, TOnMutateResult>): void {\n    const reducer = (\n      state: MutationState<TData, TError, TVariables, TOnMutateResult>,\n    ): MutationState<TData, TError, TVariables, TOnMutateResult> => {\n      switch (action.type) {\n        case 'failed':\n          return {\n            ...state,\n            failureCount: action.failureCount,\n            failureReason: action.error,\n          }\n        case 'pause':\n          return {\n            ...state,\n            isPaused: true,\n          }\n        case 'continue':\n          return {\n            ...state,\n            isPaused: false,\n          }\n        case 'pending':\n          return {\n            ...state,\n            context: action.context,\n            data: undefined,\n            failureCount: 0,\n            failureReason: null,\n            error: null,\n            isPaused: action.isPaused,\n            status: 'pending',\n            variables: action.variables,\n            submittedAt: Date.now(),\n          }\n        case 'success':\n          return {\n            ...state,\n            data: action.data,\n            failureCount: 0,\n            failureReason: null,\n            error: null,\n            status: 'success',\n            isPaused: false,\n          }\n        case 'error':\n          return {\n            ...state,\n            data: undefined,\n            error: action.error,\n            failureCount: state.failureCount + 1,\n            failureReason: action.error,\n            isPaused: false,\n            status: 'error',\n          }\n      }\n    }\n    this.state = reducer(this.state)\n\n    notifyManager.batch(() => {\n      this.#observers.forEach((observer) => {\n        observer.onMutationUpdate(action)\n      })\n      this.#mutationCache.notify({\n        mutation: this,\n        type: 'updated',\n        action,\n      })\n    })\n  }\n}\n\nexport function getDefaultState<\n  TData,\n  TError,\n  TVariables,\n  TOnMutateResult,\n>(): MutationState<TData, TError, TVariables, TOnMutateResult> {\n  return {\n    context: undefined,\n    data: undefined,\n    error: null,\n    failureCount: 0,\n    failureReason: null,\n    isPaused: false,\n    status: 'idle',\n    variables: undefined,\n    submittedAt: 0,\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"mutation.js","names":[],"sources":["../../src/mutation.ts"],"sourcesContent":["import { notifyManager } from './notifyManager'\nimport { Removable } from './removable'\nimport { createRetryer } from './retryer'\nimport type {\n  DefaultError,\n  MutationFunctionContext,\n  MutationMeta,\n  MutationOptions,\n  MutationStatus,\n} from './types'\nimport type { MutationCache } from './mutationCache'\nimport type { MutationObserver } from './mutationObserver'\nimport type { Retryer } from './retryer'\nimport type { QueryClient } from './queryClient'\n\n// TYPES\n\ninterface MutationConfig<TData, TError, TVariables, TOnMutateResult> {\n  client: QueryClient\n  mutationId: number\n  mutationCache: MutationCache\n  options: MutationOptions<TData, TError, TVariables, TOnMutateResult>\n  state?: MutationState<TData, TError, TVariables, TOnMutateResult>\n}\n\n/**\n * The raw state stored on a `Mutation` instance. This is the underlying state\n * that observer results (e.g. `MutationObserverResult`) are derived from.\n */\nexport interface MutationState<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = unknown,\n  TOnMutateResult = unknown,\n> {\n  /**\n   * The value returned by `onMutate`, if defined. Passed to `onSuccess`,\n   * `onError` and `onSettled` as the mutation's context.\n   */\n  context: TOnMutateResult | undefined\n  /**\n   * The last successfully resolved data for the mutation.\n   */\n  data: TData | undefined\n  /**\n   * The error object for the mutation, if the last attempt resulted in an error.\n   * - Defaults to `null`.\n   */\n  error: TError | null\n  /**\n   * The number of times the mutation function has failed for the current attempt.\n   */\n  failureCount: number\n  /**\n   * The reason the current attempt failed, as reported by the retryer.\n   */\n  failureReason: TError | null\n  /**\n   * Whether the mutation is currently paused (see network mode), or is\n   * waiting for another mutation with the same `scope` to finish.\n   */\n  isPaused: boolean\n  /**\n   * The status of the mutation.\n   */\n  status: MutationStatus\n  /**\n   * The variables the mutation was last called with.\n   */\n  variables: TVariables | undefined\n  /**\n   * The timestamp for when the mutation was submitted.\n   */\n  submittedAt: number\n}\n\ninterface FailedAction<TError> {\n  type: 'failed'\n  failureCount: number\n  error: TError | null\n}\n\ninterface PendingAction<TVariables, TOnMutateResult> {\n  type: 'pending'\n  isPaused: boolean\n  variables?: TVariables\n  context?: TOnMutateResult\n}\n\ninterface SuccessAction<TData> {\n  type: 'success'\n  data: TData\n}\n\ninterface ErrorAction<TError> {\n  type: 'error'\n  error: TError\n}\n\ninterface PauseAction {\n  type: 'pause'\n}\n\ninterface ContinueAction {\n  type: 'continue'\n}\n\nexport type Action<TData, TError, TVariables, TOnMutateResult> =\n  | ContinueAction\n  | ErrorAction<TError>\n  | FailedAction<TError>\n  | PendingAction<TVariables, TOnMutateResult>\n  | PauseAction\n  | SuccessAction<TData>\n\n// CLASS\n\n/**\n * Represents a single mutation attempt. A `Mutation` holds the mutation's\n * options, state (data/error/status), and the `MutationObserver`s currently\n * subscribed to it.\n *\n * Instances are created and managed internally by `MutationCache`; application\n * code typically interacts with mutations indirectly through `QueryClient` or\n * a framework hook like `useMutation`. Direct access to a `Mutation` instance\n * is possible via `mutationCache.find()`/`getAll()` for inspecting cache state.\n *\n * @example\n * ```ts\n * const mutationCache = queryClient.getMutationCache()\n *\n * const mutation = mutationCache.find({ mutationKey: ['addPost'] })\n * ```\n */\nexport class Mutation<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = unknown,\n  TOnMutateResult = unknown,\n> extends Removable {\n  state: MutationState<TData, TError, TVariables, TOnMutateResult>\n  options!: MutationOptions<TData, TError, TVariables, TOnMutateResult>\n  readonly mutationId: number\n\n  #client: QueryClient\n  #observers: Array<\n    MutationObserver<TData, TError, TVariables, TOnMutateResult>\n  >\n  #mutationCache: MutationCache\n  #retryer?: Retryer<TData>\n\n  constructor(\n    config: MutationConfig<TData, TError, TVariables, TOnMutateResult>,\n  ) {\n    super()\n\n    this.#client = config.client\n    this.mutationId = config.mutationId\n    this.#mutationCache = config.mutationCache\n    this.#observers = []\n    this.state = config.state || getDefaultState()\n\n    this.setOptions(config.options)\n    this.scheduleGc()\n  }\n\n  /** @internal */\n  setOptions(\n    options: MutationOptions<TData, TError, TVariables, TOnMutateResult>,\n  ): void {\n    this.options = options\n\n    this.updateGcTime(this.options.gcTime)\n  }\n\n  /**\n   * The `meta` object passed in the mutation's options, if any.\n   */\n  get meta(): MutationMeta | undefined {\n    return this.options.meta\n  }\n\n  /** @internal */\n  addObserver(observer: MutationObserver<any, any, any, any>): void {\n    if (!this.#observers.includes(observer)) {\n      this.#observers.push(observer)\n\n      // Stop the mutation from being garbage collected\n      this.clearGcTimeout()\n\n      this.#mutationCache.notify({\n        type: 'observerAdded',\n        mutation: this,\n        observer,\n      })\n    }\n  }\n\n  /** @internal */\n  removeObserver(observer: MutationObserver<any, any, any, any>): void {\n    this.#observers = this.#observers.filter((x) => x !== observer)\n\n    this.scheduleGc()\n\n    this.#mutationCache.notify({\n      type: 'observerRemoved',\n      mutation: this,\n      observer,\n    })\n  }\n\n  protected optionalRemove() {\n    if (!this.#observers.length) {\n      if (this.state.status === 'pending') {\n        this.scheduleGc()\n      } else {\n        this.#mutationCache.remove(this)\n      }\n    }\n  }\n\n  /**\n   * Resumes a mutation that is currently paused or was restored from a\n   * dehydrated, still-`pending` state.\n   *\n   * - If this mutation has an active retryer (it paused mid-attempt, e.g. due\n   *   to the network mode or scope-based queuing), its retryer is resumed.\n   * - Otherwise, if the mutation's status is still `pending` (e.g. it was\n   *   dehydrated while an attempt was in flight and never got a retryer in\n   *   this instance), `execute` is called again with the last known variables.\n   * - Otherwise the mutation has already settled and this resolves immediately\n   *   without running anything again.\n   *\n   * @example\n   * ```ts\n   * // typically driven by reconnect handling, e.g. queryClient.resumePausedMutations()\n   * const mutation = mutationCache.find({ mutationKey: ['addPost'] })\n   * await mutation?.continue()\n   * ```\n   *\n   * @see {@link Mutation#execute}\n   */\n  continue(): Promise<unknown> {\n    return (\n      this.#retryer?.continue() ??\n      // continuing a mutation assumes that variables are set, mutation must have been dehydrated before.\n      // a settled mutation has no retryer to continue and must not run again\n      (this.state.status === 'pending'\n        ? this.execute(this.state.variables!)\n        : Promise.resolve())\n    )\n  }\n\n  /**\n   * Runs the mutation function for the given variables through a retryer, and\n   * drives the mutation's state and lifecycle callbacks through to settlement.\n   *\n   * If this mutation's state is already `pending` when `execute` is called\n   * (i.e. it was restored, still in-flight, from a dehydrated state), the\n   * `onMutate` step is skipped and a `continue` action is dispatched to\n   * unpause it; otherwise a `pending` action is dispatched first, then the\n   * mutation cache's `onMutate` and the mutation's own `onMutate` option are\n   * awaited in that order, and the resulting context is stored.\n   *\n   * The mutation function is then run (subject to `retry`/`retryDelay`/\n   * `networkMode`, and to the mutation cache's scope-based serialization).\n   * On success, the cache's `onSuccess`/`onSettled` callbacks run before the\n   * mutation's own `onSuccess`/`onSettled` options, a `success` action is\n   * dispatched, and the resolved data is returned. On failure, the same\n   * cache-then-option ordering is used for `onError`/`onSettled`, but each of\n   * those four callbacks is individually caught so that a throwing callback\n   * cannot mask the original error; an `error` action is then dispatched and\n   * the original error is re-thrown.\n   *\n   * @example\n   * ```ts\n   * // Called internally by `MutationObserver.mutate` and `Mutation.continue` —\n   * // applications normally trigger mutations through those, not this method.\n   * const data = await mutation.execute(variables)\n   * ```\n   *\n   * @see {@link Mutation#continue}\n   */\n  async execute(variables: TVariables): Promise<TData> {\n    const onContinue = () => {\n      this.#dispatch({ type: 'continue' })\n    }\n\n    const mutationFnContext = {\n      client: this.#client,\n      meta: this.options.meta,\n      mutationKey: this.options.mutationKey,\n    } satisfies MutationFunctionContext\n\n    const retryer = (this.#retryer = createRetryer({\n      fn: () => {\n        if (!this.options.mutationFn) {\n          return Promise.reject(new Error('No mutationFn found'))\n        }\n\n        return this.options.mutationFn(variables, mutationFnContext)\n      },\n      onFail: (failureCount, error) => {\n        this.#dispatch({ type: 'failed', failureCount, error })\n      },\n      onPause: () => {\n        this.#dispatch({ type: 'pause' })\n      },\n      onContinue,\n      retry: this.options.retry ?? 0,\n      retryDelay: this.options.retryDelay,\n      networkMode: this.options.networkMode,\n      canRun: () => this.#mutationCache.canRun(this),\n    }))\n\n    const restored = this.state.status === 'pending'\n    const isPaused = !retryer.canStart()\n\n    try {\n      if (restored) {\n        // Dispatch continue action to unpause restored mutation\n        onContinue()\n      } else {\n        this.#dispatch({ type: 'pending', variables, isPaused })\n        // Notify cache callback\n        if (this.#mutationCache.config.onMutate) {\n          await this.#mutationCache.config.onMutate(\n            variables,\n            this as Mutation<unknown, unknown, unknown, unknown>,\n            mutationFnContext,\n          )\n        }\n        const context = await this.options.onMutate?.(\n          variables,\n          mutationFnContext,\n        )\n        if (context !== this.state.context) {\n          this.#dispatch({\n            type: 'pending',\n            context,\n            variables,\n            isPaused,\n          })\n        }\n      }\n      const data = await retryer.start()\n\n      // Notify cache callback\n      await this.#mutationCache.config.onSuccess?.(\n        data,\n        variables,\n        this.state.context,\n        this as Mutation<unknown, unknown, unknown, unknown>,\n        mutationFnContext,\n      )\n\n      await this.options.onSuccess?.(\n        data,\n        variables,\n        this.state.context!,\n        mutationFnContext,\n      )\n\n      // Notify cache callback\n      await this.#mutationCache.config.onSettled?.(\n        data,\n        null,\n        this.state.variables,\n        this.state.context,\n        this as Mutation<unknown, unknown, unknown, unknown>,\n        mutationFnContext,\n      )\n\n      await this.options.onSettled?.(\n        data,\n        null,\n        variables,\n        this.state.context,\n        mutationFnContext,\n      )\n\n      this.#dispatch({ type: 'success', data })\n      return data\n    } catch (error) {\n      try {\n        // Notify cache callback\n        await this.#mutationCache.config.onError?.(\n          error as any,\n          variables,\n          this.state.context,\n          this as Mutation<unknown, unknown, unknown, unknown>,\n          mutationFnContext,\n        )\n      } catch (e) {\n        void Promise.reject(e)\n      }\n\n      try {\n        await this.options.onError?.(\n          error as TError,\n          variables,\n          this.state.context,\n          mutationFnContext,\n        )\n      } catch (e) {\n        void Promise.reject(e)\n      }\n\n      try {\n        // Notify cache callback\n        await this.#mutationCache.config.onSettled?.(\n          undefined,\n          error as any,\n          this.state.variables,\n          this.state.context,\n          this as Mutation<unknown, unknown, unknown, unknown>,\n          mutationFnContext,\n        )\n      } catch (e) {\n        void Promise.reject(e)\n      }\n\n      try {\n        await this.options.onSettled?.(\n          undefined,\n          error as TError,\n          variables,\n          this.state.context,\n          mutationFnContext,\n        )\n      } catch (e) {\n        void Promise.reject(e)\n      }\n\n      this.#dispatch({ type: 'error', error: error as TError })\n      throw error\n    } finally {\n      // The settled retryer's promise would otherwise pin this mutation's\n      // result, variables and context for as long as the cache keeps it\n      if (this.#retryer === retryer) {\n        this.#retryer = undefined\n      }\n      this.#mutationCache.runNext(this)\n    }\n  }\n\n  #dispatch(action: Action<TData, TError, TVariables, TOnMutateResult>): void {\n    const reducer = (\n      state: MutationState<TData, TError, TVariables, TOnMutateResult>,\n    ): MutationState<TData, TError, TVariables, TOnMutateResult> => {\n      switch (action.type) {\n        case 'failed':\n          return {\n            ...state,\n            failureCount: action.failureCount,\n            failureReason: action.error,\n          }\n        case 'pause':\n          return {\n            ...state,\n            isPaused: true,\n          }\n        case 'continue':\n          return {\n            ...state,\n            isPaused: false,\n          }\n        case 'pending':\n          return {\n            ...state,\n            context: action.context,\n            data: undefined,\n            failureCount: 0,\n            failureReason: null,\n            error: null,\n            isPaused: action.isPaused,\n            status: 'pending',\n            variables: action.variables,\n            submittedAt: Date.now(),\n          }\n        case 'success':\n          return {\n            ...state,\n            data: action.data,\n            failureCount: 0,\n            failureReason: null,\n            error: null,\n            status: 'success',\n            isPaused: false,\n          }\n        case 'error':\n          return {\n            ...state,\n            data: undefined,\n            error: action.error,\n            failureCount: state.failureCount + 1,\n            failureReason: action.error,\n            isPaused: false,\n            status: 'error',\n          }\n      }\n    }\n    this.state = reducer(this.state)\n\n    notifyManager.batch(() => {\n      this.#observers.forEach((observer) => {\n        observer.onMutationUpdate(action)\n      })\n      this.#mutationCache.notify({\n        mutation: this,\n        type: 'updated',\n        action,\n      })\n    })\n  }\n}\n\nexport function getDefaultState<\n  TData,\n  TError,\n  TVariables,\n  TOnMutateResult,\n>(): MutationState<TData, TError, TVariables, TOnMutateResult> {\n  return {\n    context: undefined,\n    data: undefined,\n    error: null,\n    failureCount: 0,\n    failureReason: null,\n    isPaused: false,\n    status: 'idle',\n    variables: undefined,\n    submittedAt: 0,\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAsIA,IAAa,WAAb,cAKU,UAAU;CAKlB;CACA;CAGA;CACA;CAEA,YACE,QACA;EACA,MAAM;EAEN,KAAK,UAAU,OAAO;EACtB,KAAK,aAAa,OAAO;EACzB,KAAK,iBAAiB,OAAO;EAC7B,KAAK,aAAa,CAAC;EACnB,KAAK,QAAQ,OAAO,SAAS,gBAAgB;EAE7C,KAAK,WAAW,OAAO,OAAO;EAC9B,KAAK,WAAW;CAClB;;CAGA,WACE,SACM;EACN,KAAK,UAAU;EAEf,KAAK,aAAa,KAAK,QAAQ,MAAM;CACvC;;;;CAKA,IAAI,OAAiC;EACnC,OAAO,KAAK,QAAQ;CACtB;;CAGA,YAAY,UAAsD;EAChE,IAAI,CAAC,KAAK,WAAW,SAAS,QAAQ,GAAG;GACvC,KAAK,WAAW,KAAK,QAAQ;GAG7B,KAAK,eAAe;GAEpB,KAAK,eAAe,OAAO;IACzB,MAAM;IACN,UAAU;IACV;GACF,CAAC;EACH;CACF;;CAGA,eAAe,UAAsD;EACnE,KAAK,aAAa,KAAK,WAAW,QAAQ,MAAM,MAAM,QAAQ;EAE9D,KAAK,WAAW;EAEhB,KAAK,eAAe,OAAO;GACzB,MAAM;GACN,UAAU;GACV;EACF,CAAC;CACH;CAEA,iBAA2B;EACzB,IAAI,CAAC,KAAK,WAAW,QAAQ;GAC3B,IAAI,KAAK,MAAM,WAAW,WACxB,KAAK,WAAW;QAEhB,KAAK,eAAe,OAAO,IAAI;EAEnC;CACF;;;;;;;;;;;;;;;;;;;;;;CAuBA,WAA6B;EAC3B,OACE,KAAK,UAAU,SAAS,MAGvB,KAAK,MAAM,WAAW,YACnB,KAAK,QAAQ,KAAK,MAAM,SAAU,IAClC,QAAQ,QAAQ;CAExB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCA,MAAM,QAAQ,WAAuC;EACnD,MAAM,mBAAmB;GACvB,KAAK,UAAU,EAAE,MAAM,WAAW,CAAC;EACrC;EAEA,MAAM,oBAAoB;GACxB,QAAQ,KAAK;GACb,MAAM,KAAK,QAAQ;GACnB,aAAa,KAAK,QAAQ;EAC5B;EAEA,MAAM,UAAW,KAAK,WAAW,cAAc;GAC7C,UAAU;IACR,IAAI,CAAC,KAAK,QAAQ,YAChB,OAAO,QAAQ,uBAAO,IAAI,MAAM,qBAAqB,CAAC;IAGxD,OAAO,KAAK,QAAQ,WAAW,WAAW,iBAAiB;GAC7D;GACA,SAAS,cAAc,UAAU;IAC/B,KAAK,UAAU;KAAE,MAAM;KAAU;KAAc;IAAM,CAAC;GACxD;GACA,eAAe;IACb,KAAK,UAAU,EAAE,MAAM,QAAQ,CAAC;GAClC;GACA;GACA,OAAO,KAAK,QAAQ,SAAS;GAC7B,YAAY,KAAK,QAAQ;GACzB,aAAa,KAAK,QAAQ;GAC1B,cAAc,KAAK,eAAe,OAAO,IAAI;EAC/C,CAAC;EAED,MAAM,WAAW,KAAK,MAAM,WAAW;EACvC,MAAM,WAAW,CAAC,QAAQ,SAAS;EAEnC,IAAI;GACF,IAAI,UAEF,WAAW;QACN;IACL,KAAK,UAAU;KAAE,MAAM;KAAW;KAAW;IAAS,CAAC;IAEvD,IAAI,KAAK,eAAe,OAAO,UAC7B,MAAM,KAAK,eAAe,OAAO,SAC/B,WACA,MACA,iBACF;IAEF,MAAM,UAAU,MAAM,KAAK,QAAQ,WACjC,WACA,iBACF;IACA,IAAI,YAAY,KAAK,MAAM,SACzB,KAAK,UAAU;KACb,MAAM;KACN;KACA;KACA;IACF,CAAC;GAEL;GACA,MAAM,OAAO,MAAM,QAAQ,MAAM;GAGjC,MAAM,KAAK,eAAe,OAAO,YAC/B,MACA,WACA,KAAK,MAAM,SACX,MACA,iBACF;GAEA,MAAM,KAAK,QAAQ,YACjB,MACA,WACA,KAAK,MAAM,SACX,iBACF;GAGA,MAAM,KAAK,eAAe,OAAO,YAC/B,MACA,MACA,KAAK,MAAM,WACX,KAAK,MAAM,SACX,MACA,iBACF;GAEA,MAAM,KAAK,QAAQ,YACjB,MACA,MACA,WACA,KAAK,MAAM,SACX,iBACF;GAEA,KAAK,UAAU;IAAE,MAAM;IAAW;GAAK,CAAC;GACxC,OAAO;EACT,SAAS,OAAO;GACd,IAAI;IAEF,MAAM,KAAK,eAAe,OAAO,UAC/B,OACA,WACA,KAAK,MAAM,SACX,MACA,iBACF;GACF,SAAS,GAAG;IACV,QAAa,OAAO,CAAC;GACvB;GAEA,IAAI;IACF,MAAM,KAAK,QAAQ,UACjB,OACA,WACA,KAAK,MAAM,SACX,iBACF;GACF,SAAS,GAAG;IACV,QAAa,OAAO,CAAC;GACvB;GAEA,IAAI;IAEF,MAAM,KAAK,eAAe,OAAO,YAC/B,KAAA,GACA,OACA,KAAK,MAAM,WACX,KAAK,MAAM,SACX,MACA,iBACF;GACF,SAAS,GAAG;IACV,QAAa,OAAO,CAAC;GACvB;GAEA,IAAI;IACF,MAAM,KAAK,QAAQ,YACjB,KAAA,GACA,OACA,WACA,KAAK,MAAM,SACX,iBACF;GACF,SAAS,GAAG;IACV,QAAa,OAAO,CAAC;GACvB;GAEA,KAAK,UAAU;IAAE,MAAM;IAAgB;GAAgB,CAAC;GACxD,MAAM;EACR,UAAU;GAGR,IAAI,KAAK,aAAa,SACpB,KAAK,WAAW,KAAA;GAElB,KAAK,eAAe,QAAQ,IAAI;EAClC;CACF;CAEA,UAAU,QAAkE;EAC1E,MAAM,WACJ,UAC8D;GAC9D,QAAQ,OAAO,MAAf;IACE,KAAK,UACH,OAAO;KACL,GAAG;KACH,cAAc,OAAO;KACrB,eAAe,OAAO;IACxB;IACF,KAAK,SACH,OAAO;KACL,GAAG;KACH,UAAU;IACZ;IACF,KAAK,YACH,OAAO;KACL,GAAG;KACH,UAAU;IACZ;IACF,KAAK,WACH,OAAO;KACL,GAAG;KACH,SAAS,OAAO;KAChB,MAAM,KAAA;KACN,cAAc;KACd,eAAe;KACf,OAAO;KACP,UAAU,OAAO;KACjB,QAAQ;KACR,WAAW,OAAO;KAClB,aAAa,KAAK,IAAI;IACxB;IACF,KAAK,WACH,OAAO;KACL,GAAG;KACH,MAAM,OAAO;KACb,cAAc;KACd,eAAe;KACf,OAAO;KACP,QAAQ;KACR,UAAU;IACZ;IACF,KAAK,SACH,OAAO;KACL,GAAG;KACH,MAAM,KAAA;KACN,OAAO,OAAO;KACd,cAAc,MAAM,eAAe;KACnC,eAAe,OAAO;KACtB,UAAU;KACV,QAAQ;IACV;GACJ;EACF;EACA,KAAK,QAAQ,QAAQ,KAAK,KAAK;EAE/B,cAAc,YAAY;GACxB,KAAK,WAAW,SAAS,aAAa;IACpC,SAAS,iBAAiB,MAAM;GAClC,CAAC;GACD,KAAK,eAAe,OAAO;IACzB,UAAU;IACV,MAAM;IACN;GACF,CAAC;EACH,CAAC;CACH;AACF;AAEA,SAAgB,kBAK+C;CAC7D,OAAO;EACL,SAAS,KAAA;EACT,MAAM,KAAA;EACN,OAAO;EACP,cAAc;EACd,eAAe;EACf,UAAU;EACV,QAAQ;EACR,WAAW,KAAA;EACX,aAAa;CACf;AACF"}

package/build/modern/mutationCache.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"mutationCache.cjs","names":["Subscribable","#mutations","#scopes","#mutationId","Mutation","matchMutation","notifyManager","noop"],"sources":["../../src/mutationCache.ts"],"sourcesContent":["import { notifyManager } from './notifyManager'\nimport { Mutation } from './mutation'\nimport { matchMutation, noop } from './utils'\nimport { Subscribable } from './subscribable'\nimport type { MutationObserver } from './mutationObserver'\nimport type {\n  DefaultError,\n  MutationFunctionContext,\n  MutationOptions,\n  NotifyEvent,\n} from './types'\nimport type { QueryClient } from './queryClient'\nimport type { Action, MutationState } from './mutation'\nimport type { MutationFilters } from './utils'\n\n// TYPES\n\n/**\n * Global callbacks that fire for every mutation handled by a `MutationCache`, regardless of which\n * component or observer triggered it. They differ from the `defaultOptions` provided to a\n * `QueryClient` in two ways: `defaultOptions` can be overridden by each mutation, while these\n * callbacks are always called, and `onMutate` here does not allow returning a result.\n *\n * If a callback returns a promise, it will be awaited before the mutation continues.\n */\nexport interface MutationCacheConfig {\n  /** Called when any mutation in the cache encounters an error. */\n  onError?: (\n    error: DefaultError,\n    variables: unknown,\n    onMutateResult: unknown,\n    mutation: Mutation<unknown, unknown, unknown>,\n    context: MutationFunctionContext,\n  ) => Promise<unknown> | unknown\n  /** Called when any mutation in the cache is successful. */\n  onSuccess?: (\n    data: unknown,\n    variables: unknown,\n    onMutateResult: unknown,\n    mutation: Mutation<unknown, unknown, unknown>,\n    context: MutationFunctionContext,\n  ) => Promise<unknown> | unknown\n  /** Called before any mutation in the cache executes. */\n  onMutate?: (\n    variables: unknown,\n    mutation: Mutation<unknown, unknown, unknown>,\n    context: MutationFunctionContext,\n  ) => Promise<unknown> | unknown\n  /** Called when any mutation in the cache is settled, either successfully or with an error. */\n  onSettled?: (\n    data: unknown | undefined,\n    error: DefaultError | null,\n    variables: unknown,\n    onMutateResult: unknown,\n    mutation: Mutation<unknown, unknown, unknown>,\n    context: MutationFunctionContext,\n  ) => Promise<unknown> | unknown\n}\n\ninterface NotifyEventMutationAdded extends NotifyEvent {\n  type: 'added'\n  mutation: Mutation<any, any, any, any>\n}\ninterface NotifyEventMutationRemoved extends NotifyEvent {\n  type: 'removed'\n  mutation: Mutation<any, any, any, any>\n}\n\ninterface NotifyEventMutationObserverAdded extends NotifyEvent {\n  type: 'observerAdded'\n  mutation: Mutation<any, any, any, any>\n  observer: MutationObserver<any, any, any>\n}\n\ninterface NotifyEventMutationObserverRemoved extends NotifyEvent {\n  type: 'observerRemoved'\n  mutation: Mutation<any, any, any, any>\n  observer: MutationObserver<any, any, any>\n}\n\ninterface NotifyEventMutationObserverOptionsUpdated extends NotifyEvent {\n  type: 'observerOptionsUpdated'\n  mutation?: Mutation<any, any, any, any>\n  observer: MutationObserver<any, any, any, any>\n}\n\ninterface NotifyEventMutationUpdated extends NotifyEvent {\n  type: 'updated'\n  mutation: Mutation<any, any, any, any>\n  action: Action<any, any, any, any>\n}\n\n/**\n * The event passed to a `MutationCache` subscriber. Fired whenever a mutation is added or removed\n * from the cache, its state is updated, or one of its observers is added, removed, or has its\n * options updated.\n */\nexport type MutationCacheNotifyEvent =\n  | NotifyEventMutationAdded\n  | NotifyEventMutationRemoved\n  | NotifyEventMutationObserverAdded\n  | NotifyEventMutationObserverRemoved\n  | NotifyEventMutationObserverOptionsUpdated\n  | NotifyEventMutationUpdated\n\ntype MutationCacheListener = (event: MutationCacheNotifyEvent) => void\n\n// CLASS\n\n/**\n * The `MutationCache` is the storage for mutations.\n *\n * Normally, you will not interact with the `MutationCache` directly and instead use a\n * `QueryClient`. You can subscribe to it (inherited from `Subscribable`) to be informed of\n * safe/known updates to the cache, such as mutations being added, removed, or updated.\n *\n * @example\n * ```ts\n * const unsubscribe = mutationCache.subscribe((event) => {\n *   console.log(event.type, event.mutation)\n * })\n * ```\n */\nexport class MutationCache extends Subscribable<MutationCacheListener> {\n  #mutations: Set<Mutation<any, any, any, any>>\n  #scopes: Map<string, Array<Mutation<any, any, any, any>>>\n  #mutationId: number\n\n  constructor(public config: MutationCacheConfig = {}) {\n    super()\n    this.#mutations = new Set()\n    this.#scopes = new Map()\n    this.#mutationId = 0\n  }\n\n  /** @internal */\n  build<TData, TError, TVariables, TOnMutateResult>(\n    client: QueryClient,\n    options: MutationOptions<TData, TError, TVariables, TOnMutateResult>,\n    state?: MutationState<TData, TError, TVariables, TOnMutateResult>,\n  ): Mutation<TData, TError, TVariables, TOnMutateResult> {\n    const mutation = new Mutation({\n      client,\n      mutationCache: this,\n      mutationId: ++this.#mutationId,\n      options: client.defaultMutationOptions(options),\n      state,\n    })\n\n    this.add(mutation)\n\n    return mutation\n  }\n\n  /** @internal */\n  add(mutation: Mutation<any, any, any, any>): void {\n    this.#mutations.add(mutation)\n    const scope = scopeFor(mutation)\n    if (typeof scope === 'string') {\n      const scopedMutations = this.#scopes.get(scope)\n      if (scopedMutations) {\n        scopedMutations.push(mutation)\n      } else {\n        this.#scopes.set(scope, [mutation])\n      }\n    }\n    this.notify({ type: 'added', mutation })\n  }\n\n  /** @internal */\n  remove(mutation: Mutation<any, any, any, any>): void {\n    if (this.#mutations.delete(mutation)) {\n      const scope = scopeFor(mutation)\n      if (typeof scope === 'string') {\n        const scopedMutations = this.#scopes.get(scope)\n        if (scopedMutations) {\n          if (scopedMutations.length > 1) {\n            const index = scopedMutations.indexOf(mutation)\n            if (index !== -1) {\n              scopedMutations.splice(index, 1)\n            }\n          } else if (scopedMutations[0] === mutation) {\n            this.#scopes.delete(scope)\n          }\n        }\n      }\n    }\n\n    // Currently we notify the removal even if the mutation was already removed.\n    // Consider making this an error or not notifying of the removal depending on the desired semantics.\n    this.notify({ type: 'removed', mutation })\n  }\n\n  /** @internal */\n  canRun(mutation: Mutation<any, any, any, any>): boolean {\n    const scope = scopeFor(mutation)\n    if (typeof scope === 'string') {\n      const mutationsWithSameScope = this.#scopes.get(scope)\n      const firstPendingMutation = mutationsWithSameScope?.find(\n        (m) => m.state.status === 'pending',\n      )\n      // we can run if there is no current pending mutation (start use-case)\n      // or if WE are the first pending mutation (continue use-case)\n      return !firstPendingMutation || firstPendingMutation === mutation\n    } else {\n      // For unscoped mutations there are never any pending mutations in front of the\n      // current mutation\n      return true\n    }\n  }\n\n  /** @internal */\n  runNext(mutation: Mutation<any, any, any, any>): Promise<unknown> {\n    const scope = scopeFor(mutation)\n    if (typeof scope === 'string') {\n      const foundMutation = this.#scopes\n        .get(scope)\n        ?.find((m) => m !== mutation && m.state.isPaused)\n\n      return foundMutation?.continue() ?? Promise.resolve()\n    } else {\n      return Promise.resolve()\n    }\n  }\n\n  /**\n   * Removes all mutations from the cache.\n   *\n   * @example\n   * ```ts\n   * const mutationCache = queryClient.getMutationCache()\n   *\n   * mutationCache.clear()\n   * ```\n   */\n  clear(): void {\n    notifyManager.batch(() => {\n      this.#mutations.forEach((mutation) => {\n        this.notify({ type: 'removed', mutation })\n      })\n      this.#mutations.clear()\n      this.#scopes.clear()\n    })\n  }\n\n  /**\n   * Returns all mutations within the cache.\n   *\n   * This is not typically needed for most applications, but can come in handy when needing more\n   * information about a mutation in rare scenarios.\n   *\n   * @example\n   * ```ts\n   * const mutationCache = queryClient.getMutationCache()\n   *\n   * const mutations = mutationCache.getAll()\n   * ```\n   */\n  getAll(): Array<Mutation> {\n    return Array.from(this.#mutations)\n  }\n\n  /**\n   * A slightly more advanced method that can be used to get an existing mutation instance from\n   * the cache. If the mutation does not exist, `undefined` is returned.\n   *\n   * This is not typically needed for most applications, but can come in handy when needing more\n   * information about a mutation in rare scenarios.\n   *\n   * @see {@link MutationCache#findAll}\n   * @example\n   * ```ts\n   * const mutationCache = queryClient.getMutationCache()\n   *\n   * const mutation = mutationCache.find({ mutationKey: ['addPost'] })\n   * ```\n   */\n  find<\n    TData = unknown,\n    TError = DefaultError,\n    TVariables = any,\n    TOnMutateResult = unknown,\n  >(\n    filters: MutationFilters,\n  ): Mutation<TData, TError, TVariables, TOnMutateResult> | undefined {\n    const defaultedFilters = { exact: true, ...filters }\n\n    return this.getAll().find((mutation) =>\n      matchMutation(defaultedFilters, mutation),\n    ) as Mutation<TData, TError, TVariables, TOnMutateResult> | undefined\n  }\n\n  /**\n   * An even more advanced method that can be used to get existing mutation instances from the\n   * cache that match the given filters. If no mutations match, an empty array is returned.\n   *\n   * This is not typically needed for most applications, but can come in handy when needing more\n   * information about mutations in rare scenarios.\n   *\n   * @see {@link MutationCache#find}\n   * @example\n   * ```ts\n   * const mutationCache = queryClient.getMutationCache()\n   *\n   * const mutations = mutationCache.findAll({ mutationKey: ['addPost'] })\n   * ```\n   */\n  findAll(filters: MutationFilters = {}): Array<Mutation> {\n    return this.getAll().filter((mutation) => matchMutation(filters, mutation))\n  }\n\n  /** @internal */\n  notify(event: MutationCacheNotifyEvent) {\n    notifyManager.batch(() => {\n      this.listeners.forEach((listener) => {\n        listener(event)\n      })\n    })\n  }\n\n  /** @internal */\n  resumePausedMutations(): Promise<unknown> {\n    const pausedMutations = this.getAll().filter((x) => x.state.isPaused)\n\n    return notifyManager.batch(() =>\n      Promise.all(\n        pausedMutations.map((mutation) => mutation.continue().catch(noop)),\n      ),\n    )\n  }\n}\n\nfunction scopeFor(mutation: Mutation<any, any, any, any>) {\n  return mutation.options.scope?.id\n}\n"],"mappings":"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"}
+{"version":3,"file":"mutationCache.cjs","names":["Subscribable","Mutation","matchMutation","notifyManager","noop"],"sources":["../../src/mutationCache.ts"],"sourcesContent":["import { notifyManager } from './notifyManager'\nimport { Mutation } from './mutation'\nimport { matchMutation, noop } from './utils'\nimport { Subscribable } from './subscribable'\nimport type { MutationObserver } from './mutationObserver'\nimport type {\n  DefaultError,\n  MutationFunctionContext,\n  MutationOptions,\n  NotifyEvent,\n} from './types'\nimport type { QueryClient } from './queryClient'\nimport type { Action, MutationState } from './mutation'\nimport type { MutationFilters } from './utils'\n\n// TYPES\n\n/**\n * Global callbacks that fire for every mutation handled by a `MutationCache`, regardless of which\n * component or observer triggered it. They differ from the `defaultOptions` provided to a\n * `QueryClient` in two ways: `defaultOptions` can be overridden by each mutation, while these\n * callbacks are always called, and `onMutate` here does not allow returning a result.\n *\n * If a callback returns a promise, it will be awaited before the mutation continues.\n */\nexport interface MutationCacheConfig {\n  /** Called when any mutation in the cache encounters an error. */\n  onError?: (\n    error: DefaultError,\n    variables: unknown,\n    onMutateResult: unknown,\n    mutation: Mutation<unknown, unknown, unknown>,\n    context: MutationFunctionContext,\n  ) => Promise<unknown> | unknown\n  /** Called when any mutation in the cache is successful. */\n  onSuccess?: (\n    data: unknown,\n    variables: unknown,\n    onMutateResult: unknown,\n    mutation: Mutation<unknown, unknown, unknown>,\n    context: MutationFunctionContext,\n  ) => Promise<unknown> | unknown\n  /** Called before any mutation in the cache executes. */\n  onMutate?: (\n    variables: unknown,\n    mutation: Mutation<unknown, unknown, unknown>,\n    context: MutationFunctionContext,\n  ) => Promise<unknown> | unknown\n  /** Called when any mutation in the cache is settled, either successfully or with an error. */\n  onSettled?: (\n    data: unknown | undefined,\n    error: DefaultError | null,\n    variables: unknown,\n    onMutateResult: unknown,\n    mutation: Mutation<unknown, unknown, unknown>,\n    context: MutationFunctionContext,\n  ) => Promise<unknown> | unknown\n}\n\ninterface NotifyEventMutationAdded extends NotifyEvent {\n  type: 'added'\n  mutation: Mutation<any, any, any, any>\n}\ninterface NotifyEventMutationRemoved extends NotifyEvent {\n  type: 'removed'\n  mutation: Mutation<any, any, any, any>\n}\n\ninterface NotifyEventMutationObserverAdded extends NotifyEvent {\n  type: 'observerAdded'\n  mutation: Mutation<any, any, any, any>\n  observer: MutationObserver<any, any, any>\n}\n\ninterface NotifyEventMutationObserverRemoved extends NotifyEvent {\n  type: 'observerRemoved'\n  mutation: Mutation<any, any, any, any>\n  observer: MutationObserver<any, any, any>\n}\n\ninterface NotifyEventMutationObserverOptionsUpdated extends NotifyEvent {\n  type: 'observerOptionsUpdated'\n  mutation?: Mutation<any, any, any, any>\n  observer: MutationObserver<any, any, any, any>\n}\n\ninterface NotifyEventMutationUpdated extends NotifyEvent {\n  type: 'updated'\n  mutation: Mutation<any, any, any, any>\n  action: Action<any, any, any, any>\n}\n\n/**\n * The event passed to a `MutationCache` subscriber. Fired whenever a mutation is added or removed\n * from the cache, its state is updated, or one of its observers is added, removed, or has its\n * options updated.\n */\nexport type MutationCacheNotifyEvent =\n  | NotifyEventMutationAdded\n  | NotifyEventMutationRemoved\n  | NotifyEventMutationObserverAdded\n  | NotifyEventMutationObserverRemoved\n  | NotifyEventMutationObserverOptionsUpdated\n  | NotifyEventMutationUpdated\n\ntype MutationCacheListener = (event: MutationCacheNotifyEvent) => void\n\n// CLASS\n\n/**\n * The `MutationCache` is the storage for mutations.\n *\n * Normally, you will not interact with the `MutationCache` directly and instead use a\n * `QueryClient`. You can subscribe to it (inherited from `Subscribable`) to be informed of\n * safe/known updates to the cache, such as mutations being added, removed, or updated.\n *\n * @example\n * ```ts\n * const unsubscribe = mutationCache.subscribe((event) => {\n *   console.log(event.type, event.mutation)\n * })\n * ```\n */\nexport class MutationCache extends Subscribable<MutationCacheListener> {\n  #mutations: Set<Mutation<any, any, any, any>>\n  #scopes: Map<string, Array<Mutation<any, any, any, any>>>\n  #mutationId: number\n\n  constructor(public config: MutationCacheConfig = {}) {\n    super()\n    this.#mutations = new Set()\n    this.#scopes = new Map()\n    this.#mutationId = 0\n  }\n\n  /** @internal */\n  build<TData, TError, TVariables, TOnMutateResult>(\n    client: QueryClient,\n    options: MutationOptions<TData, TError, TVariables, TOnMutateResult>,\n    state?: MutationState<TData, TError, TVariables, TOnMutateResult>,\n  ): Mutation<TData, TError, TVariables, TOnMutateResult> {\n    const mutation = new Mutation({\n      client,\n      mutationCache: this,\n      mutationId: ++this.#mutationId,\n      options: client.defaultMutationOptions(options),\n      state,\n    })\n\n    this.add(mutation)\n\n    return mutation\n  }\n\n  /** @internal */\n  add(mutation: Mutation<any, any, any, any>): void {\n    this.#mutations.add(mutation)\n    const scope = scopeFor(mutation)\n    if (typeof scope === 'string') {\n      const scopedMutations = this.#scopes.get(scope)\n      if (scopedMutations) {\n        scopedMutations.push(mutation)\n      } else {\n        this.#scopes.set(scope, [mutation])\n      }\n    }\n    this.notify({ type: 'added', mutation })\n  }\n\n  /** @internal */\n  remove(mutation: Mutation<any, any, any, any>): void {\n    if (this.#mutations.delete(mutation)) {\n      const scope = scopeFor(mutation)\n      if (typeof scope === 'string') {\n        const scopedMutations = this.#scopes.get(scope)\n        if (scopedMutations) {\n          if (scopedMutations.length > 1) {\n            const index = scopedMutations.indexOf(mutation)\n            if (index !== -1) {\n              scopedMutations.splice(index, 1)\n            }\n          } else if (scopedMutations[0] === mutation) {\n            this.#scopes.delete(scope)\n          }\n        }\n      }\n    }\n\n    // Currently we notify the removal even if the mutation was already removed.\n    // Consider making this an error or not notifying of the removal depending on the desired semantics.\n    this.notify({ type: 'removed', mutation })\n  }\n\n  /** @internal */\n  canRun(mutation: Mutation<any, any, any, any>): boolean {\n    const scope = scopeFor(mutation)\n    if (typeof scope === 'string') {\n      const mutationsWithSameScope = this.#scopes.get(scope)\n      const firstPendingMutation = mutationsWithSameScope?.find(\n        (m) => m.state.status === 'pending',\n      )\n      // we can run if there is no current pending mutation (start use-case)\n      // or if WE are the first pending mutation (continue use-case)\n      return !firstPendingMutation || firstPendingMutation === mutation\n    } else {\n      // For unscoped mutations there are never any pending mutations in front of the\n      // current mutation\n      return true\n    }\n  }\n\n  /** @internal */\n  runNext(mutation: Mutation<any, any, any, any>): Promise<unknown> {\n    const scope = scopeFor(mutation)\n    if (typeof scope === 'string') {\n      const foundMutation = this.#scopes\n        .get(scope)\n        ?.find((m) => m !== mutation && m.state.isPaused)\n\n      return foundMutation?.continue() ?? Promise.resolve()\n    } else {\n      return Promise.resolve()\n    }\n  }\n\n  /**\n   * Removes all mutations from the cache.\n   *\n   * @example\n   * ```ts\n   * const mutationCache = queryClient.getMutationCache()\n   *\n   * mutationCache.clear()\n   * ```\n   */\n  clear(): void {\n    notifyManager.batch(() => {\n      this.#mutations.forEach((mutation) => {\n        this.notify({ type: 'removed', mutation })\n      })\n      this.#mutations.clear()\n      this.#scopes.clear()\n    })\n  }\n\n  /**\n   * Returns all mutations within the cache.\n   *\n   * This is not typically needed for most applications, but can come in handy when needing more\n   * information about a mutation in rare scenarios.\n   *\n   * @example\n   * ```ts\n   * const mutationCache = queryClient.getMutationCache()\n   *\n   * const mutations = mutationCache.getAll()\n   * ```\n   */\n  getAll(): Array<Mutation> {\n    return Array.from(this.#mutations)\n  }\n\n  /**\n   * A slightly more advanced method that can be used to get an existing mutation instance from\n   * the cache. If the mutation does not exist, `undefined` is returned.\n   *\n   * This is not typically needed for most applications, but can come in handy when needing more\n   * information about a mutation in rare scenarios.\n   *\n   * @see {@link MutationCache#findAll}\n   * @example\n   * ```ts\n   * const mutationCache = queryClient.getMutationCache()\n   *\n   * const mutation = mutationCache.find({ mutationKey: ['addPost'] })\n   * ```\n   */\n  find<\n    TData = unknown,\n    TError = DefaultError,\n    TVariables = any,\n    TOnMutateResult = unknown,\n  >(\n    filters: MutationFilters,\n  ): Mutation<TData, TError, TVariables, TOnMutateResult> | undefined {\n    const defaultedFilters = { exact: true, ...filters }\n\n    return this.getAll().find((mutation) =>\n      matchMutation(defaultedFilters, mutation),\n    ) as Mutation<TData, TError, TVariables, TOnMutateResult> | undefined\n  }\n\n  /**\n   * An even more advanced method that can be used to get existing mutation instances from the\n   * cache that match the given filters. If no mutations match, an empty array is returned.\n   *\n   * This is not typically needed for most applications, but can come in handy when needing more\n   * information about mutations in rare scenarios.\n   *\n   * @see {@link MutationCache#find}\n   * @example\n   * ```ts\n   * const mutationCache = queryClient.getMutationCache()\n   *\n   * const mutations = mutationCache.findAll({ mutationKey: ['addPost'] })\n   * ```\n   */\n  findAll(filters: MutationFilters = {}): Array<Mutation> {\n    return this.getAll().filter((mutation) => matchMutation(filters, mutation))\n  }\n\n  /** @internal */\n  notify(event: MutationCacheNotifyEvent) {\n    notifyManager.batch(() => {\n      this.listeners.forEach((listener) => {\n        listener(event)\n      })\n    })\n  }\n\n  /** @internal */\n  resumePausedMutations(): Promise<unknown> {\n    const pausedMutations = this.getAll().filter((x) => x.state.isPaused)\n\n    return notifyManager.batch(() =>\n      Promise.all(\n        pausedMutations.map((mutation) => mutation.continue().catch(noop)),\n      ),\n    )\n  }\n}\n\nfunction scopeFor(mutation: Mutation<any, any, any, any>) {\n  return mutation.options.scope?.id\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA2HA,IAAa,gBAAb,cAAmCA,qBAAAA,aAAoC;CACrE;CACA;CACA;CAEA,YAAY,SAAqC,CAAC,GAAG;EACnD,MAAM;EADW,KAAA,SAAA;EAEjB,KAAK,6BAAa,IAAI,IAAI;EAC1B,KAAK,0BAAU,IAAI,IAAI;EACvB,KAAK,cAAc;CACrB;;CAGA,MACE,QACA,SACA,OACsD;EACtD,MAAM,WAAW,IAAIC,iBAAAA,SAAS;GAC5B;GACA,eAAe;GACf,YAAY,EAAE,KAAK;GACnB,SAAS,OAAO,uBAAuB,OAAO;GAC9C;EACF,CAAC;EAED,KAAK,IAAI,QAAQ;EAEjB,OAAO;CACT;;CAGA,IAAI,UAA8C;EAChD,KAAK,WAAW,IAAI,QAAQ;EAC5B,MAAM,QAAQ,SAAS,QAAQ;EAC/B,IAAI,OAAO,UAAU,UAAU;GAC7B,MAAM,kBAAkB,KAAK,QAAQ,IAAI,KAAK;GAC9C,IAAI,iBACF,gBAAgB,KAAK,QAAQ;QAE7B,KAAK,QAAQ,IAAI,OAAO,CAAC,QAAQ,CAAC;EAEtC;EACA,KAAK,OAAO;GAAE,MAAM;GAAS;EAAS,CAAC;CACzC;;CAGA,OAAO,UAA8C;EACnD,IAAI,KAAK,WAAW,OAAO,QAAQ,GAAG;GACpC,MAAM,QAAQ,SAAS,QAAQ;GAC/B,IAAI,OAAO,UAAU,UAAU;IAC7B,MAAM,kBAAkB,KAAK,QAAQ,IAAI,KAAK;IAC9C,IAAI,iBAAiB;KACnB,IAAI,gBAAgB,SAAS,GAAG;MAC9B,MAAM,QAAQ,gBAAgB,QAAQ,QAAQ;MAC9C,IAAI,UAAU,IACZ,gBAAgB,OAAO,OAAO,CAAC;KAEnC,OAAO,IAAI,gBAAgB,OAAO,UAChC,KAAK,QAAQ,OAAO,KAAK;IAE7B;GACF;EACF;EAIA,KAAK,OAAO;GAAE,MAAM;GAAW;EAAS,CAAC;CAC3C;;CAGA,OAAO,UAAiD;EACtD,MAAM,QAAQ,SAAS,QAAQ;EAC/B,IAAI,OAAO,UAAU,UAAU;GAE7B,MAAM,uBADyB,KAAK,QAAQ,IAAI,KACE,CAAC,EAAE,MAClD,MAAM,EAAE,MAAM,WAAW,SAC5B;GAGA,OAAO,CAAC,wBAAwB,yBAAyB;EAC3D,OAGE,OAAO;CAEX;;CAGA,QAAQ,UAA0D;EAChE,MAAM,QAAQ,SAAS,QAAQ;EAC/B,IAAI,OAAO,UAAU,UAKnB,QAJsB,KAAK,QACxB,IAAI,KAAK,CAAC,EACT,MAAM,MAAM,MAAM,YAAY,EAAE,MAAM,QAAQ,EAAA,EAE5B,SAAS,KAAK,QAAQ,QAAQ;OAEpD,OAAO,QAAQ,QAAQ;CAE3B;;;;;;;;;;;CAYA,QAAc;EACZ,sBAAA,cAAc,YAAY;GACxB,KAAK,WAAW,SAAS,aAAa;IACpC,KAAK,OAAO;KAAE,MAAM;KAAW;IAAS,CAAC;GAC3C,CAAC;GACD,KAAK,WAAW,MAAM;GACtB,KAAK,QAAQ,MAAM;EACrB,CAAC;CACH;;;;;;;;;;;;;;CAeA,SAA0B;EACxB,OAAO,MAAM,KAAK,KAAK,UAAU;CACnC;;;;;;;;;;;;;;;;CAiBA,KAME,SACkE;EAClE,MAAM,mBAAmB;GAAE,OAAO;GAAM,GAAG;EAAQ;EAEnD,OAAO,KAAK,OAAO,CAAC,CAAC,MAAM,aACzBC,cAAAA,cAAc,kBAAkB,QAAQ,CAC1C;CACF;;;;;;;;;;;;;;;;CAiBA,QAAQ,UAA2B,CAAC,GAAoB;EACtD,OAAO,KAAK,OAAO,CAAC,CAAC,QAAQ,aAAaA,cAAAA,cAAc,SAAS,QAAQ,CAAC;CAC5E;;CAGA,OAAO,OAAiC;EACtC,sBAAA,cAAc,YAAY;GACxB,KAAK,UAAU,SAAS,aAAa;IACnC,SAAS,KAAK;GAChB,CAAC;EACH,CAAC;CACH;;CAGA,wBAA0C;EACxC,MAAM,kBAAkB,KAAK,OAAO,CAAC,CAAC,QAAQ,MAAM,EAAE,MAAM,QAAQ;EAEpE,OAAOC,sBAAAA,cAAc,YACnB,QAAQ,IACN,gBAAgB,KAAK,aAAa,SAAS,SAAS,CAAC,CAAC,MAAMC,cAAAA,IAAI,CAAC,CACnE,CACF;CACF;AACF;AAEA,SAAS,SAAS,UAAwC;CACxD,OAAO,SAAS,QAAQ,OAAO;AACjC"}

package/build/modern/mutationCache.d.cts

@@ -1,2 +1,2 @@
-import { Gn as MutationCacheConfig, Kn as MutationCacheNotifyEvent, Wn as MutationCache } from "./hydration-DwR10Hi-.cjs";
+import { Gn as MutationCacheConfig, Kn as MutationCacheNotifyEvent, Wn as MutationCache } from "./hydration-Br9VIGXa.cjs";
 export { MutationCache, MutationCacheConfig, MutationCacheNotifyEvent };

package/build/modern/mutationCache.d.ts

@@ -1,2 +1,2 @@
-import { Gn as MutationCacheConfig, Kn as MutationCacheNotifyEvent, Wn as MutationCache } from "./hydration-Cq7QYAzB.js";
+import { Gn as MutationCacheConfig, Kn as MutationCacheNotifyEvent, Wn as MutationCache } from "./hydration-B9t5w6NC.js";
 export { MutationCache, MutationCacheConfig, MutationCacheNotifyEvent };

package/build/modern/mutationCache.js.map

@@ -1 +1 @@
-{"version":3,"file":"mutationCache.js","names":["#mutations","#scopes","#mutationId"],"sources":["../../src/mutationCache.ts"],"sourcesContent":["import { notifyManager } from './notifyManager'\nimport { Mutation } from './mutation'\nimport { matchMutation, noop } from './utils'\nimport { Subscribable } from './subscribable'\nimport type { MutationObserver } from './mutationObserver'\nimport type {\n  DefaultError,\n  MutationFunctionContext,\n  MutationOptions,\n  NotifyEvent,\n} from './types'\nimport type { QueryClient } from './queryClient'\nimport type { Action, MutationState } from './mutation'\nimport type { MutationFilters } from './utils'\n\n// TYPES\n\n/**\n * Global callbacks that fire for every mutation handled by a `MutationCache`, regardless of which\n * component or observer triggered it. They differ from the `defaultOptions` provided to a\n * `QueryClient` in two ways: `defaultOptions` can be overridden by each mutation, while these\n * callbacks are always called, and `onMutate` here does not allow returning a result.\n *\n * If a callback returns a promise, it will be awaited before the mutation continues.\n */\nexport interface MutationCacheConfig {\n  /** Called when any mutation in the cache encounters an error. */\n  onError?: (\n    error: DefaultError,\n    variables: unknown,\n    onMutateResult: unknown,\n    mutation: Mutation<unknown, unknown, unknown>,\n    context: MutationFunctionContext,\n  ) => Promise<unknown> | unknown\n  /** Called when any mutation in the cache is successful. */\n  onSuccess?: (\n    data: unknown,\n    variables: unknown,\n    onMutateResult: unknown,\n    mutation: Mutation<unknown, unknown, unknown>,\n    context: MutationFunctionContext,\n  ) => Promise<unknown> | unknown\n  /** Called before any mutation in the cache executes. */\n  onMutate?: (\n    variables: unknown,\n    mutation: Mutation<unknown, unknown, unknown>,\n    context: MutationFunctionContext,\n  ) => Promise<unknown> | unknown\n  /** Called when any mutation in the cache is settled, either successfully or with an error. */\n  onSettled?: (\n    data: unknown | undefined,\n    error: DefaultError | null,\n    variables: unknown,\n    onMutateResult: unknown,\n    mutation: Mutation<unknown, unknown, unknown>,\n    context: MutationFunctionContext,\n  ) => Promise<unknown> | unknown\n}\n\ninterface NotifyEventMutationAdded extends NotifyEvent {\n  type: 'added'\n  mutation: Mutation<any, any, any, any>\n}\ninterface NotifyEventMutationRemoved extends NotifyEvent {\n  type: 'removed'\n  mutation: Mutation<any, any, any, any>\n}\n\ninterface NotifyEventMutationObserverAdded extends NotifyEvent {\n  type: 'observerAdded'\n  mutation: Mutation<any, any, any, any>\n  observer: MutationObserver<any, any, any>\n}\n\ninterface NotifyEventMutationObserverRemoved extends NotifyEvent {\n  type: 'observerRemoved'\n  mutation: Mutation<any, any, any, any>\n  observer: MutationObserver<any, any, any>\n}\n\ninterface NotifyEventMutationObserverOptionsUpdated extends NotifyEvent {\n  type: 'observerOptionsUpdated'\n  mutation?: Mutation<any, any, any, any>\n  observer: MutationObserver<any, any, any, any>\n}\n\ninterface NotifyEventMutationUpdated extends NotifyEvent {\n  type: 'updated'\n  mutation: Mutation<any, any, any, any>\n  action: Action<any, any, any, any>\n}\n\n/**\n * The event passed to a `MutationCache` subscriber. Fired whenever a mutation is added or removed\n * from the cache, its state is updated, or one of its observers is added, removed, or has its\n * options updated.\n */\nexport type MutationCacheNotifyEvent =\n  | NotifyEventMutationAdded\n  | NotifyEventMutationRemoved\n  | NotifyEventMutationObserverAdded\n  | NotifyEventMutationObserverRemoved\n  | NotifyEventMutationObserverOptionsUpdated\n  | NotifyEventMutationUpdated\n\ntype MutationCacheListener = (event: MutationCacheNotifyEvent) => void\n\n// CLASS\n\n/**\n * The `MutationCache` is the storage for mutations.\n *\n * Normally, you will not interact with the `MutationCache` directly and instead use a\n * `QueryClient`. You can subscribe to it (inherited from `Subscribable`) to be informed of\n * safe/known updates to the cache, such as mutations being added, removed, or updated.\n *\n * @example\n * ```ts\n * const unsubscribe = mutationCache.subscribe((event) => {\n *   console.log(event.type, event.mutation)\n * })\n * ```\n */\nexport class MutationCache extends Subscribable<MutationCacheListener> {\n  #mutations: Set<Mutation<any, any, any, any>>\n  #scopes: Map<string, Array<Mutation<any, any, any, any>>>\n  #mutationId: number\n\n  constructor(public config: MutationCacheConfig = {}) {\n    super()\n    this.#mutations = new Set()\n    this.#scopes = new Map()\n    this.#mutationId = 0\n  }\n\n  /** @internal */\n  build<TData, TError, TVariables, TOnMutateResult>(\n    client: QueryClient,\n    options: MutationOptions<TData, TError, TVariables, TOnMutateResult>,\n    state?: MutationState<TData, TError, TVariables, TOnMutateResult>,\n  ): Mutation<TData, TError, TVariables, TOnMutateResult> {\n    const mutation = new Mutation({\n      client,\n      mutationCache: this,\n      mutationId: ++this.#mutationId,\n      options: client.defaultMutationOptions(options),\n      state,\n    })\n\n    this.add(mutation)\n\n    return mutation\n  }\n\n  /** @internal */\n  add(mutation: Mutation<any, any, any, any>): void {\n    this.#mutations.add(mutation)\n    const scope = scopeFor(mutation)\n    if (typeof scope === 'string') {\n      const scopedMutations = this.#scopes.get(scope)\n      if (scopedMutations) {\n        scopedMutations.push(mutation)\n      } else {\n        this.#scopes.set(scope, [mutation])\n      }\n    }\n    this.notify({ type: 'added', mutation })\n  }\n\n  /** @internal */\n  remove(mutation: Mutation<any, any, any, any>): void {\n    if (this.#mutations.delete(mutation)) {\n      const scope = scopeFor(mutation)\n      if (typeof scope === 'string') {\n        const scopedMutations = this.#scopes.get(scope)\n        if (scopedMutations) {\n          if (scopedMutations.length > 1) {\n            const index = scopedMutations.indexOf(mutation)\n            if (index !== -1) {\n              scopedMutations.splice(index, 1)\n            }\n          } else if (scopedMutations[0] === mutation) {\n            this.#scopes.delete(scope)\n          }\n        }\n      }\n    }\n\n    // Currently we notify the removal even if the mutation was already removed.\n    // Consider making this an error or not notifying of the removal depending on the desired semantics.\n    this.notify({ type: 'removed', mutation })\n  }\n\n  /** @internal */\n  canRun(mutation: Mutation<any, any, any, any>): boolean {\n    const scope = scopeFor(mutation)\n    if (typeof scope === 'string') {\n      const mutationsWithSameScope = this.#scopes.get(scope)\n      const firstPendingMutation = mutationsWithSameScope?.find(\n        (m) => m.state.status === 'pending',\n      )\n      // we can run if there is no current pending mutation (start use-case)\n      // or if WE are the first pending mutation (continue use-case)\n      return !firstPendingMutation || firstPendingMutation === mutation\n    } else {\n      // For unscoped mutations there are never any pending mutations in front of the\n      // current mutation\n      return true\n    }\n  }\n\n  /** @internal */\n  runNext(mutation: Mutation<any, any, any, any>): Promise<unknown> {\n    const scope = scopeFor(mutation)\n    if (typeof scope === 'string') {\n      const foundMutation = this.#scopes\n        .get(scope)\n        ?.find((m) => m !== mutation && m.state.isPaused)\n\n      return foundMutation?.continue() ?? Promise.resolve()\n    } else {\n      return Promise.resolve()\n    }\n  }\n\n  /**\n   * Removes all mutations from the cache.\n   *\n   * @example\n   * ```ts\n   * const mutationCache = queryClient.getMutationCache()\n   *\n   * mutationCache.clear()\n   * ```\n   */\n  clear(): void {\n    notifyManager.batch(() => {\n      this.#mutations.forEach((mutation) => {\n        this.notify({ type: 'removed', mutation })\n      })\n      this.#mutations.clear()\n      this.#scopes.clear()\n    })\n  }\n\n  /**\n   * Returns all mutations within the cache.\n   *\n   * This is not typically needed for most applications, but can come in handy when needing more\n   * information about a mutation in rare scenarios.\n   *\n   * @example\n   * ```ts\n   * const mutationCache = queryClient.getMutationCache()\n   *\n   * const mutations = mutationCache.getAll()\n   * ```\n   */\n  getAll(): Array<Mutation> {\n    return Array.from(this.#mutations)\n  }\n\n  /**\n   * A slightly more advanced method that can be used to get an existing mutation instance from\n   * the cache. If the mutation does not exist, `undefined` is returned.\n   *\n   * This is not typically needed for most applications, but can come in handy when needing more\n   * information about a mutation in rare scenarios.\n   *\n   * @see {@link MutationCache#findAll}\n   * @example\n   * ```ts\n   * const mutationCache = queryClient.getMutationCache()\n   *\n   * const mutation = mutationCache.find({ mutationKey: ['addPost'] })\n   * ```\n   */\n  find<\n    TData = unknown,\n    TError = DefaultError,\n    TVariables = any,\n    TOnMutateResult = unknown,\n  >(\n    filters: MutationFilters,\n  ): Mutation<TData, TError, TVariables, TOnMutateResult> | undefined {\n    const defaultedFilters = { exact: true, ...filters }\n\n    return this.getAll().find((mutation) =>\n      matchMutation(defaultedFilters, mutation),\n    ) as Mutation<TData, TError, TVariables, TOnMutateResult> | undefined\n  }\n\n  /**\n   * An even more advanced method that can be used to get existing mutation instances from the\n   * cache that match the given filters. If no mutations match, an empty array is returned.\n   *\n   * This is not typically needed for most applications, but can come in handy when needing more\n   * information about mutations in rare scenarios.\n   *\n   * @see {@link MutationCache#find}\n   * @example\n   * ```ts\n   * const mutationCache = queryClient.getMutationCache()\n   *\n   * const mutations = mutationCache.findAll({ mutationKey: ['addPost'] })\n   * ```\n   */\n  findAll(filters: MutationFilters = {}): Array<Mutation> {\n    return this.getAll().filter((mutation) => matchMutation(filters, mutation))\n  }\n\n  /** @internal */\n  notify(event: MutationCacheNotifyEvent) {\n    notifyManager.batch(() => {\n      this.listeners.forEach((listener) => {\n        listener(event)\n      })\n    })\n  }\n\n  /** @internal */\n  resumePausedMutations(): Promise<unknown> {\n    const pausedMutations = this.getAll().filter((x) => x.state.isPaused)\n\n    return notifyManager.batch(() =>\n      Promise.all(\n        pausedMutations.map((mutation) => mutation.continue().catch(noop)),\n      ),\n    )\n  }\n}\n\nfunction scopeFor(mutation: Mutation<any, any, any, any>) {\n  return mutation.options.scope?.id\n}\n"],"mappings":"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"}
+{"version":3,"file":"mutationCache.js","names":[],"sources":["../../src/mutationCache.ts"],"sourcesContent":["import { notifyManager } from './notifyManager'\nimport { Mutation } from './mutation'\nimport { matchMutation, noop } from './utils'\nimport { Subscribable } from './subscribable'\nimport type { MutationObserver } from './mutationObserver'\nimport type {\n  DefaultError,\n  MutationFunctionContext,\n  MutationOptions,\n  NotifyEvent,\n} from './types'\nimport type { QueryClient } from './queryClient'\nimport type { Action, MutationState } from './mutation'\nimport type { MutationFilters } from './utils'\n\n// TYPES\n\n/**\n * Global callbacks that fire for every mutation handled by a `MutationCache`, regardless of which\n * component or observer triggered it. They differ from the `defaultOptions` provided to a\n * `QueryClient` in two ways: `defaultOptions` can be overridden by each mutation, while these\n * callbacks are always called, and `onMutate` here does not allow returning a result.\n *\n * If a callback returns a promise, it will be awaited before the mutation continues.\n */\nexport interface MutationCacheConfig {\n  /** Called when any mutation in the cache encounters an error. */\n  onError?: (\n    error: DefaultError,\n    variables: unknown,\n    onMutateResult: unknown,\n    mutation: Mutation<unknown, unknown, unknown>,\n    context: MutationFunctionContext,\n  ) => Promise<unknown> | unknown\n  /** Called when any mutation in the cache is successful. */\n  onSuccess?: (\n    data: unknown,\n    variables: unknown,\n    onMutateResult: unknown,\n    mutation: Mutation<unknown, unknown, unknown>,\n    context: MutationFunctionContext,\n  ) => Promise<unknown> | unknown\n  /** Called before any mutation in the cache executes. */\n  onMutate?: (\n    variables: unknown,\n    mutation: Mutation<unknown, unknown, unknown>,\n    context: MutationFunctionContext,\n  ) => Promise<unknown> | unknown\n  /** Called when any mutation in the cache is settled, either successfully or with an error. */\n  onSettled?: (\n    data: unknown | undefined,\n    error: DefaultError | null,\n    variables: unknown,\n    onMutateResult: unknown,\n    mutation: Mutation<unknown, unknown, unknown>,\n    context: MutationFunctionContext,\n  ) => Promise<unknown> | unknown\n}\n\ninterface NotifyEventMutationAdded extends NotifyEvent {\n  type: 'added'\n  mutation: Mutation<any, any, any, any>\n}\ninterface NotifyEventMutationRemoved extends NotifyEvent {\n  type: 'removed'\n  mutation: Mutation<any, any, any, any>\n}\n\ninterface NotifyEventMutationObserverAdded extends NotifyEvent {\n  type: 'observerAdded'\n  mutation: Mutation<any, any, any, any>\n  observer: MutationObserver<any, any, any>\n}\n\ninterface NotifyEventMutationObserverRemoved extends NotifyEvent {\n  type: 'observerRemoved'\n  mutation: Mutation<any, any, any, any>\n  observer: MutationObserver<any, any, any>\n}\n\ninterface NotifyEventMutationObserverOptionsUpdated extends NotifyEvent {\n  type: 'observerOptionsUpdated'\n  mutation?: Mutation<any, any, any, any>\n  observer: MutationObserver<any, any, any, any>\n}\n\ninterface NotifyEventMutationUpdated extends NotifyEvent {\n  type: 'updated'\n  mutation: Mutation<any, any, any, any>\n  action: Action<any, any, any, any>\n}\n\n/**\n * The event passed to a `MutationCache` subscriber. Fired whenever a mutation is added or removed\n * from the cache, its state is updated, or one of its observers is added, removed, or has its\n * options updated.\n */\nexport type MutationCacheNotifyEvent =\n  | NotifyEventMutationAdded\n  | NotifyEventMutationRemoved\n  | NotifyEventMutationObserverAdded\n  | NotifyEventMutationObserverRemoved\n  | NotifyEventMutationObserverOptionsUpdated\n  | NotifyEventMutationUpdated\n\ntype MutationCacheListener = (event: MutationCacheNotifyEvent) => void\n\n// CLASS\n\n/**\n * The `MutationCache` is the storage for mutations.\n *\n * Normally, you will not interact with the `MutationCache` directly and instead use a\n * `QueryClient`. You can subscribe to it (inherited from `Subscribable`) to be informed of\n * safe/known updates to the cache, such as mutations being added, removed, or updated.\n *\n * @example\n * ```ts\n * const unsubscribe = mutationCache.subscribe((event) => {\n *   console.log(event.type, event.mutation)\n * })\n * ```\n */\nexport class MutationCache extends Subscribable<MutationCacheListener> {\n  #mutations: Set<Mutation<any, any, any, any>>\n  #scopes: Map<string, Array<Mutation<any, any, any, any>>>\n  #mutationId: number\n\n  constructor(public config: MutationCacheConfig = {}) {\n    super()\n    this.#mutations = new Set()\n    this.#scopes = new Map()\n    this.#mutationId = 0\n  }\n\n  /** @internal */\n  build<TData, TError, TVariables, TOnMutateResult>(\n    client: QueryClient,\n    options: MutationOptions<TData, TError, TVariables, TOnMutateResult>,\n    state?: MutationState<TData, TError, TVariables, TOnMutateResult>,\n  ): Mutation<TData, TError, TVariables, TOnMutateResult> {\n    const mutation = new Mutation({\n      client,\n      mutationCache: this,\n      mutationId: ++this.#mutationId,\n      options: client.defaultMutationOptions(options),\n      state,\n    })\n\n    this.add(mutation)\n\n    return mutation\n  }\n\n  /** @internal */\n  add(mutation: Mutation<any, any, any, any>): void {\n    this.#mutations.add(mutation)\n    const scope = scopeFor(mutation)\n    if (typeof scope === 'string') {\n      const scopedMutations = this.#scopes.get(scope)\n      if (scopedMutations) {\n        scopedMutations.push(mutation)\n      } else {\n        this.#scopes.set(scope, [mutation])\n      }\n    }\n    this.notify({ type: 'added', mutation })\n  }\n\n  /** @internal */\n  remove(mutation: Mutation<any, any, any, any>): void {\n    if (this.#mutations.delete(mutation)) {\n      const scope = scopeFor(mutation)\n      if (typeof scope === 'string') {\n        const scopedMutations = this.#scopes.get(scope)\n        if (scopedMutations) {\n          if (scopedMutations.length > 1) {\n            const index = scopedMutations.indexOf(mutation)\n            if (index !== -1) {\n              scopedMutations.splice(index, 1)\n            }\n          } else if (scopedMutations[0] === mutation) {\n            this.#scopes.delete(scope)\n          }\n        }\n      }\n    }\n\n    // Currently we notify the removal even if the mutation was already removed.\n    // Consider making this an error or not notifying of the removal depending on the desired semantics.\n    this.notify({ type: 'removed', mutation })\n  }\n\n  /** @internal */\n  canRun(mutation: Mutation<any, any, any, any>): boolean {\n    const scope = scopeFor(mutation)\n    if (typeof scope === 'string') {\n      const mutationsWithSameScope = this.#scopes.get(scope)\n      const firstPendingMutation = mutationsWithSameScope?.find(\n        (m) => m.state.status === 'pending',\n      )\n      // we can run if there is no current pending mutation (start use-case)\n      // or if WE are the first pending mutation (continue use-case)\n      return !firstPendingMutation || firstPendingMutation === mutation\n    } else {\n      // For unscoped mutations there are never any pending mutations in front of the\n      // current mutation\n      return true\n    }\n  }\n\n  /** @internal */\n  runNext(mutation: Mutation<any, any, any, any>): Promise<unknown> {\n    const scope = scopeFor(mutation)\n    if (typeof scope === 'string') {\n      const foundMutation = this.#scopes\n        .get(scope)\n        ?.find((m) => m !== mutation && m.state.isPaused)\n\n      return foundMutation?.continue() ?? Promise.resolve()\n    } else {\n      return Promise.resolve()\n    }\n  }\n\n  /**\n   * Removes all mutations from the cache.\n   *\n   * @example\n   * ```ts\n   * const mutationCache = queryClient.getMutationCache()\n   *\n   * mutationCache.clear()\n   * ```\n   */\n  clear(): void {\n    notifyManager.batch(() => {\n      this.#mutations.forEach((mutation) => {\n        this.notify({ type: 'removed', mutation })\n      })\n      this.#mutations.clear()\n      this.#scopes.clear()\n    })\n  }\n\n  /**\n   * Returns all mutations within the cache.\n   *\n   * This is not typically needed for most applications, but can come in handy when needing more\n   * information about a mutation in rare scenarios.\n   *\n   * @example\n   * ```ts\n   * const mutationCache = queryClient.getMutationCache()\n   *\n   * const mutations = mutationCache.getAll()\n   * ```\n   */\n  getAll(): Array<Mutation> {\n    return Array.from(this.#mutations)\n  }\n\n  /**\n   * A slightly more advanced method that can be used to get an existing mutation instance from\n   * the cache. If the mutation does not exist, `undefined` is returned.\n   *\n   * This is not typically needed for most applications, but can come in handy when needing more\n   * information about a mutation in rare scenarios.\n   *\n   * @see {@link MutationCache#findAll}\n   * @example\n   * ```ts\n   * const mutationCache = queryClient.getMutationCache()\n   *\n   * const mutation = mutationCache.find({ mutationKey: ['addPost'] })\n   * ```\n   */\n  find<\n    TData = unknown,\n    TError = DefaultError,\n    TVariables = any,\n    TOnMutateResult = unknown,\n  >(\n    filters: MutationFilters,\n  ): Mutation<TData, TError, TVariables, TOnMutateResult> | undefined {\n    const defaultedFilters = { exact: true, ...filters }\n\n    return this.getAll().find((mutation) =>\n      matchMutation(defaultedFilters, mutation),\n    ) as Mutation<TData, TError, TVariables, TOnMutateResult> | undefined\n  }\n\n  /**\n   * An even more advanced method that can be used to get existing mutation instances from the\n   * cache that match the given filters. If no mutations match, an empty array is returned.\n   *\n   * This is not typically needed for most applications, but can come in handy when needing more\n   * information about mutations in rare scenarios.\n   *\n   * @see {@link MutationCache#find}\n   * @example\n   * ```ts\n   * const mutationCache = queryClient.getMutationCache()\n   *\n   * const mutations = mutationCache.findAll({ mutationKey: ['addPost'] })\n   * ```\n   */\n  findAll(filters: MutationFilters = {}): Array<Mutation> {\n    return this.getAll().filter((mutation) => matchMutation(filters, mutation))\n  }\n\n  /** @internal */\n  notify(event: MutationCacheNotifyEvent) {\n    notifyManager.batch(() => {\n      this.listeners.forEach((listener) => {\n        listener(event)\n      })\n    })\n  }\n\n  /** @internal */\n  resumePausedMutations(): Promise<unknown> {\n    const pausedMutations = this.getAll().filter((x) => x.state.isPaused)\n\n    return notifyManager.batch(() =>\n      Promise.all(\n        pausedMutations.map((mutation) => mutation.continue().catch(noop)),\n      ),\n    )\n  }\n}\n\nfunction scopeFor(mutation: Mutation<any, any, any, any>) {\n  return mutation.options.scope?.id\n}\n"],"mappings":"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"}