@tanstack/query-core 5.102.7 → 5.103.0

package/build/modern/infiniteQueryObserver.cjs

@@ -2,6 +2,25 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_infiniteQueryBehavior = require("./infiniteQueryBehavior.cjs");
 const require_queryObserver = require("./queryObserver.cjs");
 //#region src/infiniteQueryObserver.ts
+/**
+* An `InfiniteQueryObserver` extends `QueryObserver` to observe and switch
+* between infinite queries. It augments the base `QueryObserverResult` with
+* infinite-query-specific fields and methods, such as `hasNextPage` and
+* `fetchNextPage`, and is the primitive that framework adapters (e.g.
+* `useInfiniteQuery`) build their hooks on top of.
+*
+* @example
+* ```ts
+* const observer = new InfiniteQueryObserver(queryClient, {
+*   queryKey: ['projects'],
+*   queryFn: ({ pageParam }) => fetchProjects(pageParam),
+*   initialPageParam: 0,
+*   getNextPageParam: (lastPage) => lastPage.nextCursor,
+* })
+*
+* const unsubscribe = observer.subscribe((result) => console.log(result))
+* ```
+*/
 var InfiniteQueryObserver = class extends require_queryObserver.QueryObserver {
 	constructor(client, options) {
 		super(client, options);
@@ -11,20 +30,68 @@ var InfiniteQueryObserver = class extends require_queryObserver.QueryObserver {
 		this.fetchNextPage = this.fetchNextPage.bind(this);
 		this.fetchPreviousPage = this.fetchPreviousPage.bind(this);
 	}
+	/**
+	* Updates the observer's options. Behaves the same as
+	* `QueryObserver.setOptions`, additionally marking the options as
+	* belonging to an infinite query before delegating to the base
+	* implementation.
+	*/
 	setOptions(options) {
 		options._type = "infinite";
 		super.setOptions(options);
 	}
+	/**
+	* The infinite-query counterpart of {@link QueryObserver#getOptimisticResult}, marking the
+	* options as an infinite query before delegating to it. Called by framework adapters (e.g.
+	* `useInfiniteQuery`) ahead of subscribing, to compute the current `InfiniteQueryObserverResult`
+	* synchronously.
+	*/
 	getOptimisticResult(options) {
 		options._type = "infinite";
 		return super.getOptimisticResult(options);
 	}
+	/**
+	* Fetches the next page of the infinite query and returns a promise that
+	* resolves with the resulting `InfiniteQueryObserverResult`. The page
+	* param used for the fetch is determined by `getNextPageParam`, which
+	* receives the current pages/page params and whose result also determines
+	* `hasNextPage`.
+	*
+	* @example
+	* ```ts
+	* const { hasNextPage } = observer.getCurrentResult()
+	*
+	* if (hasNextPage) {
+	*   await observer.fetchNextPage()
+	* }
+	* ```
+	*
+	* @see {@link InfiniteQueryObserver#fetchPreviousPage}
+	*/
 	fetchNextPage(options) {
 		return this.fetch({
 			...options,
 			meta: { fetchMore: { direction: "forward" } }
 		});
 	}
+	/**
+	* Fetches the previous page of the infinite query and returns a promise
+	* that resolves with the resulting `InfiniteQueryObserverResult`. The page
+	* param used for the fetch is determined by `getPreviousPageParam`, which
+	* receives the current pages/page params and whose result also determines
+	* `hasPreviousPage`.
+	*
+	* @example
+	* ```ts
+	* const { hasPreviousPage } = observer.getCurrentResult()
+	*
+	* if (hasPreviousPage) {
+	*   await observer.fetchPreviousPage()
+	* }
+	* ```
+	*
+	* @see {@link InfiniteQueryObserver#fetchNextPage}
+	*/
 	fetchPreviousPage(options) {
 		return this.fetch({
 			...options,

package/build/modern/infiniteQueryObserver.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"infiniteQueryObserver.cjs","names":["QueryObserver","hasNextPage","hasPreviousPage"],"sources":["../../src/infiniteQueryObserver.ts"],"sourcesContent":["import { QueryObserver } from './queryObserver'\nimport { hasNextPage, hasPreviousPage } from './infiniteQueryBehavior'\nimport type { Subscribable } from './subscribable'\nimport type {\n  DefaultError,\n  DefaultedInfiniteQueryObserverOptions,\n  FetchNextPageOptions,\n  FetchPreviousPageOptions,\n  InfiniteData,\n  InfiniteQueryObserverBaseResult,\n  InfiniteQueryObserverOptions,\n  InfiniteQueryObserverResult,\n  QueryKey,\n} from './types'\nimport type { QueryClient } from './queryClient'\nimport type { Query } from './query'\n\ntype InfiniteQueryObserverListener<TData, TError> = (\n  result: InfiniteQueryObserverResult<TData, TError>,\n) => void\n\nexport class InfiniteQueryObserver<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n> extends QueryObserver<\n  TQueryFnData,\n  TError,\n  TData,\n  InfiniteData<TQueryFnData, TPageParam>,\n  TQueryKey\n> {\n  // Type override\n  subscribe!: Subscribable<\n    InfiniteQueryObserverListener<TData, TError>\n  >['subscribe']\n\n  // Type override\n  getCurrentResult!: ReplaceReturnType<\n    QueryObserver<\n      TQueryFnData,\n      TError,\n      TData,\n      InfiniteData<TQueryFnData, TPageParam>,\n      TQueryKey\n    >['getCurrentResult'],\n    InfiniteQueryObserverResult<TData, TError>\n  >\n\n  // Type override\n  protected fetch!: ReplaceReturnType<\n    QueryObserver<\n      TQueryFnData,\n      TError,\n      TData,\n      InfiniteData<TQueryFnData, TPageParam>,\n      TQueryKey\n    >['fetch'],\n    Promise<InfiniteQueryObserverResult<TData, TError>>\n  >\n\n  constructor(\n    client: QueryClient,\n    options: InfiniteQueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ) {\n    super(client, options)\n  }\n\n  protected bindMethods(): void {\n    super.bindMethods()\n    this.fetchNextPage = this.fetchNextPage.bind(this)\n    this.fetchPreviousPage = this.fetchPreviousPage.bind(this)\n  }\n\n  setOptions(\n    options: InfiniteQueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): void {\n    options._type = 'infinite'\n    super.setOptions(options)\n  }\n\n  getOptimisticResult(\n    options: DefaultedInfiniteQueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): InfiniteQueryObserverResult<TData, TError> {\n    options._type = 'infinite'\n    return super.getOptimisticResult(options) as InfiniteQueryObserverResult<\n      TData,\n      TError\n    >\n  }\n\n  fetchNextPage(\n    options?: FetchNextPageOptions,\n  ): Promise<InfiniteQueryObserverResult<TData, TError>> {\n    return this.fetch({\n      ...options,\n      meta: {\n        fetchMore: { direction: 'forward' },\n      },\n    })\n  }\n\n  fetchPreviousPage(\n    options?: FetchPreviousPageOptions,\n  ): Promise<InfiniteQueryObserverResult<TData, TError>> {\n    return this.fetch({\n      ...options,\n      meta: {\n        fetchMore: { direction: 'backward' },\n      },\n    })\n  }\n\n  protected createResult(\n    query: Query<\n      TQueryFnData,\n      TError,\n      InfiniteData<TQueryFnData, TPageParam>,\n      TQueryKey\n    >,\n    options: InfiniteQueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): InfiniteQueryObserverResult<TData, TError> {\n    const { state } = query\n    const parentResult = super.createResult(query, options)\n\n    const { isFetching, isRefetching, isError, isRefetchError } = parentResult\n    const fetchDirection = state.fetchMeta?.fetchMore?.direction\n\n    const isFetchNextPageError = isError && fetchDirection === 'forward'\n    const isFetchingNextPage = isFetching && fetchDirection === 'forward'\n\n    const isFetchPreviousPageError = isError && fetchDirection === 'backward'\n    const isFetchingPreviousPage = isFetching && fetchDirection === 'backward'\n\n    const result: InfiniteQueryObserverBaseResult<TData, TError> = {\n      ...parentResult,\n      fetchNextPage: this.fetchNextPage,\n      fetchPreviousPage: this.fetchPreviousPage,\n      hasNextPage: hasNextPage(options, state.data),\n      hasPreviousPage: hasPreviousPage(options, state.data),\n      isFetchNextPageError,\n      isFetchingNextPage,\n      isFetchPreviousPageError,\n      isFetchingPreviousPage,\n      isRefetchError:\n        isRefetchError && !isFetchNextPageError && !isFetchPreviousPageError,\n      isRefetching:\n        isRefetching && !isFetchingNextPage && !isFetchingPreviousPage,\n    }\n\n    return result as InfiniteQueryObserverResult<TData, TError>\n  }\n}\n\ntype ReplaceReturnType<\n  TFunction extends (...args: Array<any>) => unknown,\n  TReturn,\n> = (...args: Parameters<TFunction>) => TReturn\n"],"mappings":";;;;AAqBA,IAAa,wBAAb,cAMUA,sBAAAA,cAMR;CA8BA,YACE,QACA,SAOA;EACA,MAAM,QAAQ,OAAO;CACvB;CAEA,cAA8B;EAC5B,MAAM,YAAY;EAClB,KAAK,gBAAgB,KAAK,cAAc,KAAK,IAAI;EACjD,KAAK,oBAAoB,KAAK,kBAAkB,KAAK,IAAI;CAC3D;CAEA,WACE,SAOM;EACN,QAAQ,QAAQ;EAChB,MAAM,WAAW,OAAO;CAC1B;CAEA,oBACE,SAO4C;EAC5C,QAAQ,QAAQ;EAChB,OAAO,MAAM,oBAAoB,OAAO;CAI1C;CAEA,cACE,SACqD;EACrD,OAAO,KAAK,MAAM;GAChB,GAAG;GACH,MAAM,EACJ,WAAW,EAAE,WAAW,UAAU,EACpC;EACF,CAAC;CACH;CAEA,kBACE,SACqD;EACrD,OAAO,KAAK,MAAM;GAChB,GAAG;GACH,MAAM,EACJ,WAAW,EAAE,WAAW,WAAW,EACrC;EACF,CAAC;CACH;CAEA,aACE,OAMA,SAO4C;EAC5C,MAAM,EAAE,UAAU;EAClB,MAAM,eAAe,MAAM,aAAa,OAAO,OAAO;EAEtD,MAAM,EAAE,YAAY,cAAc,SAAS,mBAAmB;EAC9D,MAAM,iBAAiB,MAAM,WAAW,WAAW;EAEnD,MAAM,uBAAuB,WAAW,mBAAmB;EAC3D,MAAM,qBAAqB,cAAc,mBAAmB;EAE5D,MAAM,2BAA2B,WAAW,mBAAmB;EAC/D,MAAM,yBAAyB,cAAc,mBAAmB;EAkBhE,OAAO;GAfL,GAAG;GACH,eAAe,KAAK;GACpB,mBAAmB,KAAK;GACxB,aAAaC,8BAAAA,YAAY,SAAS,MAAM,IAAI;GAC5C,iBAAiBC,8BAAAA,gBAAgB,SAAS,MAAM,IAAI;GACpD;GACA;GACA;GACA;GACA,gBACE,kBAAkB,CAAC,wBAAwB,CAAC;GAC9C,cACE,gBAAgB,CAAC,sBAAsB,CAAC;EAGhC;CACd;AACF"}
+{"version":3,"file":"infiniteQueryObserver.cjs","names":["QueryObserver","hasNextPage","hasPreviousPage"],"sources":["../../src/infiniteQueryObserver.ts"],"sourcesContent":["import { QueryObserver } from './queryObserver'\nimport { hasNextPage, hasPreviousPage } from './infiniteQueryBehavior'\nimport type { Subscribable } from './subscribable'\nimport type {\n  DefaultError,\n  DefaultedInfiniteQueryObserverOptions,\n  FetchNextPageOptions,\n  FetchPreviousPageOptions,\n  InfiniteData,\n  InfiniteQueryObserverBaseResult,\n  InfiniteQueryObserverOptions,\n  InfiniteQueryObserverResult,\n  QueryKey,\n} from './types'\nimport type { QueryClient } from './queryClient'\nimport type { Query } from './query'\n\ntype InfiniteQueryObserverListener<TData, TError> = (\n  result: InfiniteQueryObserverResult<TData, TError>,\n) => void\n\n/**\n * An `InfiniteQueryObserver` extends `QueryObserver` to observe and switch\n * between infinite queries. It augments the base `QueryObserverResult` with\n * infinite-query-specific fields and methods, such as `hasNextPage` and\n * `fetchNextPage`, and is the primitive that framework adapters (e.g.\n * `useInfiniteQuery`) build their hooks on top of.\n *\n * @example\n * ```ts\n * const observer = new InfiniteQueryObserver(queryClient, {\n *   queryKey: ['projects'],\n *   queryFn: ({ pageParam }) => fetchProjects(pageParam),\n *   initialPageParam: 0,\n *   getNextPageParam: (lastPage) => lastPage.nextCursor,\n * })\n *\n * const unsubscribe = observer.subscribe((result) => console.log(result))\n * ```\n */\nexport class InfiniteQueryObserver<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n> extends QueryObserver<\n  TQueryFnData,\n  TError,\n  TData,\n  InfiniteData<TQueryFnData, TPageParam>,\n  TQueryKey\n> {\n  // Type override\n  subscribe!: Subscribable<\n    InfiniteQueryObserverListener<TData, TError>\n  >['subscribe']\n\n  // Type override\n  getCurrentResult!: ReplaceReturnType<\n    QueryObserver<\n      TQueryFnData,\n      TError,\n      TData,\n      InfiniteData<TQueryFnData, TPageParam>,\n      TQueryKey\n    >['getCurrentResult'],\n    InfiniteQueryObserverResult<TData, TError>\n  >\n\n  // Type override\n  protected fetch!: ReplaceReturnType<\n    QueryObserver<\n      TQueryFnData,\n      TError,\n      TData,\n      InfiniteData<TQueryFnData, TPageParam>,\n      TQueryKey\n    >['fetch'],\n    Promise<InfiniteQueryObserverResult<TData, TError>>\n  >\n\n  constructor(\n    client: QueryClient,\n    options: InfiniteQueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ) {\n    super(client, options)\n  }\n\n  protected bindMethods(): void {\n    super.bindMethods()\n    this.fetchNextPage = this.fetchNextPage.bind(this)\n    this.fetchPreviousPage = this.fetchPreviousPage.bind(this)\n  }\n\n  /**\n   * Updates the observer's options. Behaves the same as\n   * `QueryObserver.setOptions`, additionally marking the options as\n   * belonging to an infinite query before delegating to the base\n   * implementation.\n   */\n  setOptions(\n    options: InfiniteQueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): void {\n    options._type = 'infinite'\n    super.setOptions(options)\n  }\n\n  /**\n   * The infinite-query counterpart of {@link QueryObserver#getOptimisticResult}, marking the\n   * options as an infinite query before delegating to it. Called by framework adapters (e.g.\n   * `useInfiniteQuery`) ahead of subscribing, to compute the current `InfiniteQueryObserverResult`\n   * synchronously.\n   */\n  getOptimisticResult(\n    options: DefaultedInfiniteQueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): InfiniteQueryObserverResult<TData, TError> {\n    options._type = 'infinite'\n    return super.getOptimisticResult(options) as InfiniteQueryObserverResult<\n      TData,\n      TError\n    >\n  }\n\n  /**\n   * Fetches the next page of the infinite query and returns a promise that\n   * resolves with the resulting `InfiniteQueryObserverResult`. The page\n   * param used for the fetch is determined by `getNextPageParam`, which\n   * receives the current pages/page params and whose result also determines\n   * `hasNextPage`.\n   *\n   * @example\n   * ```ts\n   * const { hasNextPage } = observer.getCurrentResult()\n   *\n   * if (hasNextPage) {\n   *   await observer.fetchNextPage()\n   * }\n   * ```\n   *\n   * @see {@link InfiniteQueryObserver#fetchPreviousPage}\n   */\n  fetchNextPage(\n    options?: FetchNextPageOptions,\n  ): Promise<InfiniteQueryObserverResult<TData, TError>> {\n    return this.fetch({\n      ...options,\n      meta: {\n        fetchMore: { direction: 'forward' },\n      },\n    })\n  }\n\n  /**\n   * Fetches the previous page of the infinite query and returns a promise\n   * that resolves with the resulting `InfiniteQueryObserverResult`. The page\n   * param used for the fetch is determined by `getPreviousPageParam`, which\n   * receives the current pages/page params and whose result also determines\n   * `hasPreviousPage`.\n   *\n   * @example\n   * ```ts\n   * const { hasPreviousPage } = observer.getCurrentResult()\n   *\n   * if (hasPreviousPage) {\n   *   await observer.fetchPreviousPage()\n   * }\n   * ```\n   *\n   * @see {@link InfiniteQueryObserver#fetchNextPage}\n   */\n  fetchPreviousPage(\n    options?: FetchPreviousPageOptions,\n  ): Promise<InfiniteQueryObserverResult<TData, TError>> {\n    return this.fetch({\n      ...options,\n      meta: {\n        fetchMore: { direction: 'backward' },\n      },\n    })\n  }\n\n  protected createResult(\n    query: Query<\n      TQueryFnData,\n      TError,\n      InfiniteData<TQueryFnData, TPageParam>,\n      TQueryKey\n    >,\n    options: InfiniteQueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): InfiniteQueryObserverResult<TData, TError> {\n    const { state } = query\n    const parentResult = super.createResult(query, options)\n\n    const { isFetching, isRefetching, isError, isRefetchError } = parentResult\n    const fetchDirection = state.fetchMeta?.fetchMore?.direction\n\n    const isFetchNextPageError = isError && fetchDirection === 'forward'\n    const isFetchingNextPage = isFetching && fetchDirection === 'forward'\n\n    const isFetchPreviousPageError = isError && fetchDirection === 'backward'\n    const isFetchingPreviousPage = isFetching && fetchDirection === 'backward'\n\n    const result: InfiniteQueryObserverBaseResult<TData, TError> = {\n      ...parentResult,\n      fetchNextPage: this.fetchNextPage,\n      fetchPreviousPage: this.fetchPreviousPage,\n      hasNextPage: hasNextPage(options, state.data),\n      hasPreviousPage: hasPreviousPage(options, state.data),\n      isFetchNextPageError,\n      isFetchingNextPage,\n      isFetchPreviousPageError,\n      isFetchingPreviousPage,\n      isRefetchError:\n        isRefetchError && !isFetchNextPageError && !isFetchPreviousPageError,\n      isRefetching:\n        isRefetching && !isFetchingNextPage && !isFetchingPreviousPage,\n    }\n\n    return result as InfiniteQueryObserverResult<TData, TError>\n  }\n}\n\ntype ReplaceReturnType<\n  TFunction extends (...args: Array<any>) => unknown,\n  TReturn,\n> = (...args: Parameters<TFunction>) => TReturn\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAwCA,IAAa,wBAAb,cAMUA,sBAAAA,cAMR;CA8BA,YACE,QACA,SAOA;EACA,MAAM,QAAQ,OAAO;CACvB;CAEA,cAA8B;EAC5B,MAAM,YAAY;EAClB,KAAK,gBAAgB,KAAK,cAAc,KAAK,IAAI;EACjD,KAAK,oBAAoB,KAAK,kBAAkB,KAAK,IAAI;CAC3D;;;;;;;CAQA,WACE,SAOM;EACN,QAAQ,QAAQ;EAChB,MAAM,WAAW,OAAO;CAC1B;;;;;;;CAQA,oBACE,SAO4C;EAC5C,QAAQ,QAAQ;EAChB,OAAO,MAAM,oBAAoB,OAAO;CAI1C;;;;;;;;;;;;;;;;;;;CAoBA,cACE,SACqD;EACrD,OAAO,KAAK,MAAM;GAChB,GAAG;GACH,MAAM,EACJ,WAAW,EAAE,WAAW,UAAU,EACpC;EACF,CAAC;CACH;;;;;;;;;;;;;;;;;;;CAoBA,kBACE,SACqD;EACrD,OAAO,KAAK,MAAM;GAChB,GAAG;GACH,MAAM,EACJ,WAAW,EAAE,WAAW,WAAW,EACrC;EACF,CAAC;CACH;CAEA,aACE,OAMA,SAO4C;EAC5C,MAAM,EAAE,UAAU;EAClB,MAAM,eAAe,MAAM,aAAa,OAAO,OAAO;EAEtD,MAAM,EAAE,YAAY,cAAc,SAAS,mBAAmB;EAC9D,MAAM,iBAAiB,MAAM,WAAW,WAAW;EAEnD,MAAM,uBAAuB,WAAW,mBAAmB;EAC3D,MAAM,qBAAqB,cAAc,mBAAmB;EAE5D,MAAM,2BAA2B,WAAW,mBAAmB;EAC/D,MAAM,yBAAyB,cAAc,mBAAmB;EAkBhE,OAAO;GAfL,GAAG;GACH,eAAe,KAAK;GACpB,mBAAmB,KAAK;GACxB,aAAaC,8BAAAA,YAAY,SAAS,MAAM,IAAI;GAC5C,iBAAiBC,8BAAAA,gBAAgB,SAAS,MAAM,IAAI;GACpD;GACA;GACA;GACA;GACA,gBACE,kBAAkB,CAAC,wBAAwB,CAAC;GAC9C,cACE,gBAAgB,CAAC,sBAAsB,CAAC;EAGhC;CACd;AACF"}

package/build/modern/infiniteQueryObserver.d.cts

@@ -1,16 +1,83 @@
 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-DWGr3cFC.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";
 //#region src/infiniteQueryObserver.d.ts
 type InfiniteQueryObserverListener<TData, TError> = (result: InfiniteQueryObserverResult<TData, TError>) => void;
+/**
+ * An `InfiniteQueryObserver` extends `QueryObserver` to observe and switch
+ * between infinite queries. It augments the base `QueryObserverResult` with
+ * infinite-query-specific fields and methods, such as `hasNextPage` and
+ * `fetchNextPage`, and is the primitive that framework adapters (e.g.
+ * `useInfiniteQuery`) build their hooks on top of.
+ *
+ * @example
+ * ```ts
+ * const observer = new InfiniteQueryObserver(queryClient, {
+ *   queryKey: ['projects'],
+ *   queryFn: ({ pageParam }) => fetchProjects(pageParam),
+ *   initialPageParam: 0,
+ *   getNextPageParam: (lastPage) => lastPage.nextCursor,
+ * })
+ *
+ * const unsubscribe = observer.subscribe((result) => console.log(result))
+ * ```
+ */
 declare class InfiniteQueryObserver<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends QueryObserver<TQueryFnData, TError, TData, InfiniteData<TQueryFnData, TPageParam>, TQueryKey> {
   subscribe: Subscribable<InfiniteQueryObserverListener<TData, TError>>['subscribe'];
   getCurrentResult: ReplaceReturnType<QueryObserver<TQueryFnData, TError, TData, InfiniteData<TQueryFnData, TPageParam>, TQueryKey>['getCurrentResult'], InfiniteQueryObserverResult<TData, TError>>;
   protected fetch: ReplaceReturnType<QueryObserver<TQueryFnData, TError, TData, InfiniteData<TQueryFnData, TPageParam>, TQueryKey>['fetch'], Promise<InfiniteQueryObserverResult<TData, TError>>>;
   constructor(client: QueryClient, options: InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>);
   protected bindMethods(): void;
+  /**
+   * Updates the observer's options. Behaves the same as
+   * `QueryObserver.setOptions`, additionally marking the options as
+   * belonging to an infinite query before delegating to the base
+   * implementation.
+   */
   setOptions(options: InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): void;
+  /**
+   * The infinite-query counterpart of {@link QueryObserver#getOptimisticResult}, marking the
+   * options as an infinite query before delegating to it. Called by framework adapters (e.g.
+   * `useInfiniteQuery`) ahead of subscribing, to compute the current `InfiniteQueryObserverResult`
+   * synchronously.
+   */
   getOptimisticResult(options: DefaultedInfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): InfiniteQueryObserverResult<TData, TError>;
+  /**
+   * Fetches the next page of the infinite query and returns a promise that
+   * resolves with the resulting `InfiniteQueryObserverResult`. The page
+   * param used for the fetch is determined by `getNextPageParam`, which
+   * receives the current pages/page params and whose result also determines
+   * `hasNextPage`.
+   *
+   * @example
+   * ```ts
+   * const { hasNextPage } = observer.getCurrentResult()
+   *
+   * if (hasNextPage) {
+   *   await observer.fetchNextPage()
+   * }
+   * ```
+   *
+   * @see {@link InfiniteQueryObserver#fetchPreviousPage}
+   */
   fetchNextPage(options?: FetchNextPageOptions): Promise<InfiniteQueryObserverResult<TData, TError>>;
+  /**
+   * Fetches the previous page of the infinite query and returns a promise
+   * that resolves with the resulting `InfiniteQueryObserverResult`. The page
+   * param used for the fetch is determined by `getPreviousPageParam`, which
+   * receives the current pages/page params and whose result also determines
+   * `hasPreviousPage`.
+   *
+   * @example
+   * ```ts
+   * const { hasPreviousPage } = observer.getCurrentResult()
+   *
+   * if (hasPreviousPage) {
+   *   await observer.fetchPreviousPage()
+   * }
+   * ```
+   *
+   * @see {@link InfiniteQueryObserver#fetchNextPage}
+   */
   fetchPreviousPage(options?: FetchPreviousPageOptions): Promise<InfiniteQueryObserverResult<TData, TError>>;
   protected createResult(query: Query<TQueryFnData, TError, InfiniteData<TQueryFnData, TPageParam>, TQueryKey>, options: InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): InfiniteQueryObserverResult<TData, TError>;
 }

package/build/modern/infiniteQueryObserver.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"infiniteQueryObserver.d.cts","names":[],"sources":["../../src/infiniteQueryObserver.ts"],"mappings":";;;KAiBK,8BAA8B,OAAO,WACxC,QAAQ,4BAA4B,OAAO;cAGhC,sBACX,wBACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,8BACQ,cACR,cACA,QACA,OACA,aAAa,cAAc,aAC3B;EAGA,WAAY,aACV,8BAA8B,OAAO;EAIvC,kBAAmB,kBACjB,cACE,cACA,QACA,OACA,aAAa,cAAc,aAC3B,gCAEF,4BAA4B,OAAO;YAI3B,OAAQ,kBAChB,cACE,cACA,QACA,OACA,aAAa,cAAc,aAC3B,qBAEF,QAAQ,4BAA4B,OAAO;EAI3C,YAAA,QAAQ,aACR,SAAS,6BACP,cACA,QACA,OACA,WACA;YAMM;EAMV,WACE,SAAS,6BACP,cACA,QACA,OACA,WACA;EAOJ,oBACE,SAAS,sCACP,cACA,QACA,OACA,WACA,cAED,4BAA4B,OAAO;EAQtC,cACE,UAAU,uBACT,QAAQ,4BAA4B,OAAO;EAS9C,kBACE,UAAU,2BACT,QAAQ,4BAA4B,OAAO;YASpC,aACR,OAAO,MACL,cACA,QACA,aAAa,cAAc,aAC3B,YAEF,SAAS,6BACP,cACA,QACA,OACA,WACA,cAED,4BAA4B,OAAO;;KAiCnC,kBACH,sBAAsB,MAAM,wBAC5B,eACM,MAAM,WAAW,eAAe"}
+{"version":3,"file":"infiniteQueryObserver.d.cts","names":[],"sources":["../../src/infiniteQueryObserver.ts"],"mappings":";;;KAiBK,8BAA8B,OAAO,WACxC,QAAQ,4BAA4B,OAAO;;;;;;;;;;;;;;;;;;;;cAsBhC,sBACX,wBACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,8BACQ,cACR,cACA,QACA,OACA,aAAa,cAAc,aAC3B;EAGA,WAAY,aACV,8BAA8B,OAAO;EAIvC,kBAAmB,kBACjB,cACE,cACA,QACA,OACA,aAAa,cAAc,aAC3B,gCAEF,4BAA4B,OAAO;YAI3B,OAAQ,kBAChB,cACE,cACA,QACA,OACA,aAAa,cAAc,aAC3B,qBAEF,QAAQ,4BAA4B,OAAO;EAI3C,YAAA,QAAQ,aACR,SAAS,6BACP,cACA,QACA,OACA,WACA;YAMM;;;;;;;EAYV,WACE,SAAS,6BACP,cACA,QACA,OACA,WACA;;;;;;;EAaJ,oBACE,SAAS,sCACP,cACA,QACA,OACA,WACA,cAED,4BAA4B,OAAO;;;;;;;;;;;;;;;;;;;EA0BtC,cACE,UAAU,uBACT,QAAQ,4BAA4B,OAAO;;;;;;;;;;;;;;;;;;;EA2B9C,kBACE,UAAU,2BACT,QAAQ,4BAA4B,OAAO;YASpC,aACR,OAAO,MACL,cACA,QACA,aAAa,cAAc,aAC3B,YAEF,SAAS,6BACP,cACA,QACA,OACA,WACA,cAED,4BAA4B,OAAO;;KAiCnC,kBACH,sBAAsB,MAAM,wBAC5B,eACM,MAAM,WAAW,eAAe"}

package/build/modern/infiniteQueryObserver.d.ts

@@ -1,16 +1,83 @@
 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-Bjs0MSgg.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";
 //#region src/infiniteQueryObserver.d.ts
 type InfiniteQueryObserverListener<TData, TError> = (result: InfiniteQueryObserverResult<TData, TError>) => void;
+/**
+ * An `InfiniteQueryObserver` extends `QueryObserver` to observe and switch
+ * between infinite queries. It augments the base `QueryObserverResult` with
+ * infinite-query-specific fields and methods, such as `hasNextPage` and
+ * `fetchNextPage`, and is the primitive that framework adapters (e.g.
+ * `useInfiniteQuery`) build their hooks on top of.
+ *
+ * @example
+ * ```ts
+ * const observer = new InfiniteQueryObserver(queryClient, {
+ *   queryKey: ['projects'],
+ *   queryFn: ({ pageParam }) => fetchProjects(pageParam),
+ *   initialPageParam: 0,
+ *   getNextPageParam: (lastPage) => lastPage.nextCursor,
+ * })
+ *
+ * const unsubscribe = observer.subscribe((result) => console.log(result))
+ * ```
+ */
 declare class InfiniteQueryObserver<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends QueryObserver<TQueryFnData, TError, TData, InfiniteData<TQueryFnData, TPageParam>, TQueryKey> {
   subscribe: Subscribable<InfiniteQueryObserverListener<TData, TError>>['subscribe'];
   getCurrentResult: ReplaceReturnType<QueryObserver<TQueryFnData, TError, TData, InfiniteData<TQueryFnData, TPageParam>, TQueryKey>['getCurrentResult'], InfiniteQueryObserverResult<TData, TError>>;
   protected fetch: ReplaceReturnType<QueryObserver<TQueryFnData, TError, TData, InfiniteData<TQueryFnData, TPageParam>, TQueryKey>['fetch'], Promise<InfiniteQueryObserverResult<TData, TError>>>;
   constructor(client: QueryClient, options: InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>);
   protected bindMethods(): void;
+  /**
+   * Updates the observer's options. Behaves the same as
+   * `QueryObserver.setOptions`, additionally marking the options as
+   * belonging to an infinite query before delegating to the base
+   * implementation.
+   */
   setOptions(options: InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): void;
+  /**
+   * The infinite-query counterpart of {@link QueryObserver#getOptimisticResult}, marking the
+   * options as an infinite query before delegating to it. Called by framework adapters (e.g.
+   * `useInfiniteQuery`) ahead of subscribing, to compute the current `InfiniteQueryObserverResult`
+   * synchronously.
+   */
   getOptimisticResult(options: DefaultedInfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): InfiniteQueryObserverResult<TData, TError>;
+  /**
+   * Fetches the next page of the infinite query and returns a promise that
+   * resolves with the resulting `InfiniteQueryObserverResult`. The page
+   * param used for the fetch is determined by `getNextPageParam`, which
+   * receives the current pages/page params and whose result also determines
+   * `hasNextPage`.
+   *
+   * @example
+   * ```ts
+   * const { hasNextPage } = observer.getCurrentResult()
+   *
+   * if (hasNextPage) {
+   *   await observer.fetchNextPage()
+   * }
+   * ```
+   *
+   * @see {@link InfiniteQueryObserver#fetchPreviousPage}
+   */
   fetchNextPage(options?: FetchNextPageOptions): Promise<InfiniteQueryObserverResult<TData, TError>>;
+  /**
+   * Fetches the previous page of the infinite query and returns a promise
+   * that resolves with the resulting `InfiniteQueryObserverResult`. The page
+   * param used for the fetch is determined by `getPreviousPageParam`, which
+   * receives the current pages/page params and whose result also determines
+   * `hasPreviousPage`.
+   *
+   * @example
+   * ```ts
+   * const { hasPreviousPage } = observer.getCurrentResult()
+   *
+   * if (hasPreviousPage) {
+   *   await observer.fetchPreviousPage()
+   * }
+   * ```
+   *
+   * @see {@link InfiniteQueryObserver#fetchNextPage}
+   */
   fetchPreviousPage(options?: FetchPreviousPageOptions): Promise<InfiniteQueryObserverResult<TData, TError>>;
   protected createResult(query: Query<TQueryFnData, TError, InfiniteData<TQueryFnData, TPageParam>, TQueryKey>, options: InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): InfiniteQueryObserverResult<TData, TError>;
 }

package/build/modern/infiniteQueryObserver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"infiniteQueryObserver.d.ts","names":[],"sources":["../../src/infiniteQueryObserver.ts"],"mappings":";;;KAiBK,8BAA8B,OAAO,WACxC,QAAQ,4BAA4B,OAAO;cAGhC,sBACX,wBACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,8BACQ,cACR,cACA,QACA,OACA,aAAa,cAAc,aAC3B;EAGA,WAAY,aACV,8BAA8B,OAAO;EAIvC,kBAAmB,kBACjB,cACE,cACA,QACA,OACA,aAAa,cAAc,aAC3B,gCAEF,4BAA4B,OAAO;YAI3B,OAAQ,kBAChB,cACE,cACA,QACA,OACA,aAAa,cAAc,aAC3B,qBAEF,QAAQ,4BAA4B,OAAO;EAI3C,YAAA,QAAQ,aACR,SAAS,6BACP,cACA,QACA,OACA,WACA;YAMM;EAMV,WACE,SAAS,6BACP,cACA,QACA,OACA,WACA;EAOJ,oBACE,SAAS,sCACP,cACA,QACA,OACA,WACA,cAED,4BAA4B,OAAO;EAQtC,cACE,UAAU,uBACT,QAAQ,4BAA4B,OAAO;EAS9C,kBACE,UAAU,2BACT,QAAQ,4BAA4B,OAAO;YASpC,aACR,OAAO,MACL,cACA,QACA,aAAa,cAAc,aAC3B,YAEF,SAAS,6BACP,cACA,QACA,OACA,WACA,cAED,4BAA4B,OAAO;;KAiCnC,kBACH,sBAAsB,MAAM,wBAC5B,eACM,MAAM,WAAW,eAAe"}
+{"version":3,"file":"infiniteQueryObserver.d.ts","names":[],"sources":["../../src/infiniteQueryObserver.ts"],"mappings":";;;KAiBK,8BAA8B,OAAO,WACxC,QAAQ,4BAA4B,OAAO;;;;;;;;;;;;;;;;;;;;cAsBhC,sBACX,wBACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,8BACQ,cACR,cACA,QACA,OACA,aAAa,cAAc,aAC3B;EAGA,WAAY,aACV,8BAA8B,OAAO;EAIvC,kBAAmB,kBACjB,cACE,cACA,QACA,OACA,aAAa,cAAc,aAC3B,gCAEF,4BAA4B,OAAO;YAI3B,OAAQ,kBAChB,cACE,cACA,QACA,OACA,aAAa,cAAc,aAC3B,qBAEF,QAAQ,4BAA4B,OAAO;EAI3C,YAAA,QAAQ,aACR,SAAS,6BACP,cACA,QACA,OACA,WACA;YAMM;;;;;;;EAYV,WACE,SAAS,6BACP,cACA,QACA,OACA,WACA;;;;;;;EAaJ,oBACE,SAAS,sCACP,cACA,QACA,OACA,WACA,cAED,4BAA4B,OAAO;;;;;;;;;;;;;;;;;;;EA0BtC,cACE,UAAU,uBACT,QAAQ,4BAA4B,OAAO;;;;;;;;;;;;;;;;;;;EA2B9C,kBACE,UAAU,2BACT,QAAQ,4BAA4B,OAAO;YASpC,aACR,OAAO,MACL,cACA,QACA,aAAa,cAAc,aAC3B,YAEF,SAAS,6BACP,cACA,QACA,OACA,WACA,cAED,4BAA4B,OAAO;;KAiCnC,kBACH,sBAAsB,MAAM,wBAC5B,eACM,MAAM,WAAW,eAAe"}

package/build/modern/infiniteQueryObserver.js

@@ -1,6 +1,25 @@
 import { hasNextPage, hasPreviousPage } from "./infiniteQueryBehavior.js";
 import { QueryObserver } from "./queryObserver.js";
 //#region src/infiniteQueryObserver.ts
+/**
+* An `InfiniteQueryObserver` extends `QueryObserver` to observe and switch
+* between infinite queries. It augments the base `QueryObserverResult` with
+* infinite-query-specific fields and methods, such as `hasNextPage` and
+* `fetchNextPage`, and is the primitive that framework adapters (e.g.
+* `useInfiniteQuery`) build their hooks on top of.
+*
+* @example
+* ```ts
+* const observer = new InfiniteQueryObserver(queryClient, {
+*   queryKey: ['projects'],
+*   queryFn: ({ pageParam }) => fetchProjects(pageParam),
+*   initialPageParam: 0,
+*   getNextPageParam: (lastPage) => lastPage.nextCursor,
+* })
+*
+* const unsubscribe = observer.subscribe((result) => console.log(result))
+* ```
+*/
 var InfiniteQueryObserver = class extends QueryObserver {
 	constructor(client, options) {
 		super(client, options);
@@ -10,20 +29,68 @@ var InfiniteQueryObserver = class extends QueryObserver {
 		this.fetchNextPage = this.fetchNextPage.bind(this);
 		this.fetchPreviousPage = this.fetchPreviousPage.bind(this);
 	}
+	/**
+	* Updates the observer's options. Behaves the same as
+	* `QueryObserver.setOptions`, additionally marking the options as
+	* belonging to an infinite query before delegating to the base
+	* implementation.
+	*/
 	setOptions(options) {
 		options._type = "infinite";
 		super.setOptions(options);
 	}
+	/**
+	* The infinite-query counterpart of {@link QueryObserver#getOptimisticResult}, marking the
+	* options as an infinite query before delegating to it. Called by framework adapters (e.g.
+	* `useInfiniteQuery`) ahead of subscribing, to compute the current `InfiniteQueryObserverResult`
+	* synchronously.
+	*/
 	getOptimisticResult(options) {
 		options._type = "infinite";
 		return super.getOptimisticResult(options);
 	}
+	/**
+	* Fetches the next page of the infinite query and returns a promise that
+	* resolves with the resulting `InfiniteQueryObserverResult`. The page
+	* param used for the fetch is determined by `getNextPageParam`, which
+	* receives the current pages/page params and whose result also determines
+	* `hasNextPage`.
+	*
+	* @example
+	* ```ts
+	* const { hasNextPage } = observer.getCurrentResult()
+	*
+	* if (hasNextPage) {
+	*   await observer.fetchNextPage()
+	* }
+	* ```
+	*
+	* @see {@link InfiniteQueryObserver#fetchPreviousPage}
+	*/
 	fetchNextPage(options) {
 		return this.fetch({
 			...options,
 			meta: { fetchMore: { direction: "forward" } }
 		});
 	}
+	/**
+	* Fetches the previous page of the infinite query and returns a promise
+	* that resolves with the resulting `InfiniteQueryObserverResult`. The page
+	* param used for the fetch is determined by `getPreviousPageParam`, which
+	* receives the current pages/page params and whose result also determines
+	* `hasPreviousPage`.
+	*
+	* @example
+	* ```ts
+	* const { hasPreviousPage } = observer.getCurrentResult()
+	*
+	* if (hasPreviousPage) {
+	*   await observer.fetchPreviousPage()
+	* }
+	* ```
+	*
+	* @see {@link InfiniteQueryObserver#fetchNextPage}
+	*/
 	fetchPreviousPage(options) {
 		return this.fetch({
 			...options,

package/build/modern/infiniteQueryObserver.js.map

@@ -1 +1 @@
-{"version":3,"file":"infiniteQueryObserver.js","names":[],"sources":["../../src/infiniteQueryObserver.ts"],"sourcesContent":["import { QueryObserver } from './queryObserver'\nimport { hasNextPage, hasPreviousPage } from './infiniteQueryBehavior'\nimport type { Subscribable } from './subscribable'\nimport type {\n  DefaultError,\n  DefaultedInfiniteQueryObserverOptions,\n  FetchNextPageOptions,\n  FetchPreviousPageOptions,\n  InfiniteData,\n  InfiniteQueryObserverBaseResult,\n  InfiniteQueryObserverOptions,\n  InfiniteQueryObserverResult,\n  QueryKey,\n} from './types'\nimport type { QueryClient } from './queryClient'\nimport type { Query } from './query'\n\ntype InfiniteQueryObserverListener<TData, TError> = (\n  result: InfiniteQueryObserverResult<TData, TError>,\n) => void\n\nexport class InfiniteQueryObserver<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n> extends QueryObserver<\n  TQueryFnData,\n  TError,\n  TData,\n  InfiniteData<TQueryFnData, TPageParam>,\n  TQueryKey\n> {\n  // Type override\n  subscribe!: Subscribable<\n    InfiniteQueryObserverListener<TData, TError>\n  >['subscribe']\n\n  // Type override\n  getCurrentResult!: ReplaceReturnType<\n    QueryObserver<\n      TQueryFnData,\n      TError,\n      TData,\n      InfiniteData<TQueryFnData, TPageParam>,\n      TQueryKey\n    >['getCurrentResult'],\n    InfiniteQueryObserverResult<TData, TError>\n  >\n\n  // Type override\n  protected fetch!: ReplaceReturnType<\n    QueryObserver<\n      TQueryFnData,\n      TError,\n      TData,\n      InfiniteData<TQueryFnData, TPageParam>,\n      TQueryKey\n    >['fetch'],\n    Promise<InfiniteQueryObserverResult<TData, TError>>\n  >\n\n  constructor(\n    client: QueryClient,\n    options: InfiniteQueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ) {\n    super(client, options)\n  }\n\n  protected bindMethods(): void {\n    super.bindMethods()\n    this.fetchNextPage = this.fetchNextPage.bind(this)\n    this.fetchPreviousPage = this.fetchPreviousPage.bind(this)\n  }\n\n  setOptions(\n    options: InfiniteQueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): void {\n    options._type = 'infinite'\n    super.setOptions(options)\n  }\n\n  getOptimisticResult(\n    options: DefaultedInfiniteQueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): InfiniteQueryObserverResult<TData, TError> {\n    options._type = 'infinite'\n    return super.getOptimisticResult(options) as InfiniteQueryObserverResult<\n      TData,\n      TError\n    >\n  }\n\n  fetchNextPage(\n    options?: FetchNextPageOptions,\n  ): Promise<InfiniteQueryObserverResult<TData, TError>> {\n    return this.fetch({\n      ...options,\n      meta: {\n        fetchMore: { direction: 'forward' },\n      },\n    })\n  }\n\n  fetchPreviousPage(\n    options?: FetchPreviousPageOptions,\n  ): Promise<InfiniteQueryObserverResult<TData, TError>> {\n    return this.fetch({\n      ...options,\n      meta: {\n        fetchMore: { direction: 'backward' },\n      },\n    })\n  }\n\n  protected createResult(\n    query: Query<\n      TQueryFnData,\n      TError,\n      InfiniteData<TQueryFnData, TPageParam>,\n      TQueryKey\n    >,\n    options: InfiniteQueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): InfiniteQueryObserverResult<TData, TError> {\n    const { state } = query\n    const parentResult = super.createResult(query, options)\n\n    const { isFetching, isRefetching, isError, isRefetchError } = parentResult\n    const fetchDirection = state.fetchMeta?.fetchMore?.direction\n\n    const isFetchNextPageError = isError && fetchDirection === 'forward'\n    const isFetchingNextPage = isFetching && fetchDirection === 'forward'\n\n    const isFetchPreviousPageError = isError && fetchDirection === 'backward'\n    const isFetchingPreviousPage = isFetching && fetchDirection === 'backward'\n\n    const result: InfiniteQueryObserverBaseResult<TData, TError> = {\n      ...parentResult,\n      fetchNextPage: this.fetchNextPage,\n      fetchPreviousPage: this.fetchPreviousPage,\n      hasNextPage: hasNextPage(options, state.data),\n      hasPreviousPage: hasPreviousPage(options, state.data),\n      isFetchNextPageError,\n      isFetchingNextPage,\n      isFetchPreviousPageError,\n      isFetchingPreviousPage,\n      isRefetchError:\n        isRefetchError && !isFetchNextPageError && !isFetchPreviousPageError,\n      isRefetching:\n        isRefetching && !isFetchingNextPage && !isFetchingPreviousPage,\n    }\n\n    return result as InfiniteQueryObserverResult<TData, TError>\n  }\n}\n\ntype ReplaceReturnType<\n  TFunction extends (...args: Array<any>) => unknown,\n  TReturn,\n> = (...args: Parameters<TFunction>) => TReturn\n"],"mappings":";;;AAqBA,IAAa,wBAAb,cAMU,cAMR;CA8BA,YACE,QACA,SAOA;EACA,MAAM,QAAQ,OAAO;CACvB;CAEA,cAA8B;EAC5B,MAAM,YAAY;EAClB,KAAK,gBAAgB,KAAK,cAAc,KAAK,IAAI;EACjD,KAAK,oBAAoB,KAAK,kBAAkB,KAAK,IAAI;CAC3D;CAEA,WACE,SAOM;EACN,QAAQ,QAAQ;EAChB,MAAM,WAAW,OAAO;CAC1B;CAEA,oBACE,SAO4C;EAC5C,QAAQ,QAAQ;EAChB,OAAO,MAAM,oBAAoB,OAAO;CAI1C;CAEA,cACE,SACqD;EACrD,OAAO,KAAK,MAAM;GAChB,GAAG;GACH,MAAM,EACJ,WAAW,EAAE,WAAW,UAAU,EACpC;EACF,CAAC;CACH;CAEA,kBACE,SACqD;EACrD,OAAO,KAAK,MAAM;GAChB,GAAG;GACH,MAAM,EACJ,WAAW,EAAE,WAAW,WAAW,EACrC;EACF,CAAC;CACH;CAEA,aACE,OAMA,SAO4C;EAC5C,MAAM,EAAE,UAAU;EAClB,MAAM,eAAe,MAAM,aAAa,OAAO,OAAO;EAEtD,MAAM,EAAE,YAAY,cAAc,SAAS,mBAAmB;EAC9D,MAAM,iBAAiB,MAAM,WAAW,WAAW;EAEnD,MAAM,uBAAuB,WAAW,mBAAmB;EAC3D,MAAM,qBAAqB,cAAc,mBAAmB;EAE5D,MAAM,2BAA2B,WAAW,mBAAmB;EAC/D,MAAM,yBAAyB,cAAc,mBAAmB;EAkBhE,OAAO;GAfL,GAAG;GACH,eAAe,KAAK;GACpB,mBAAmB,KAAK;GACxB,aAAa,YAAY,SAAS,MAAM,IAAI;GAC5C,iBAAiB,gBAAgB,SAAS,MAAM,IAAI;GACpD;GACA;GACA;GACA;GACA,gBACE,kBAAkB,CAAC,wBAAwB,CAAC;GAC9C,cACE,gBAAgB,CAAC,sBAAsB,CAAC;EAGhC;CACd;AACF"}
+{"version":3,"file":"infiniteQueryObserver.js","names":[],"sources":["../../src/infiniteQueryObserver.ts"],"sourcesContent":["import { QueryObserver } from './queryObserver'\nimport { hasNextPage, hasPreviousPage } from './infiniteQueryBehavior'\nimport type { Subscribable } from './subscribable'\nimport type {\n  DefaultError,\n  DefaultedInfiniteQueryObserverOptions,\n  FetchNextPageOptions,\n  FetchPreviousPageOptions,\n  InfiniteData,\n  InfiniteQueryObserverBaseResult,\n  InfiniteQueryObserverOptions,\n  InfiniteQueryObserverResult,\n  QueryKey,\n} from './types'\nimport type { QueryClient } from './queryClient'\nimport type { Query } from './query'\n\ntype InfiniteQueryObserverListener<TData, TError> = (\n  result: InfiniteQueryObserverResult<TData, TError>,\n) => void\n\n/**\n * An `InfiniteQueryObserver` extends `QueryObserver` to observe and switch\n * between infinite queries. It augments the base `QueryObserverResult` with\n * infinite-query-specific fields and methods, such as `hasNextPage` and\n * `fetchNextPage`, and is the primitive that framework adapters (e.g.\n * `useInfiniteQuery`) build their hooks on top of.\n *\n * @example\n * ```ts\n * const observer = new InfiniteQueryObserver(queryClient, {\n *   queryKey: ['projects'],\n *   queryFn: ({ pageParam }) => fetchProjects(pageParam),\n *   initialPageParam: 0,\n *   getNextPageParam: (lastPage) => lastPage.nextCursor,\n * })\n *\n * const unsubscribe = observer.subscribe((result) => console.log(result))\n * ```\n */\nexport class InfiniteQueryObserver<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n> extends QueryObserver<\n  TQueryFnData,\n  TError,\n  TData,\n  InfiniteData<TQueryFnData, TPageParam>,\n  TQueryKey\n> {\n  // Type override\n  subscribe!: Subscribable<\n    InfiniteQueryObserverListener<TData, TError>\n  >['subscribe']\n\n  // Type override\n  getCurrentResult!: ReplaceReturnType<\n    QueryObserver<\n      TQueryFnData,\n      TError,\n      TData,\n      InfiniteData<TQueryFnData, TPageParam>,\n      TQueryKey\n    >['getCurrentResult'],\n    InfiniteQueryObserverResult<TData, TError>\n  >\n\n  // Type override\n  protected fetch!: ReplaceReturnType<\n    QueryObserver<\n      TQueryFnData,\n      TError,\n      TData,\n      InfiniteData<TQueryFnData, TPageParam>,\n      TQueryKey\n    >['fetch'],\n    Promise<InfiniteQueryObserverResult<TData, TError>>\n  >\n\n  constructor(\n    client: QueryClient,\n    options: InfiniteQueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ) {\n    super(client, options)\n  }\n\n  protected bindMethods(): void {\n    super.bindMethods()\n    this.fetchNextPage = this.fetchNextPage.bind(this)\n    this.fetchPreviousPage = this.fetchPreviousPage.bind(this)\n  }\n\n  /**\n   * Updates the observer's options. Behaves the same as\n   * `QueryObserver.setOptions`, additionally marking the options as\n   * belonging to an infinite query before delegating to the base\n   * implementation.\n   */\n  setOptions(\n    options: InfiniteQueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): void {\n    options._type = 'infinite'\n    super.setOptions(options)\n  }\n\n  /**\n   * The infinite-query counterpart of {@link QueryObserver#getOptimisticResult}, marking the\n   * options as an infinite query before delegating to it. Called by framework adapters (e.g.\n   * `useInfiniteQuery`) ahead of subscribing, to compute the current `InfiniteQueryObserverResult`\n   * synchronously.\n   */\n  getOptimisticResult(\n    options: DefaultedInfiniteQueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): InfiniteQueryObserverResult<TData, TError> {\n    options._type = 'infinite'\n    return super.getOptimisticResult(options) as InfiniteQueryObserverResult<\n      TData,\n      TError\n    >\n  }\n\n  /**\n   * Fetches the next page of the infinite query and returns a promise that\n   * resolves with the resulting `InfiniteQueryObserverResult`. The page\n   * param used for the fetch is determined by `getNextPageParam`, which\n   * receives the current pages/page params and whose result also determines\n   * `hasNextPage`.\n   *\n   * @example\n   * ```ts\n   * const { hasNextPage } = observer.getCurrentResult()\n   *\n   * if (hasNextPage) {\n   *   await observer.fetchNextPage()\n   * }\n   * ```\n   *\n   * @see {@link InfiniteQueryObserver#fetchPreviousPage}\n   */\n  fetchNextPage(\n    options?: FetchNextPageOptions,\n  ): Promise<InfiniteQueryObserverResult<TData, TError>> {\n    return this.fetch({\n      ...options,\n      meta: {\n        fetchMore: { direction: 'forward' },\n      },\n    })\n  }\n\n  /**\n   * Fetches the previous page of the infinite query and returns a promise\n   * that resolves with the resulting `InfiniteQueryObserverResult`. The page\n   * param used for the fetch is determined by `getPreviousPageParam`, which\n   * receives the current pages/page params and whose result also determines\n   * `hasPreviousPage`.\n   *\n   * @example\n   * ```ts\n   * const { hasPreviousPage } = observer.getCurrentResult()\n   *\n   * if (hasPreviousPage) {\n   *   await observer.fetchPreviousPage()\n   * }\n   * ```\n   *\n   * @see {@link InfiniteQueryObserver#fetchNextPage}\n   */\n  fetchPreviousPage(\n    options?: FetchPreviousPageOptions,\n  ): Promise<InfiniteQueryObserverResult<TData, TError>> {\n    return this.fetch({\n      ...options,\n      meta: {\n        fetchMore: { direction: 'backward' },\n      },\n    })\n  }\n\n  protected createResult(\n    query: Query<\n      TQueryFnData,\n      TError,\n      InfiniteData<TQueryFnData, TPageParam>,\n      TQueryKey\n    >,\n    options: InfiniteQueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): InfiniteQueryObserverResult<TData, TError> {\n    const { state } = query\n    const parentResult = super.createResult(query, options)\n\n    const { isFetching, isRefetching, isError, isRefetchError } = parentResult\n    const fetchDirection = state.fetchMeta?.fetchMore?.direction\n\n    const isFetchNextPageError = isError && fetchDirection === 'forward'\n    const isFetchingNextPage = isFetching && fetchDirection === 'forward'\n\n    const isFetchPreviousPageError = isError && fetchDirection === 'backward'\n    const isFetchingPreviousPage = isFetching && fetchDirection === 'backward'\n\n    const result: InfiniteQueryObserverBaseResult<TData, TError> = {\n      ...parentResult,\n      fetchNextPage: this.fetchNextPage,\n      fetchPreviousPage: this.fetchPreviousPage,\n      hasNextPage: hasNextPage(options, state.data),\n      hasPreviousPage: hasPreviousPage(options, state.data),\n      isFetchNextPageError,\n      isFetchingNextPage,\n      isFetchPreviousPageError,\n      isFetchingPreviousPage,\n      isRefetchError:\n        isRefetchError && !isFetchNextPageError && !isFetchPreviousPageError,\n      isRefetching:\n        isRefetching && !isFetchingNextPage && !isFetchingPreviousPage,\n    }\n\n    return result as InfiniteQueryObserverResult<TData, TError>\n  }\n}\n\ntype ReplaceReturnType<\n  TFunction extends (...args: Array<any>) => unknown,\n  TReturn,\n> = (...args: Parameters<TFunction>) => TReturn\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAwCA,IAAa,wBAAb,cAMU,cAMR;CA8BA,YACE,QACA,SAOA;EACA,MAAM,QAAQ,OAAO;CACvB;CAEA,cAA8B;EAC5B,MAAM,YAAY;EAClB,KAAK,gBAAgB,KAAK,cAAc,KAAK,IAAI;EACjD,KAAK,oBAAoB,KAAK,kBAAkB,KAAK,IAAI;CAC3D;;;;;;;CAQA,WACE,SAOM;EACN,QAAQ,QAAQ;EAChB,MAAM,WAAW,OAAO;CAC1B;;;;;;;CAQA,oBACE,SAO4C;EAC5C,QAAQ,QAAQ;EAChB,OAAO,MAAM,oBAAoB,OAAO;CAI1C;;;;;;;;;;;;;;;;;;;CAoBA,cACE,SACqD;EACrD,OAAO,KAAK,MAAM;GAChB,GAAG;GACH,MAAM,EACJ,WAAW,EAAE,WAAW,UAAU,EACpC;EACF,CAAC;CACH;;;;;;;;;;;;;;;;;;;CAoBA,kBACE,SACqD;EACrD,OAAO,KAAK,MAAM;GAChB,GAAG;GACH,MAAM,EACJ,WAAW,EAAE,WAAW,WAAW,EACrC;EACF,CAAC;CACH;CAEA,aACE,OAMA,SAO4C;EAC5C,MAAM,EAAE,UAAU;EAClB,MAAM,eAAe,MAAM,aAAa,OAAO,OAAO;EAEtD,MAAM,EAAE,YAAY,cAAc,SAAS,mBAAmB;EAC9D,MAAM,iBAAiB,MAAM,WAAW,WAAW;EAEnD,MAAM,uBAAuB,WAAW,mBAAmB;EAC3D,MAAM,qBAAqB,cAAc,mBAAmB;EAE5D,MAAM,2BAA2B,WAAW,mBAAmB;EAC/D,MAAM,yBAAyB,cAAc,mBAAmB;EAkBhE,OAAO;GAfL,GAAG;GACH,eAAe,KAAK;GACpB,mBAAmB,KAAK;GACxB,aAAa,YAAY,SAAS,MAAM,IAAI;GAC5C,iBAAiB,gBAAgB,SAAS,MAAM,IAAI;GACpD;GACA;GACA;GACA;GACA,gBACE,kBAAkB,CAAC,wBAAwB,CAAC;GAC9C,cACE,gBAAgB,CAAC,sBAAsB,CAAC;EAGhC;CACd;AACF"}

package/build/modern/mutation.cjs

@@ -3,6 +3,23 @@ const require_notifyManager = require("./notifyManager.cjs");
 const require_retryer = require("./retryer.cjs");
 const require_removable = require("./removable.cjs");
 //#region src/mutation.ts
+/**
+* Represents a single mutation attempt. A `Mutation` holds the mutation's
+* options, state (data/error/status), and the `MutationObserver`s currently
+* subscribed to it.
+*
+* Instances are created and managed internally by `MutationCache`; application
+* code typically interacts with mutations indirectly through `QueryClient` or
+* a framework hook like `useMutation`. Direct access to a `Mutation` instance
+* is possible via `mutationCache.find()`/`getAll()` for inspecting cache state.
+*
+* @example
+* ```ts
+* const mutationCache = queryClient.getMutationCache()
+*
+* const mutation = mutationCache.find({ mutationKey: ['addPost'] })
+* ```
+*/
 var Mutation = class extends require_removable.Removable {
 	#client;
 	#observers;
@@ -18,13 +35,18 @@ var Mutation = class extends require_removable.Removable {
 		this.setOptions(config.options);
 		this.scheduleGc();
 	}
+	/** @internal */
 	setOptions(options) {
 		this.options = options;
 		this.updateGcTime(this.options.gcTime);
 	}
+	/**
+	* The `meta` object passed in the mutation's options, if any.
+	*/
 	get meta() {
 		return this.options.meta;
 	}
+	/** @internal */
 	addObserver(observer) {
 		if (!this.#observers.includes(observer)) {
 			this.#observers.push(observer);
@@ -36,6 +58,7 @@ var Mutation = class extends require_removable.Removable {
 			});
 		}
 	}
+	/** @internal */
 	removeObserver(observer) {
 		this.#observers = this.#observers.filter((x) => x !== observer);
 		this.scheduleGc();
@@ -51,9 +74,60 @@ var Mutation = class extends require_removable.Removable {
 			else this.#mutationCache.remove(this);
 		}
 	}
+	/**
+	* Resumes a mutation that is currently paused or was restored from a
+	* dehydrated, still-`pending` state.
+	*
+	* - If this mutation has an active retryer (it paused mid-attempt, e.g. due
+	*   to the network mode or scope-based queuing), its retryer is resumed.
+	* - Otherwise, if the mutation's status is still `pending` (e.g. it was
+	*   dehydrated while an attempt was in flight and never got a retryer in
+	*   this instance), `execute` is called again with the last known variables.
+	* - Otherwise the mutation has already settled and this resolves immediately
+	*   without running anything again.
+	*
+	* @example
+	* ```ts
+	* // typically driven by reconnect handling, e.g. queryClient.resumePausedMutations()
+	* const mutation = mutationCache.find({ mutationKey: ['addPost'] })
+	* await mutation?.continue()
+	* ```
+	*
+	* @see {@link Mutation#execute}
+	*/
 	continue() {
 		return this.#retryer?.continue() ?? (this.state.status === "pending" ? this.execute(this.state.variables) : Promise.resolve());
 	}
+	/**
+	* Runs the mutation function for the given variables through a retryer, and
+	* drives the mutation's state and lifecycle callbacks through to settlement.
+	*
+	* If this mutation's state is already `pending` when `execute` is called
+	* (i.e. it was restored, still in-flight, from a dehydrated state), the
+	* `onMutate` step is skipped and a `continue` action is dispatched to
+	* unpause it; otherwise a `pending` action is dispatched first, then the
+	* mutation cache's `onMutate` and the mutation's own `onMutate` option are
+	* awaited in that order, and the resulting context is stored.
+	*
+	* The mutation function is then run (subject to `retry`/`retryDelay`/
+	* `networkMode`, and to the mutation cache's scope-based serialization).
+	* On success, the cache's `onSuccess`/`onSettled` callbacks run before the
+	* mutation's own `onSuccess`/`onSettled` options, a `success` action is
+	* dispatched, and the resolved data is returned. On failure, the same
+	* cache-then-option ordering is used for `onError`/`onSettled`, but each of
+	* those four callbacks is individually caught so that a throwing callback
+	* cannot mask the original error; an `error` action is then dispatched and
+	* the original error is re-thrown.
+	*
+	* @example
+	* ```ts
+	* // Called internally by `MutationObserver.mutate` and `Mutation.continue` —
+	* // applications normally trigger mutations through those, not this method.
+	* const data = await mutation.execute(variables)
+	* ```
+	*
+	* @see {@link Mutation#continue}
+	*/
 	async execute(variables) {
 		const onContinue = () => {
 			this.#dispatch({ type: "continue" });