@tanstack/angular-query-experimental 5.102.8 → 5.103.1

package/infinite-query-options.d.ts

@@ -1,35 +1,216 @@
 import { DefaultError, InfiniteData, InitialDataFunction, NonUndefinedGuard, OmitKeyof, QueryKey, QueryKeyWithDataTag, SkipToken } from '@tanstack/query-core';
 import { CreateInfiniteQueryOptions } from './types.js';
+/**
+ * The options accepted by the `infiniteQueryOptions` overload selected when no `initialData` is set — `data`
+ * may be `undefined` while the query is `pending`.
+ *
+ * @template TQueryFnData - The type of a single page, as your `queryFn` resolves it.
+ * @template TError - The type of errors your `queryFn` may throw.
+ * @template TData - The type `data` ends up as after `select` runs — defaults to `InfiniteData<TQueryFnData>`,
+ * the shape of all fetched pages plus their page params.
+ * @template TQueryKey - The type of your `queryKey`.
+ * @template TPageParam - The type of the parameter passed to `queryFn` to fetch a given page.
+ */
 export type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+    /**
+     * If set, this value will be used as the initial data for the query cache (as long as the query hasn't been
+     * created or cached yet). If set to a function, the function will be called **once** during the shared/root
+     * query initialization, and be expected to synchronously return the initial data. Initial data is
+     * considered stale by default unless a `staleTime` has been set. `initialData` **is persisted** to the
+     * cache.
+     */
     initialData?: undefined | NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> | InitialDataFunction<NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>>;
 };
+/**
+ * The options accepted by the `infiniteQueryOptions` overload selected when no `initialData` is set and
+ * `queryFn` is not `skipToken` — same as {@link UndefinedInitialDataInfiniteOptions}, but `queryFn` may not be
+ * `skipToken`.
+ *
+ * @template TQueryFnData - The type of a single page, as your `queryFn` resolves it.
+ * @template TError - The type of errors your `queryFn` may throw.
+ * @template TData - The type `data` ends up as after `select` runs — defaults to `InfiniteData<TQueryFnData>`,
+ * the shape of all fetched pages plus their page params.
+ * @template TQueryKey - The type of your `queryKey`.
+ * @template TPageParam - The type of the parameter passed to `queryFn` to fetch a given page.
+ */
 export type UnusedSkipTokenInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = OmitKeyof<CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn'> & {
+    /**
+     * `skipToken` is not allowed as a value here — this overload is selected when no `initialData` is set. If
+     * you don't intend to run the query yet, set `enabled: false` — omitting `queryFn` alone still triggers a
+     * fetch that fails with "Missing queryFn" unless `enabled` is `false` or a default query function has been
+     * defined. A default query function only supplies `queryFn`; it doesn't defer the fetch on its own.
+     */
     queryFn?: Exclude<CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>['queryFn'], SkipToken | undefined>;
 };
+/**
+ * The options accepted by the `infiniteQueryOptions` overload selected when `initialData` is set — `data` is
+ * never `undefined` (unless a `select` changes `TData` to include `undefined`).
+ *
+ * @template TQueryFnData - The type of a single page, as your `queryFn` resolves it.
+ * @template TError - The type of errors your `queryFn` may throw.
+ * @template TData - The type `data` ends up as after `select` runs — defaults to `InfiniteData<TQueryFnData>`,
+ * the shape of all fetched pages plus their page params.
+ * @template TQueryKey - The type of your `queryKey`.
+ * @template TPageParam - The type of the parameter passed to `queryFn` to fetch a given page.
+ */
 export type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+    /**
+     * If set, this value will be used as the initial data for the query cache (as long as the query hasn't been
+     * created or cached yet). If set to a function, the function will be called **once** during the shared/root
+     * query initialization, and be expected to synchronously return the initial data. Initial data is
+     * considered stale by default unless a `staleTime` has been set. `initialData` **is persisted** to the
+     * cache.
+     */
     initialData: NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> | (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>) | undefined;
 };
 /**
- * Allows sharing and re-using infinite query options in a type-safe way.
+ * You can generally pass everything to `infiniteQueryOptions` that you can also pass to
+ * `injectInfiniteQuery`. These options can be shared across functions and imperative APIs such as
+ * `queryClient.fetchInfiniteQuery`. `options.queryKey` is required and is the query key to generate options
+ * for.
+ *
+ * This overload is selected when `initialData` is set.
+ *
+ * @see {@link injectInfiniteQuery} to run an infinite query with these options.
+ * @param options - The {@link DefinedInitialDataInfiniteOptions} to use — everything you can pass to
+ * `injectInfiniteQuery`, with `initialData` set.
+ * @returns The same options object, typed so that `queryKey` carries the inferred data type.
+ * @remarks See {@link injectInfiniteQuery} for examples that fetch further pages, from a button click or
+ * automatically as the user scrolls.
  *
- * The `queryKey` will be tagged with the type from `queryFn`.
- * @param options - The infinite query options to tag with the type from `queryFn`.
- * @returns The tagged infinite query options.
+ * @example
+ * ```angular-ts
+ * import { infiniteQueryOptions, injectInfiniteQuery } from '@tanstack/angular-query-experimental'
+ *
+ * export const projectsOptions = infiniteQueryOptions({
+ *   queryKey: ['projects'],
+ *   queryFn: ({ pageParam }) => fetchProjects(pageParam),
+ *   initialPageParam: 0,
+ *   getNextPageParam: (lastPage) => lastPage.nextId,
+ *   initialData: { pages: [], pageParams: [] },
+ * })
+ *
+ * @Component({
+ *   selector: 'projects',
+ *   template: `
+ *     <!-- `projectsQuery.data()` is never `undefined`, thanks to `initialData` — even if a
+ *     refetch fails, so the list stays visible alongside the error. -->
+ *     <ul>
+ *       @for (page of projectsQuery.data().pages; track $index) {
+ *         @for (project of page.projects; track project.id) {
+ *           <li>{{ project.name }}</li>
+ *         }
+ *       }
+ *     </ul>
+ *   `,
+ * })
+ * export class Projects {
+ *   readonly projectsQuery = injectInfiniteQuery(() => projectsOptions)
+ * }
+ * ```
  */
 export declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
 /**
- * Allows sharing and re-using infinite query options in a type-safe way.
+ * You can generally pass everything to `infiniteQueryOptions` that you can also pass to
+ * `injectInfiniteQuery`. These options can be shared across functions and imperative APIs such as
+ * `queryClient.fetchInfiniteQuery`. `options.queryKey` is required and is the query key to generate options
+ * for.
+ *
+ * @returns The same options object, typed so that `queryKey` carries the inferred data type.
+ * @remarks See {@link injectInfiniteQuery} for examples that fetch further pages, from a button click or
+ * automatically as the user scrolls.
+ *
+ * @example
+ * A parameterized factory, so the same options object can be reused per `postId`:
+ * ```angular-ts
+ * import { infiniteQueryOptions, injectInfiniteQuery } from '@tanstack/angular-query-experimental'
+ *
+ * export const commentsOptions = (postId: string) =>
+ *   infiniteQueryOptions({
+ *     queryKey: ['post', postId, 'comments'],
+ *     queryFn: ({ pageParam }) => fetchComments(postId, pageParam),
+ *     initialPageParam: 0,
+ *     getNextPageParam: (lastPage) => lastPage.nextId,
+ *   })
  *
- * The `queryKey` will be tagged with the type from `queryFn`.
- * @param options - The infinite query options to tag with the type from `queryFn`.
- * @returns The tagged infinite query options.
+ * @Component({
+ *   selector: 'comments',
+ *   template: `
+ *     @if (commentsQuery.isPending()) {
+ *       Loading...
+ *     } @else if (commentsQuery.isError()) {
+ *       <span>Error: {{ commentsQuery.error()?.message }}</span>
+ *     } @else {
+ *       <ul>
+ *         @for (page of commentsQuery.data().pages; track $index) {
+ *           @for (comment of page.comments; track comment.id) {
+ *             <li>{{ comment.text }}</li>
+ *           }
+ *         }
+ *       </ul>
+ *     }
+ *   `,
+ * })
+ * export class Comments {
+ *   readonly postId = signal('1')
+ *   readonly commentsQuery = injectInfiniteQuery(() => commentsOptions(this.postId()))
+ * }
+ * ```
+ *
+ * @see {@link injectInfiniteQuery} to run an infinite query with these options.
+ * @param options - The {@link UnusedSkipTokenInfiniteOptions} to use — everything you can pass to
+ * `injectInfiniteQuery`.
  */
 export declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
 /**
- * Allows sharing and re-using infinite query options in a type-safe way.
+ * You can generally pass everything to `infiniteQueryOptions` that you can also pass to
+ * `injectInfiniteQuery`. These options can be shared across functions and imperative APIs such as
+ * `queryClient.fetchInfiniteQuery`. `options.queryKey` is required and is the query key to generate options
+ * for.
+ *
+ * @returns The same options object, typed so that `queryKey` carries the inferred data type.
+ * @remarks See {@link injectInfiniteQuery} for examples that fetch further pages (from a button click or
+ * automatically as the user scrolls) and that use `skipToken` to disable the query until `postId` is set.
+ *
+ * @example
+ * A parameterized factory, so the same options object can be reused per `postId`:
+ * ```angular-ts
+ * import { infiniteQueryOptions, injectInfiniteQuery } from '@tanstack/angular-query-experimental'
+ *
+ * export const commentsOptions = (postId: string) =>
+ *   infiniteQueryOptions({
+ *     queryKey: ['post', postId, 'comments'],
+ *     queryFn: ({ pageParam }) => fetchComments(postId, pageParam),
+ *     initialPageParam: 0,
+ *     getNextPageParam: (lastPage) => lastPage.nextId,
+ *   })
+ *
+ * @Component({
+ *   selector: 'comments',
+ *   template: `
+ *     @if (commentsQuery.isPending()) {
+ *       Loading...
+ *     } @else if (commentsQuery.isError()) {
+ *       <span>Error: {{ commentsQuery.error()?.message }}</span>
+ *     } @else {
+ *       <ul>
+ *         @for (page of commentsQuery.data().pages; track $index) {
+ *           @for (comment of page.comments; track comment.id) {
+ *             <li>{{ comment.text }}</li>
+ *           }
+ *         }
+ *       </ul>
+ *     }
+ *   `,
+ * })
+ * export class Comments {
+ *   readonly postId = signal('1')
+ *   readonly commentsQuery = injectInfiniteQuery(() => commentsOptions(this.postId()))
+ * }
+ * ```
  *
- * The `queryKey` will be tagged with the type from `queryFn`.
- * @param options - The infinite query options to tag with the type from `queryFn`.
- * @returns The tagged infinite query options.
+ * @see {@link injectInfiniteQuery} to run an infinite query with these options.
+ * @param options - The {@link UndefinedInitialDataInfiniteOptions} to use — everything you can pass to
+ * `injectInfiniteQuery`.
  */
 export declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;

package/infinite-query-options.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"infinite-query-options.mjs","sources":["../src/infinite-query-options.ts"],"sourcesContent":["import type {\n  DefaultError,\n  InfiniteData,\n  InitialDataFunction,\n  NonUndefinedGuard,\n  OmitKeyof,\n  QueryKey,\n  QueryKeyWithDataTag,\n  SkipToken,\n} from '@tanstack/query-core'\nimport type { CreateInfiniteQueryOptions } from './types'\n\nexport type UndefinedInitialDataInfiniteOptions<\n  TQueryFnData,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n> = CreateInfiniteQueryOptions<\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryKey,\n  TPageParam\n> & {\n  initialData?:\n    | undefined\n    | NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n    | InitialDataFunction<\n        NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n      >\n}\n\nexport type UnusedSkipTokenInfiniteOptions<\n  TQueryFnData,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n> = OmitKeyof<\n  CreateInfiniteQueryOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >,\n  'queryFn'\n> & {\n  queryFn?: Exclude<\n    CreateInfiniteQueryOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >['queryFn'],\n    SkipToken | undefined\n  >\n}\n\nexport type DefinedInitialDataInfiniteOptions<\n  TQueryFnData,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n> = CreateInfiniteQueryOptions<\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryKey,\n  TPageParam\n> & {\n  initialData:\n    | NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n    | (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>)\n    | undefined\n}\n\n/**\n * Allows sharing and re-using infinite query options in a type-safe way.\n *\n * The `queryKey` will be tagged with the type from `queryFn`.\n * @param options - The infinite query options to tag with the type from `queryFn`.\n * @returns The tagged infinite query options.\n */\nexport function infiniteQueryOptions<\n  TQueryFnData,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n>(\n  options: DefinedInitialDataInfiniteOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >,\n): DefinedInitialDataInfiniteOptions<\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryKey,\n  TPageParam\n> &\n  QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n\n/**\n * Allows sharing and re-using infinite query options in a type-safe way.\n *\n * The `queryKey` will be tagged with the type from `queryFn`.\n * @param options - The infinite query options to tag with the type from `queryFn`.\n * @returns The tagged infinite query options.\n */\nexport function infiniteQueryOptions<\n  TQueryFnData,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n>(\n  options: UnusedSkipTokenInfiniteOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >,\n): UnusedSkipTokenInfiniteOptions<\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryKey,\n  TPageParam\n> &\n  QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n\n/**\n * Allows sharing and re-using infinite query options in a type-safe way.\n *\n * The `queryKey` will be tagged with the type from `queryFn`.\n * @param options - The infinite query options to tag with the type from `queryFn`.\n * @returns The tagged infinite query options.\n */\nexport function infiniteQueryOptions<\n  TQueryFnData,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n>(\n  options: UndefinedInitialDataInfiniteOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >,\n): UndefinedInitialDataInfiniteOptions<\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryKey,\n  TPageParam\n> &\n  QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n\n/**\n * Allows sharing and re-using infinite query options in a type-safe way.\n *\n * The `queryKey` will be tagged with the type from `queryFn`.\n * @param options - The infinite query options to tag with the type from `queryFn`.\n * @returns The tagged infinite query options.\n */\nexport function infiniteQueryOptions(options: unknown) {\n  return options\n}\n"],"names":[],"mappings":"AAiLO,SAAS,qBAAqB,SAAkB;AACrD,SAAO;AACT;"}
+{"version":3,"file":"infinite-query-options.mjs","sources":["../src/infinite-query-options.ts"],"sourcesContent":["import type {\n  DefaultError,\n  InfiniteData,\n  InitialDataFunction,\n  NonUndefinedGuard,\n  OmitKeyof,\n  QueryKey,\n  QueryKeyWithDataTag,\n  SkipToken,\n} from '@tanstack/query-core'\nimport type { CreateInfiniteQueryOptions } from './types'\n\n/**\n * The options accepted by the `infiniteQueryOptions` overload selected when no `initialData` is set — `data`\n * may be `undefined` while the query is `pending`.\n *\n * @template TQueryFnData - The type of a single page, as your `queryFn` resolves it.\n * @template TError - The type of errors your `queryFn` may throw.\n * @template TData - The type `data` ends up as after `select` runs — defaults to `InfiniteData<TQueryFnData>`,\n * the shape of all fetched pages plus their page params.\n * @template TQueryKey - The type of your `queryKey`.\n * @template TPageParam - The type of the parameter passed to `queryFn` to fetch a given page.\n */\nexport type UndefinedInitialDataInfiniteOptions<\n  TQueryFnData,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n> = CreateInfiniteQueryOptions<\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryKey,\n  TPageParam\n> & {\n  /**\n   * If set, this value will be used as the initial data for the query cache (as long as the query hasn't been\n   * created or cached yet). If set to a function, the function will be called **once** during the shared/root\n   * query initialization, and be expected to synchronously return the initial data. Initial data is\n   * considered stale by default unless a `staleTime` has been set. `initialData` **is persisted** to the\n   * cache.\n   */\n  initialData?:\n    | undefined\n    | NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n    | InitialDataFunction<\n        NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n      >\n}\n\n/**\n * The options accepted by the `infiniteQueryOptions` overload selected when no `initialData` is set and\n * `queryFn` is not `skipToken` — same as {@link UndefinedInitialDataInfiniteOptions}, but `queryFn` may not be\n * `skipToken`.\n *\n * @template TQueryFnData - The type of a single page, as your `queryFn` resolves it.\n * @template TError - The type of errors your `queryFn` may throw.\n * @template TData - The type `data` ends up as after `select` runs — defaults to `InfiniteData<TQueryFnData>`,\n * the shape of all fetched pages plus their page params.\n * @template TQueryKey - The type of your `queryKey`.\n * @template TPageParam - The type of the parameter passed to `queryFn` to fetch a given page.\n */\nexport type UnusedSkipTokenInfiniteOptions<\n  TQueryFnData,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n> = OmitKeyof<\n  CreateInfiniteQueryOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >,\n  'queryFn'\n> & {\n  /**\n   * `skipToken` is not allowed as a value here — this overload is selected when no `initialData` is set. If\n   * you don't intend to run the query yet, set `enabled: false` — omitting `queryFn` alone still triggers a\n   * fetch that fails with \"Missing queryFn\" unless `enabled` is `false` or a default query function has been\n   * defined. A default query function only supplies `queryFn`; it doesn't defer the fetch on its own.\n   */\n  queryFn?: Exclude<\n    CreateInfiniteQueryOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >['queryFn'],\n    SkipToken | undefined\n  >\n}\n\n/**\n * The options accepted by the `infiniteQueryOptions` overload selected when `initialData` is set — `data` is\n * never `undefined` (unless a `select` changes `TData` to include `undefined`).\n *\n * @template TQueryFnData - The type of a single page, as your `queryFn` resolves it.\n * @template TError - The type of errors your `queryFn` may throw.\n * @template TData - The type `data` ends up as after `select` runs — defaults to `InfiniteData<TQueryFnData>`,\n * the shape of all fetched pages plus their page params.\n * @template TQueryKey - The type of your `queryKey`.\n * @template TPageParam - The type of the parameter passed to `queryFn` to fetch a given page.\n */\nexport type DefinedInitialDataInfiniteOptions<\n  TQueryFnData,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n> = CreateInfiniteQueryOptions<\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryKey,\n  TPageParam\n> & {\n  /**\n   * If set, this value will be used as the initial data for the query cache (as long as the query hasn't been\n   * created or cached yet). If set to a function, the function will be called **once** during the shared/root\n   * query initialization, and be expected to synchronously return the initial data. Initial data is\n   * considered stale by default unless a `staleTime` has been set. `initialData` **is persisted** to the\n   * cache.\n   */\n  initialData:\n    | NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n    | (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>)\n    | undefined\n}\n\n/**\n * You can generally pass everything to `infiniteQueryOptions` that you can also pass to\n * `injectInfiniteQuery`. These options can be shared across functions and imperative APIs such as\n * `queryClient.fetchInfiniteQuery`. `options.queryKey` is required and is the query key to generate options\n * for.\n *\n * This overload is selected when `initialData` is set.\n *\n * @see {@link injectInfiniteQuery} to run an infinite query with these options.\n * @param options - The {@link DefinedInitialDataInfiniteOptions} to use — everything you can pass to\n * `injectInfiniteQuery`, with `initialData` set.\n * @returns The same options object, typed so that `queryKey` carries the inferred data type.\n * @remarks See {@link injectInfiniteQuery} for examples that fetch further pages, from a button click or\n * automatically as the user scrolls.\n *\n * @example\n * ```angular-ts\n * import { infiniteQueryOptions, injectInfiniteQuery } from '@tanstack/angular-query-experimental'\n *\n * export const projectsOptions = infiniteQueryOptions({\n *   queryKey: ['projects'],\n *   queryFn: ({ pageParam }) => fetchProjects(pageParam),\n *   initialPageParam: 0,\n *   getNextPageParam: (lastPage) => lastPage.nextId,\n *   initialData: { pages: [], pageParams: [] },\n * })\n *\n * @Component({\n *   selector: 'projects',\n *   template: `\n *     <!-- `projectsQuery.data()` is never `undefined`, thanks to `initialData` — even if a\n *     refetch fails, so the list stays visible alongside the error. -->\n *     <ul>\n *       @for (page of projectsQuery.data().pages; track $index) {\n *         @for (project of page.projects; track project.id) {\n *           <li>{{ project.name }}</li>\n *         }\n *       }\n *     </ul>\n *   `,\n * })\n * export class Projects {\n *   readonly projectsQuery = injectInfiniteQuery(() => projectsOptions)\n * }\n * ```\n */\nexport function infiniteQueryOptions<\n  TQueryFnData,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n>(\n  options: DefinedInitialDataInfiniteOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >,\n): DefinedInitialDataInfiniteOptions<\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryKey,\n  TPageParam\n> &\n  QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n\n/**\n * You can generally pass everything to `infiniteQueryOptions` that you can also pass to\n * `injectInfiniteQuery`. These options can be shared across functions and imperative APIs such as\n * `queryClient.fetchInfiniteQuery`. `options.queryKey` is required and is the query key to generate options\n * for.\n *\n * @returns The same options object, typed so that `queryKey` carries the inferred data type.\n * @remarks See {@link injectInfiniteQuery} for examples that fetch further pages, from a button click or\n * automatically as the user scrolls.\n *\n * @example\n * A parameterized factory, so the same options object can be reused per `postId`:\n * ```angular-ts\n * import { infiniteQueryOptions, injectInfiniteQuery } from '@tanstack/angular-query-experimental'\n *\n * export const commentsOptions = (postId: string) =>\n *   infiniteQueryOptions({\n *     queryKey: ['post', postId, 'comments'],\n *     queryFn: ({ pageParam }) => fetchComments(postId, pageParam),\n *     initialPageParam: 0,\n *     getNextPageParam: (lastPage) => lastPage.nextId,\n *   })\n *\n * @Component({\n *   selector: 'comments',\n *   template: `\n *     @if (commentsQuery.isPending()) {\n *       Loading...\n *     } @else if (commentsQuery.isError()) {\n *       <span>Error: {{ commentsQuery.error()?.message }}</span>\n *     } @else {\n *       <ul>\n *         @for (page of commentsQuery.data().pages; track $index) {\n *           @for (comment of page.comments; track comment.id) {\n *             <li>{{ comment.text }}</li>\n *           }\n *         }\n *       </ul>\n *     }\n *   `,\n * })\n * export class Comments {\n *   readonly postId = signal('1')\n *   readonly commentsQuery = injectInfiniteQuery(() => commentsOptions(this.postId()))\n * }\n * ```\n *\n * @see {@link injectInfiniteQuery} to run an infinite query with these options.\n * @param options - The {@link UnusedSkipTokenInfiniteOptions} to use — everything you can pass to\n * `injectInfiniteQuery`.\n */\nexport function infiniteQueryOptions<\n  TQueryFnData,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n>(\n  options: UnusedSkipTokenInfiniteOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >,\n): UnusedSkipTokenInfiniteOptions<\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryKey,\n  TPageParam\n> &\n  QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n\n/**\n * You can generally pass everything to `infiniteQueryOptions` that you can also pass to\n * `injectInfiniteQuery`. These options can be shared across functions and imperative APIs such as\n * `queryClient.fetchInfiniteQuery`. `options.queryKey` is required and is the query key to generate options\n * for.\n *\n * @returns The same options object, typed so that `queryKey` carries the inferred data type.\n * @remarks See {@link injectInfiniteQuery} for examples that fetch further pages (from a button click or\n * automatically as the user scrolls) and that use `skipToken` to disable the query until `postId` is set.\n *\n * @example\n * A parameterized factory, so the same options object can be reused per `postId`:\n * ```angular-ts\n * import { infiniteQueryOptions, injectInfiniteQuery } from '@tanstack/angular-query-experimental'\n *\n * export const commentsOptions = (postId: string) =>\n *   infiniteQueryOptions({\n *     queryKey: ['post', postId, 'comments'],\n *     queryFn: ({ pageParam }) => fetchComments(postId, pageParam),\n *     initialPageParam: 0,\n *     getNextPageParam: (lastPage) => lastPage.nextId,\n *   })\n *\n * @Component({\n *   selector: 'comments',\n *   template: `\n *     @if (commentsQuery.isPending()) {\n *       Loading...\n *     } @else if (commentsQuery.isError()) {\n *       <span>Error: {{ commentsQuery.error()?.message }}</span>\n *     } @else {\n *       <ul>\n *         @for (page of commentsQuery.data().pages; track $index) {\n *           @for (comment of page.comments; track comment.id) {\n *             <li>{{ comment.text }}</li>\n *           }\n *         }\n *       </ul>\n *     }\n *   `,\n * })\n * export class Comments {\n *   readonly postId = signal('1')\n *   readonly commentsQuery = injectInfiniteQuery(() => commentsOptions(this.postId()))\n * }\n * ```\n *\n * @see {@link injectInfiniteQuery} to run an infinite query with these options.\n * @param options - The {@link UndefinedInitialDataInfiniteOptions} to use — everything you can pass to\n * `injectInfiniteQuery`.\n */\nexport function infiniteQueryOptions<\n  TQueryFnData,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n>(\n  options: UndefinedInitialDataInfiniteOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >,\n): UndefinedInitialDataInfiniteOptions<\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryKey,\n  TPageParam\n> &\n  QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n\nexport function infiniteQueryOptions(options: unknown) {\n  return options\n}\n"],"names":[],"mappings":"AA+VO,SAAS,qBAAqB,SAAkB;AACrD,SAAO;AACT;"}

package/inject-infinite-query.d.ts

@@ -11,25 +11,203 @@ export interface InjectInfiniteQueryOptions {
     injector?: Injector;
 }
 /**
- * Injects an infinite query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
- * Infinite queries can additively "load more" data onto an existing set of data or "infinite scroll"
- * @param injectInfiniteQueryFn - A function that returns infinite query options.
+ * The options for `injectInfiniteQuery` are identical to `injectQuery`, with the addition of
+ * `initialPageParam`, `getNextPageParam`, `getPreviousPageParam`, and `maxPages`. Infinite queries can
+ * additively "load more" data onto an existing set of data, or "infinite scroll".
+ *
+ * This overload is selected when `initialData` is set on the options returned by `injectInfiniteQueryFn`,
+ * so the resulting `data` signal is never `undefined` (unless a `select` changes `TData` to include `undefined`).
+ *
+ * @remarks Keep in mind that imperative fetch calls, such as `fetchNextPage`, may interfere with the default
+ * refetch behavior, resulting in outdated data. Make sure to call these functions only in response to user
+ * actions, or add conditions like `hasNextPage() && !isFetching()`.
+ * @see {@link infiniteQueryOptions} to share these options between `injectInfiniteQuery` and imperative APIs
+ * like `queryClient.fetchInfiniteQuery`.
+ * @param injectInfiniteQueryFn - A function returning the {@link DefinedInitialDataInfiniteOptions} to use —
+ * everything you can pass to `injectInfiniteQuery`, with `initialData` set. Similar to `computed` from
+ * Angular, this function runs in the reactive context, so signals read inside it drive the query.
  * @param options - Additional configuration.
- * @returns The infinite query result.
+ * @returns The same signals as `injectQuery`, with the addition of `fetchNextPage`, `fetchPreviousPage`,
+ * `hasNextPage`, `hasPreviousPage`, `isFetchingNextPage`, and `isFetchingPreviousPage`. `data().pages` and
+ * `data().pageParams` are also added, as long as a `select` doesn't change `TData` away from its default
+ * `InfiniteData<TQueryFnData>` shape.
+ *
+ * @example
+ * ```angular-ts
+ * @Component({
+ *   selector: 'projects',
+ *   template: `
+ *     <!-- `projectsQuery.data()` is never `undefined`, thanks to `initialData` — even if a
+ *     refetch fails, so the list stays visible alongside the error. -->
+ *     <ul>
+ *       @for (page of projectsQuery.data().pages; track $index) {
+ *         @for (project of page.projects; track project.id) {
+ *           <li>{{ project.name }}</li>
+ *         }
+ *       }
+ *     </ul>
+ *   `,
+ * })
+ * export class Projects {
+ *   readonly projectsQuery = injectInfiniteQuery(() => ({
+ *     queryKey: ['projects'],
+ *     queryFn: ({ pageParam }) => fetchProjects(pageParam),
+ *     initialPageParam: 0,
+ *     getNextPageParam: (lastPage) => lastPage.nextId,
+ *     initialData: { pages: [], pageParams: [] },
+ *   }))
+ * }
+ * ```
  */
 export declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(injectInfiniteQueryFn: () => DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, options?: InjectInfiniteQueryOptions): DefinedCreateInfiniteQueryResult<TData, TError>;
 /**
- * Injects an infinite query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
- * Infinite queries can additively "load more" data onto an existing set of data or "infinite scroll"
- * @param injectInfiniteQueryFn - A function that returns infinite query options.
+ * Injects an infinite query: a declarative dependency on an asynchronous source of data that is tied to a
+ * unique key. Infinite queries can additively "load more" data onto an existing set of data, or
+ * "infinite scroll".
+ *
+ * @remarks Keep in mind that imperative fetch calls, such as `fetchNextPage`, may interfere with the default
+ * refetch behavior, resulting in outdated data. Make sure to call these functions only in response to user
+ * actions, or add conditions like `hasNextPage() && !isFetching()`. This is the only overload that accepts
+ * `queryFn: skipToken`, shown below.
+ * @see {@link infiniteQueryOptions} to share these options between `injectInfiniteQuery` and imperative APIs
+ * like `queryClient.fetchInfiniteQuery`.
+ * @param injectInfiniteQueryFn - A function returning the {@link UndefinedInitialDataInfiniteOptions} to use
+ * — everything you can pass to `injectInfiniteQuery`. Similar to `computed` from Angular, this function runs
+ * in the reactive context, so signals read inside it drive the query.
  * @param options - Additional configuration.
- * @returns The infinite query result.
+ * @returns The same signals as `injectQuery`, with the addition of `fetchNextPage`, `fetchPreviousPage`,
+ * `hasNextPage`, `hasPreviousPage`, `isFetchingNextPage`, and `isFetchingPreviousPage`. `data().pages` and
+ * `data().pageParams` are also added, as long as a `select` doesn't change `TData` away from its default
+ * `InfiniteData<TQueryFnData>` shape.
+ *
+ * @example
+ * Fetching the next page from a button click:
+ * ```angular-ts
+ * @Component({
+ *   selector: 'projects-list',
+ *   template: `
+ *     <ul>
+ *       @for (page of projectsQuery.data()?.pages; track $index) {
+ *         @for (project of page.projects; track project.id) {
+ *           <li>{{ project.name }}</li>
+ *         }
+ *       }
+ *     </ul>
+ *     <button
+ *       [disabled]="!projectsQuery.hasNextPage() || projectsQuery.isFetching()"
+ *       (click)="projectsQuery.fetchNextPage()"
+ *     >
+ *       Load More
+ *     </button>
+ *   `,
+ * })
+ * export class ProjectsList {
+ *   readonly projectsQuery = injectInfiniteQuery(() => ({
+ *     queryKey: ['projects'],
+ *     queryFn: ({ pageParam }) => fetchProjects(pageParam),
+ *     initialPageParam: 0,
+ *     getNextPageParam: (lastPage) => lastPage.nextId,
+ *   }))
+ * }
+ * ```
+ *
+ * @example
+ * Fetching the next page automatically as the user scrolls, using an `IntersectionObserver` on a sentinel
+ * element after the list:
+ * ```angular-ts
+ * @Component({
+ *   selector: 'projects-list',
+ *   template: `
+ *     <ul>
+ *       @for (page of projectsQuery.data()?.pages; track $index) {
+ *         @for (project of page.projects; track project.id) {
+ *           <li>{{ project.name }}</li>
+ *         }
+ *       }
+ *     </ul>
+ *     <div #sentinel>{{ projectsQuery.isFetchingNextPage() ? 'Loading more...' : '' }}</div>
+ *   `,
+ * })
+ * export class ProjectsList {
+ *   readonly sentinel = viewChild<ElementRef<HTMLElement>>('sentinel')
+ *
+ *   readonly projectsQuery = injectInfiniteQuery(() => ({
+ *     queryKey: ['projects'],
+ *     queryFn: ({ pageParam }) => fetchProjects(pageParam),
+ *     initialPageParam: 0,
+ *     getNextPageParam: (lastPage) => lastPage.nextId,
+ *   }))
+ *
+ *   constructor() {
+ *     effect((onCleanup) => {
+ *       const sentinel = this.sentinel()?.nativeElement
+ *       if (
+ *         sentinel == null ||
+ *         !this.projectsQuery.hasNextPage() ||
+ *         this.projectsQuery.isFetching()
+ *       ) {
+ *         return
+ *       }
+ *
+ *       const observer = new IntersectionObserver(([entry]) => {
+ *         if (entry?.isIntersecting) this.projectsQuery.fetchNextPage()
+ *       })
+ *       observer.observe(sentinel)
+ *
+ *       onCleanup(() => observer.disconnect())
+ *     })
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * A query that's disabled, type safe, until `postId` is set — pass `skipToken` as `queryFn` instead of
+ * setting `enabled: false`:
+ * ```angular-ts
+ * @Component({
+ *   selector: 'comments',
+ *   template: `
+ *     @if (postId() == null) {
+ *       Select a post
+ *     } @else if (commentsQuery.isPending()) {
+ *       Loading...
+ *     } @else if (commentsQuery.isError()) {
+ *       <span>Error: {{ commentsQuery.error()?.message }}</span>
+ *     } @else {
+ *       <ul>
+ *         @for (page of commentsQuery.data().pages; track $index) {
+ *           @for (comment of page.comments; track comment.id) {
+ *             <li>{{ comment.text }}</li>
+ *           }
+ *         }
+ *       </ul>
+ *     }
+ *   `,
+ * })
+ * export class Comments {
+ *   readonly postId = signal<string | undefined>(undefined)
+ *
+ *   readonly commentsQuery = injectInfiniteQuery(() => ({
+ *     queryKey: ['post', this.postId(), 'comments'],
+ *     queryFn:
+ *       this.postId() != null
+ *         ? ({ pageParam }) => fetchComments(this.postId()!, pageParam)
+ *         : skipToken,
+ *     initialPageParam: 0,
+ *     getNextPageParam: (lastPage) => lastPage.nextId,
+ *   }))
+ * }
+ * ```
  */
 export declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(injectInfiniteQueryFn: () => UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, options?: InjectInfiniteQueryOptions): CreateInfiniteQueryResult<TData, TError>;
 /**
- * Injects an infinite query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
- * Infinite queries can additively "load more" data onto an existing set of data or "infinite scroll"
- * @param injectInfiniteQueryFn - A function that returns infinite query options.
+ * This overload accepts the general {@link CreateInfiniteQueryOptions} shape rather than the
+ * `initialData`-aware overloads above, so whether `data` is defined can't be inferred from the call site —
+ * useful when wrapping `injectInfiniteQuery` in your own helper function that forwards caller-provided
+ * options.
+ *
+ * @param injectInfiniteQueryFn - A function that returns infinite query options. Similar to `computed` from
+ * Angular, this function runs in the reactive context, so signals read inside it drive the query.
  * @param options - Additional configuration.
  * @returns The infinite query result.
  */

package/inject-infinite-query.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"inject-infinite-query.mjs","sources":["../src/inject-infinite-query.ts"],"sourcesContent":["import { InfiniteQueryObserver } from '@tanstack/query-core'\nimport {\n  Injector,\n  assertInInjectionContext,\n  inject,\n  runInInjectionContext,\n} from '@angular/core'\nimport { createBaseQuery } from './create-base-query'\nimport type {\n  DefaultError,\n  InfiniteData,\n  QueryKey,\n  QueryObserver,\n} from '@tanstack/query-core'\nimport type {\n  CreateInfiniteQueryOptions,\n  CreateInfiniteQueryResult,\n  DefinedCreateInfiniteQueryResult,\n} from './types'\nimport type {\n  DefinedInitialDataInfiniteOptions,\n  UndefinedInitialDataInfiniteOptions,\n} from './infinite-query-options'\n\nexport interface InjectInfiniteQueryOptions {\n  /**\n   * The `Injector` in which to create the infinite query.\n   *\n   * If this is not provided, the current injection context will be used instead (via `inject`).\n   */\n  injector?: Injector\n}\n\n/**\n * Injects an infinite query: a declarative dependency on an asynchronous source of data that is tied to a unique key.\n * Infinite queries can additively \"load more\" data onto an existing set of data or \"infinite scroll\"\n * @param injectInfiniteQueryFn - A function that returns infinite query options.\n * @param options - Additional configuration.\n * @returns The infinite query result.\n */\nexport function injectInfiniteQuery<\n  TQueryFnData,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n>(\n  injectInfiniteQueryFn: () => DefinedInitialDataInfiniteOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >,\n  options?: InjectInfiniteQueryOptions,\n): DefinedCreateInfiniteQueryResult<TData, TError>\n\n/**\n * Injects an infinite query: a declarative dependency on an asynchronous source of data that is tied to a unique key.\n * Infinite queries can additively \"load more\" data onto an existing set of data or \"infinite scroll\"\n * @param injectInfiniteQueryFn - A function that returns infinite query options.\n * @param options - Additional configuration.\n * @returns The infinite query result.\n */\nexport function injectInfiniteQuery<\n  TQueryFnData,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n>(\n  injectInfiniteQueryFn: () => UndefinedInitialDataInfiniteOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >,\n  options?: InjectInfiniteQueryOptions,\n): CreateInfiniteQueryResult<TData, TError>\n\n/**\n * Injects an infinite query: a declarative dependency on an asynchronous source of data that is tied to a unique key.\n * Infinite queries can additively \"load more\" data onto an existing set of data or \"infinite scroll\"\n * @param injectInfiniteQueryFn - A function that returns infinite query options.\n * @param options - Additional configuration.\n * @returns The infinite query result.\n */\nexport function injectInfiniteQuery<\n  TQueryFnData,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n>(\n  injectInfiniteQueryFn: () => CreateInfiniteQueryOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >,\n  options?: InjectInfiniteQueryOptions,\n): CreateInfiniteQueryResult<TData, TError>\n\n/**\n * Injects an infinite query: a declarative dependency on an asynchronous source of data that is tied to a unique key.\n * Infinite queries can additively \"load more\" data onto an existing set of data or \"infinite scroll\"\n * @param injectInfiniteQueryFn - A function that returns infinite query options.\n * @param options - Additional configuration.\n * @returns The infinite query result.\n */\nexport function injectInfiniteQuery(\n  injectInfiniteQueryFn: () => CreateInfiniteQueryOptions,\n  options?: InjectInfiniteQueryOptions,\n) {\n  !options?.injector && assertInInjectionContext(injectInfiniteQuery)\n  const injector = options?.injector ?? inject(Injector)\n  return runInInjectionContext(injector, () =>\n    createBaseQuery(\n      injectInfiniteQueryFn,\n      InfiniteQueryObserver as typeof QueryObserver,\n    ),\n  )\n}\n"],"names":[],"mappings":";;;AAgHO,SAAS,oBACd,uBACA,SACA;AACA,IAAC,mCAAS,aAAY,yBAAyB,mBAAmB;AAClE,QAAM,YAAW,mCAAS,aAAY,OAAO,QAAQ;AACrD,SAAO;AAAA,IAAsB;AAAA,IAAU,MACrC;AAAA,MACE;AAAA,MACA;AAAA,IAAA;AAAA,EACF;AAEJ;"}
+{"version":3,"file":"inject-infinite-query.mjs","sources":["../src/inject-infinite-query.ts"],"sourcesContent":["import { InfiniteQueryObserver } from '@tanstack/query-core'\nimport {\n  Injector,\n  assertInInjectionContext,\n  inject,\n  runInInjectionContext,\n} from '@angular/core'\nimport { createBaseQuery } from './create-base-query'\nimport type {\n  DefaultError,\n  InfiniteData,\n  QueryKey,\n  QueryObserver,\n} from '@tanstack/query-core'\nimport type {\n  CreateInfiniteQueryOptions,\n  CreateInfiniteQueryResult,\n  DefinedCreateInfiniteQueryResult,\n} from './types'\nimport type {\n  DefinedInitialDataInfiniteOptions,\n  UndefinedInitialDataInfiniteOptions,\n} from './infinite-query-options'\n\nexport interface InjectInfiniteQueryOptions {\n  /**\n   * The `Injector` in which to create the infinite query.\n   *\n   * If this is not provided, the current injection context will be used instead (via `inject`).\n   */\n  injector?: Injector\n}\n\n/**\n * The options for `injectInfiniteQuery` are identical to `injectQuery`, with the addition of\n * `initialPageParam`, `getNextPageParam`, `getPreviousPageParam`, and `maxPages`. Infinite queries can\n * additively \"load more\" data onto an existing set of data, or \"infinite scroll\".\n *\n * This overload is selected when `initialData` is set on the options returned by `injectInfiniteQueryFn`,\n * so the resulting `data` signal is never `undefined` (unless a `select` changes `TData` to include `undefined`).\n *\n * @remarks Keep in mind that imperative fetch calls, such as `fetchNextPage`, may interfere with the default\n * refetch behavior, resulting in outdated data. Make sure to call these functions only in response to user\n * actions, or add conditions like `hasNextPage() && !isFetching()`.\n * @see {@link infiniteQueryOptions} to share these options between `injectInfiniteQuery` and imperative APIs\n * like `queryClient.fetchInfiniteQuery`.\n * @param injectInfiniteQueryFn - A function returning the {@link DefinedInitialDataInfiniteOptions} to use —\n * everything you can pass to `injectInfiniteQuery`, with `initialData` set. Similar to `computed` from\n * Angular, this function runs in the reactive context, so signals read inside it drive the query.\n * @param options - Additional configuration.\n * @returns The same signals as `injectQuery`, with the addition of `fetchNextPage`, `fetchPreviousPage`,\n * `hasNextPage`, `hasPreviousPage`, `isFetchingNextPage`, and `isFetchingPreviousPage`. `data().pages` and\n * `data().pageParams` are also added, as long as a `select` doesn't change `TData` away from its default\n * `InfiniteData<TQueryFnData>` shape.\n *\n * @example\n * ```angular-ts\n * @Component({\n *   selector: 'projects',\n *   template: `\n *     <!-- `projectsQuery.data()` is never `undefined`, thanks to `initialData` — even if a\n *     refetch fails, so the list stays visible alongside the error. -->\n *     <ul>\n *       @for (page of projectsQuery.data().pages; track $index) {\n *         @for (project of page.projects; track project.id) {\n *           <li>{{ project.name }}</li>\n *         }\n *       }\n *     </ul>\n *   `,\n * })\n * export class Projects {\n *   readonly projectsQuery = injectInfiniteQuery(() => ({\n *     queryKey: ['projects'],\n *     queryFn: ({ pageParam }) => fetchProjects(pageParam),\n *     initialPageParam: 0,\n *     getNextPageParam: (lastPage) => lastPage.nextId,\n *     initialData: { pages: [], pageParams: [] },\n *   }))\n * }\n * ```\n */\nexport function injectInfiniteQuery<\n  TQueryFnData,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n>(\n  injectInfiniteQueryFn: () => DefinedInitialDataInfiniteOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >,\n  options?: InjectInfiniteQueryOptions,\n): DefinedCreateInfiniteQueryResult<TData, TError>\n\n/**\n * Injects an infinite query: a declarative dependency on an asynchronous source of data that is tied to a\n * unique key. Infinite queries can additively \"load more\" data onto an existing set of data, or\n * \"infinite scroll\".\n *\n * @remarks Keep in mind that imperative fetch calls, such as `fetchNextPage`, may interfere with the default\n * refetch behavior, resulting in outdated data. Make sure to call these functions only in response to user\n * actions, or add conditions like `hasNextPage() && !isFetching()`. This is the only overload that accepts\n * `queryFn: skipToken`, shown below.\n * @see {@link infiniteQueryOptions} to share these options between `injectInfiniteQuery` and imperative APIs\n * like `queryClient.fetchInfiniteQuery`.\n * @param injectInfiniteQueryFn - A function returning the {@link UndefinedInitialDataInfiniteOptions} to use\n * — everything you can pass to `injectInfiniteQuery`. Similar to `computed` from Angular, this function runs\n * in the reactive context, so signals read inside it drive the query.\n * @param options - Additional configuration.\n * @returns The same signals as `injectQuery`, with the addition of `fetchNextPage`, `fetchPreviousPage`,\n * `hasNextPage`, `hasPreviousPage`, `isFetchingNextPage`, and `isFetchingPreviousPage`. `data().pages` and\n * `data().pageParams` are also added, as long as a `select` doesn't change `TData` away from its default\n * `InfiniteData<TQueryFnData>` shape.\n *\n * @example\n * Fetching the next page from a button click:\n * ```angular-ts\n * @Component({\n *   selector: 'projects-list',\n *   template: `\n *     <ul>\n *       @for (page of projectsQuery.data()?.pages; track $index) {\n *         @for (project of page.projects; track project.id) {\n *           <li>{{ project.name }}</li>\n *         }\n *       }\n *     </ul>\n *     <button\n *       [disabled]=\"!projectsQuery.hasNextPage() || projectsQuery.isFetching()\"\n *       (click)=\"projectsQuery.fetchNextPage()\"\n *     >\n *       Load More\n *     </button>\n *   `,\n * })\n * export class ProjectsList {\n *   readonly projectsQuery = injectInfiniteQuery(() => ({\n *     queryKey: ['projects'],\n *     queryFn: ({ pageParam }) => fetchProjects(pageParam),\n *     initialPageParam: 0,\n *     getNextPageParam: (lastPage) => lastPage.nextId,\n *   }))\n * }\n * ```\n *\n * @example\n * Fetching the next page automatically as the user scrolls, using an `IntersectionObserver` on a sentinel\n * element after the list:\n * ```angular-ts\n * @Component({\n *   selector: 'projects-list',\n *   template: `\n *     <ul>\n *       @for (page of projectsQuery.data()?.pages; track $index) {\n *         @for (project of page.projects; track project.id) {\n *           <li>{{ project.name }}</li>\n *         }\n *       }\n *     </ul>\n *     <div #sentinel>{{ projectsQuery.isFetchingNextPage() ? 'Loading more...' : '' }}</div>\n *   `,\n * })\n * export class ProjectsList {\n *   readonly sentinel = viewChild<ElementRef<HTMLElement>>('sentinel')\n *\n *   readonly projectsQuery = injectInfiniteQuery(() => ({\n *     queryKey: ['projects'],\n *     queryFn: ({ pageParam }) => fetchProjects(pageParam),\n *     initialPageParam: 0,\n *     getNextPageParam: (lastPage) => lastPage.nextId,\n *   }))\n *\n *   constructor() {\n *     effect((onCleanup) => {\n *       const sentinel = this.sentinel()?.nativeElement\n *       if (\n *         sentinel == null ||\n *         !this.projectsQuery.hasNextPage() ||\n *         this.projectsQuery.isFetching()\n *       ) {\n *         return\n *       }\n *\n *       const observer = new IntersectionObserver(([entry]) => {\n *         if (entry?.isIntersecting) this.projectsQuery.fetchNextPage()\n *       })\n *       observer.observe(sentinel)\n *\n *       onCleanup(() => observer.disconnect())\n *     })\n *   }\n * }\n * ```\n *\n * @example\n * A query that's disabled, type safe, until `postId` is set — pass `skipToken` as `queryFn` instead of\n * setting `enabled: false`:\n * ```angular-ts\n * @Component({\n *   selector: 'comments',\n *   template: `\n *     @if (postId() == null) {\n *       Select a post\n *     } @else if (commentsQuery.isPending()) {\n *       Loading...\n *     } @else if (commentsQuery.isError()) {\n *       <span>Error: {{ commentsQuery.error()?.message }}</span>\n *     } @else {\n *       <ul>\n *         @for (page of commentsQuery.data().pages; track $index) {\n *           @for (comment of page.comments; track comment.id) {\n *             <li>{{ comment.text }}</li>\n *           }\n *         }\n *       </ul>\n *     }\n *   `,\n * })\n * export class Comments {\n *   readonly postId = signal<string | undefined>(undefined)\n *\n *   readonly commentsQuery = injectInfiniteQuery(() => ({\n *     queryKey: ['post', this.postId(), 'comments'],\n *     queryFn:\n *       this.postId() != null\n *         ? ({ pageParam }) => fetchComments(this.postId()!, pageParam)\n *         : skipToken,\n *     initialPageParam: 0,\n *     getNextPageParam: (lastPage) => lastPage.nextId,\n *   }))\n * }\n * ```\n */\nexport function injectInfiniteQuery<\n  TQueryFnData,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n>(\n  injectInfiniteQueryFn: () => UndefinedInitialDataInfiniteOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >,\n  options?: InjectInfiniteQueryOptions,\n): CreateInfiniteQueryResult<TData, TError>\n\n/**\n * This overload accepts the general {@link CreateInfiniteQueryOptions} shape rather than the\n * `initialData`-aware overloads above, so whether `data` is defined can't be inferred from the call site —\n * useful when wrapping `injectInfiniteQuery` in your own helper function that forwards caller-provided\n * options.\n *\n * @param injectInfiniteQueryFn - A function that returns infinite query options. Similar to `computed` from\n * Angular, this function runs in the reactive context, so signals read inside it drive the query.\n * @param options - Additional configuration.\n * @returns The infinite query result.\n */\nexport function injectInfiniteQuery<\n  TQueryFnData,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n>(\n  injectInfiniteQueryFn: () => CreateInfiniteQueryOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >,\n  options?: InjectInfiniteQueryOptions,\n): CreateInfiniteQueryResult<TData, TError>\n\nexport function injectInfiniteQuery(\n  injectInfiniteQueryFn: () => CreateInfiniteQueryOptions,\n  options?: InjectInfiniteQueryOptions,\n) {\n  !options?.injector && assertInInjectionContext(injectInfiniteQuery)\n  const injector = options?.injector ?? inject(Injector)\n  return runInInjectionContext(injector, () =>\n    createBaseQuery(\n      injectInfiniteQueryFn,\n      InfiniteQueryObserver as typeof QueryObserver,\n    ),\n  )\n}\n"],"names":[],"mappings":";;;AA2RO,SAAS,oBACd,uBACA,SACA;AACA,IAAC,mCAAS,aAAY,yBAAyB,mBAAmB;AAClE,QAAM,YAAW,mCAAS,aAAY,OAAO,QAAQ;AACrD,SAAO;AAAA,IAAsB;AAAA,IAAU,MACrC;AAAA,MACE;AAAA,MACA;AAAA,IAAA;AAAA,EACF;AAEJ;"}

package/inject-is-fetching.d.ts

@@ -9,12 +9,44 @@ export interface InjectIsFetchingOptions {
     injector?: Injector;
 }
 /**
- * Injects a signal that tracks the number of queries that your application is loading or
- * fetching in the background.
+ * Injects a signal that tracks the number of queries that your application is loading or fetching in the
+ * background (useful for app-wide loading indicators).
  *
- * Can be used for app-wide loading indicators
- * @param filters - The filters to apply to the query.
+ * @param filters - The {@link QueryFilters} to narrow down the matched queries.
  * @param options - Additional configuration
- * @returns signal with number of loading or fetching queries.
+ * @returns A `Signal` with the number of queries that your application is currently loading or fetching in
+ * the background.
+ *
+ * @example
+ * ```angular-ts
+ * @Component({
+ *   selector: 'posts-fetching-indicator',
+ *   template: `
+ *     @if (isFetchingPosts()) {
+ *       <span>Refreshing posts...</span>
+ *     }
+ *   `,
+ * })
+ * export class PostsFetchingIndicator {
+ *   // How many queries matching the posts prefix are fetching?
+ *   readonly isFetchingPosts = injectIsFetching({ queryKey: ['posts'] })
+ * }
+ * ```
+ *
+ * @example
+ * A global loading indicator for any query fetching in the background, not just the ones on screen:
+ * ```angular-ts
+ * @Component({
+ *   selector: 'global-loading-indicator',
+ *   template: `
+ *     @if (isFetching()) {
+ *       <div>Queries are fetching in the background...</div>
+ *     }
+ *   `,
+ * })
+ * export class GlobalLoadingIndicator {
+ *   readonly isFetching = injectIsFetching()
+ * }
+ * ```
  */
 export declare function injectIsFetching(filters?: QueryFilters, options?: InjectIsFetchingOptions): Signal<number>;

package/inject-is-fetching.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"inject-is-fetching.mjs","sources":["../src/inject-is-fetching.ts"],"sourcesContent":["import {\n  DestroyRef,\n  Injector,\n  NgZone,\n  assertInInjectionContext,\n  inject,\n  signal,\n} from '@angular/core'\nimport { QueryClient, notifyManager } from '@tanstack/query-core'\nimport type { QueryFilters } from '@tanstack/query-core'\nimport type { Signal } from '@angular/core'\n\nexport interface InjectIsFetchingOptions {\n  /**\n   * The `Injector` in which to create the isFetching signal.\n   *\n   * If this is not provided, the current injection context will be used instead (via `inject`).\n   */\n  injector?: Injector\n}\n\n/**\n * Injects a signal that tracks the number of queries that your application is loading or\n * fetching in the background.\n *\n * Can be used for app-wide loading indicators\n * @param filters - The filters to apply to the query.\n * @param options - Additional configuration\n * @returns signal with number of loading or fetching queries.\n */\nexport function injectIsFetching(\n  filters?: QueryFilters,\n  options?: InjectIsFetchingOptions,\n): Signal<number> {\n  !options?.injector && assertInInjectionContext(injectIsFetching)\n  const injector = options?.injector ?? inject(Injector)\n  const destroyRef = injector.get(DestroyRef)\n  const ngZone = injector.get(NgZone)\n  const queryClient = injector.get(QueryClient)\n\n  const cache = queryClient.getQueryCache()\n  // isFetching is the prev value initialized on mount *\n  let isFetching = queryClient.isFetching(filters)\n\n  const result = signal(isFetching)\n\n  const unsubscribe = ngZone.runOutsideAngular(() =>\n    cache.subscribe(\n      notifyManager.batchCalls(() => {\n        const newIsFetching = queryClient.isFetching(filters)\n        if (isFetching !== newIsFetching) {\n          // * and update with each change\n          isFetching = newIsFetching\n          ngZone.run(() => {\n            result.set(isFetching)\n          })\n        }\n      }),\n    ),\n  )\n\n  destroyRef.onDestroy(unsubscribe)\n\n  return result\n}\n"],"names":[],"mappings":";;AA8BO,SAAS,iBACd,SACA,SACgB;AAChB,IAAC,mCAAS,aAAY,yBAAyB,gBAAgB;AAC/D,QAAM,YAAW,mCAAS,aAAY,OAAO,QAAQ;AACrD,QAAM,aAAa,SAAS,IAAI,UAAU;AAC1C,QAAM,SAAS,SAAS,IAAI,MAAM;AAClC,QAAM,cAAc,SAAS,IAAI,WAAW;AAE5C,QAAM,QAAQ,YAAY,cAAA;AAE1B,MAAI,aAAa,YAAY,WAAW,OAAO;AAE/C,QAAM,SAAS,OAAO,UAAU;AAEhC,QAAM,cAAc,OAAO;AAAA,IAAkB,MAC3C,MAAM;AAAA,MACJ,cAAc,WAAW,MAAM;AAC7B,cAAM,gBAAgB,YAAY,WAAW,OAAO;AACpD,YAAI,eAAe,eAAe;AAEhC,uBAAa;AACb,iBAAO,IAAI,MAAM;AACf,mBAAO,IAAI,UAAU;AAAA,UACvB,CAAC;AAAA,QACH;AAAA,MACF,CAAC;AAAA,IAAA;AAAA,EACH;AAGF,aAAW,UAAU,WAAW;AAEhC,SAAO;AACT;"}
+{"version":3,"file":"inject-is-fetching.mjs","sources":["../src/inject-is-fetching.ts"],"sourcesContent":["import {\n  DestroyRef,\n  Injector,\n  NgZone,\n  assertInInjectionContext,\n  inject,\n  signal,\n} from '@angular/core'\nimport { QueryClient, notifyManager } from '@tanstack/query-core'\nimport type { QueryFilters } from '@tanstack/query-core'\nimport type { Signal } from '@angular/core'\n\nexport interface InjectIsFetchingOptions {\n  /**\n   * The `Injector` in which to create the isFetching signal.\n   *\n   * If this is not provided, the current injection context will be used instead (via `inject`).\n   */\n  injector?: Injector\n}\n\n/**\n * Injects a signal that tracks the number of queries that your application is loading or fetching in the\n * background (useful for app-wide loading indicators).\n *\n * @param filters - The {@link QueryFilters} to narrow down the matched queries.\n * @param options - Additional configuration\n * @returns A `Signal` with the number of queries that your application is currently loading or fetching in\n * the background.\n *\n * @example\n * ```angular-ts\n * @Component({\n *   selector: 'posts-fetching-indicator',\n *   template: `\n *     @if (isFetchingPosts()) {\n *       <span>Refreshing posts...</span>\n *     }\n *   `,\n * })\n * export class PostsFetchingIndicator {\n *   // How many queries matching the posts prefix are fetching?\n *   readonly isFetchingPosts = injectIsFetching({ queryKey: ['posts'] })\n * }\n * ```\n *\n * @example\n * A global loading indicator for any query fetching in the background, not just the ones on screen:\n * ```angular-ts\n * @Component({\n *   selector: 'global-loading-indicator',\n *   template: `\n *     @if (isFetching()) {\n *       <div>Queries are fetching in the background...</div>\n *     }\n *   `,\n * })\n * export class GlobalLoadingIndicator {\n *   readonly isFetching = injectIsFetching()\n * }\n * ```\n */\nexport function injectIsFetching(\n  filters?: QueryFilters,\n  options?: InjectIsFetchingOptions,\n): Signal<number> {\n  !options?.injector && assertInInjectionContext(injectIsFetching)\n  const injector = options?.injector ?? inject(Injector)\n  const destroyRef = injector.get(DestroyRef)\n  const ngZone = injector.get(NgZone)\n  const queryClient = injector.get(QueryClient)\n\n  const cache = queryClient.getQueryCache()\n  // isFetching is the prev value initialized on mount *\n  let isFetching = queryClient.isFetching(filters)\n\n  const result = signal(isFetching)\n\n  const unsubscribe = ngZone.runOutsideAngular(() =>\n    cache.subscribe(\n      notifyManager.batchCalls(() => {\n        const newIsFetching = queryClient.isFetching(filters)\n        if (isFetching !== newIsFetching) {\n          // * and update with each change\n          isFetching = newIsFetching\n          ngZone.run(() => {\n            result.set(isFetching)\n          })\n        }\n      }),\n    ),\n  )\n\n  destroyRef.onDestroy(unsubscribe)\n\n  return result\n}\n"],"names":[],"mappings":";;AA8DO,SAAS,iBACd,SACA,SACgB;AAChB,IAAC,mCAAS,aAAY,yBAAyB,gBAAgB;AAC/D,QAAM,YAAW,mCAAS,aAAY,OAAO,QAAQ;AACrD,QAAM,aAAa,SAAS,IAAI,UAAU;AAC1C,QAAM,SAAS,SAAS,IAAI,MAAM;AAClC,QAAM,cAAc,SAAS,IAAI,WAAW;AAE5C,QAAM,QAAQ,YAAY,cAAA;AAE1B,MAAI,aAAa,YAAY,WAAW,OAAO;AAE/C,QAAM,SAAS,OAAO,UAAU;AAEhC,QAAM,cAAc,OAAO;AAAA,IAAkB,MAC3C,MAAM;AAAA,MACJ,cAAc,WAAW,MAAM;AAC7B,cAAM,gBAAgB,YAAY,WAAW,OAAO;AACpD,YAAI,eAAe,eAAe;AAEhC,uBAAa;AACb,iBAAO,IAAI,MAAM;AACf,mBAAO,IAAI,UAAU;AAAA,UACvB,CAAC;AAAA,QACH;AAAA,MACF,CAAC;AAAA,IAAA;AAAA,EACH;AAGF,aAAW,UAAU,WAAW;AAEhC,SAAO;AACT;"}

package/inject-is-mutating.d.ts

@@ -9,11 +9,27 @@ export interface InjectIsMutatingOptions {
     injector?: Injector;
 }
 /**
- * Injects a signal that tracks the number of mutations that your application is fetching.
+ * Injects a signal that tracks the number of mutations that your application currently has `pending`
+ * (useful for app-wide loading indicators).
  *
- * Can be used for app-wide loading indicators
- * @param filters - The filters to apply to the query.
+ * @param filters - The {@link MutationFilters} to narrow down the matched mutations.
  * @param options - Additional configuration
- * @returns A read-only signal with the number of fetching mutations.
+ * @returns A `Signal` with the number of mutations that your application currently has `pending`.
+ *
+ * @example
+ * ```angular-ts
+ * @Component({
+ *   selector: 'posts-mutating-indicator',
+ *   template: `
+ *     @if (isMutatingPosts()) {
+ *       <span>Saving posts...</span>
+ *     }
+ *   `,
+ * })
+ * export class PostsMutatingIndicator {
+ *   // How many mutations matching the posts prefix are in progress?
+ *   readonly isMutatingPosts = injectIsMutating({ mutationKey: ['posts'] })
+ * }
+ * ```
  */
 export declare function injectIsMutating(filters?: MutationFilters, options?: InjectIsMutatingOptions): Signal<number>;