@tanstack/angular-query-experimental 5.102.8 → 5.103.1

package/inject-query.d.ts

@@ -11,113 +11,131 @@ export interface InjectQueryOptions {
     injector?: Injector;
 }
 /**
- * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
- *
- * **Basic example**
- * ```ts
- * class ServiceOrComponent {
- *   query = injectQuery(() => ({
- *     queryKey: ['repoData'],
- *     queryFn: () =>
- *       this.#http.get<Response>('https://api.github.com/repos/tanstack/query'),
- *   }))
- * }
- * ```
+ * This overload is selected when `initialData` is set on the options returned by `injectQueryFn`, so the
+ * resulting `data` signal is never `undefined` (unless a `select` changes `TData` to include `undefined`).
  *
- * Similar to `computed` from Angular, the function passed to `injectQuery` will be run in the reactive context.
- * In the example below, the query will be automatically enabled and executed when the filter signal changes
- * to a truthy value. When the filter signal changes back to a falsy value, the query will be disabled.
- *
- * **Reactive example**
- * ```ts
- * class ServiceOrComponent {
- *   filter = signal('')
+ * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
+ * @see {@link queryOptions} to share these options between `injectQuery` and imperative APIs like
+ * `queryClient.fetchQuery`.
+ * @param injectQueryFn - A function returning the {@link DefinedInitialDataOptions} to use — everything you
+ * can pass to `injectQuery`, with `initialData` set. Similar to `computed` from Angular, this function runs
+ * in the reactive context, so signals read inside it (in `queryKey`, `enabled`, etc.) drive the query.
+ * @param options - Additional configuration
+ * @returns The query result, typed so that `data` is never `undefined` (unless a `select` changes `TData` to
+ * include `undefined`).
  *
- *   todosQuery = injectQuery(() => ({
- *     queryKey: ['todos', this.filter()],
- *     queryFn: () => fetchTodos(this.filter()),
- *     // Signals can be combined with expressions
- *     enabled: !!this.filter(),
+ * @example
+ * ```angular-ts
+ * @Component({
+ *   selector: 'posts',
+ *   template: `
+ *     <!-- `postsQuery.data()` is `Post[]`, never `undefined`, thanks to `initialData` — even if a
+ *     refetch fails, so the list stays visible alongside the error. -->
+ *     @if (postsQuery.isError()) {
+ *       <span>Error: {{ postsQuery.error()?.message }}</span>
+ *     }
+ *     <ul>
+ *       @for (post of postsQuery.data(); track post.id) {
+ *         <li>{{ post.title }}</li>
+ *       }
+ *     </ul>
+ *   `,
+ * })
+ * export class Posts {
+ *   readonly postsQuery = injectQuery(() => ({
+ *     queryKey: ['posts'],
+ *     queryFn: fetchPosts,
+ *     initialData: [],
  *   }))
  * }
  * ```
- * @param injectQueryFn - A function that returns query options.
- * @param options - Additional configuration
- * @returns The query result.
- * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
  */
 export declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(injectQueryFn: () => DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, options?: InjectQueryOptions): DefinedCreateQueryResult<TData, TError>;
 /**
  * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
  *
- * **Basic example**
- * ```ts
- * class ServiceOrComponent {
- *   query = injectQuery(() => ({
- *     queryKey: ['repoData'],
- *     queryFn: () =>
- *       this.#http.get<Response>('https://api.github.com/repos/tanstack/query'),
+ * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
+ * @see {@link queryOptions} to share these options between `injectQuery` and imperative APIs like
+ * `queryClient.fetchQuery`.
+ * @param injectQueryFn - A function returning the {@link UndefinedInitialDataOptions} to use — everything
+ * you can pass to `injectQuery`. Similar to `computed` from Angular, this function runs in the reactive
+ * context, so signals read inside it (in `queryKey`, `enabled`, etc.) drive the query.
+ * @param options - Additional configuration
+ * @returns The query result. `status()` is `'pending'` if there is no cached data to display, `'error'` if
+ * the last fetch attempt failed, or `'success'` if the query has data to display. `isPending`/`isSuccess`/
+ * `isError` are type-guard methods for convenience.
+ *
+ * @example
+ * ```angular-ts
+ * @Component({
+ *   selector: 'posts',
+ *   template: `
+ *     @if (postsQuery.isPending()) {
+ *       Loading...
+ *     } @else if (postsQuery.isError()) {
+ *       <span>Error: {{ postsQuery.error()?.message }}</span>
+ *     } @else {
+ *       <ul>
+ *         @for (post of postsQuery.data(); track post.id) {
+ *           <li>{{ post.title }}</li>
+ *         }
+ *       </ul>
+ *     }
+ *   `,
+ * })
+ * export class Posts {
+ *   readonly postsQuery = injectQuery(() => ({
+ *     queryKey: ['posts'],
+ *     queryFn: fetchPosts,
  *   }))
  * }
  * ```
  *
- * Similar to `computed` from Angular, the function passed to `injectQuery` will be run in the reactive context.
- * In the example below, the query will be automatically enabled and executed when the filter signal changes
- * to a truthy value. When the filter signal changes back to a falsy value, the query will be disabled.
- *
- * **Reactive example**
- * ```ts
- * class ServiceOrComponent {
- *   filter = signal('')
+ * @example
+ * Similar to `computed` from Angular, the function passed to `injectQuery` runs in the reactive context. In
+ * the example below, the query is automatically enabled and executed when the filter signal changes to a
+ * truthy value. When the filter signal changes back to a falsy value, the query is disabled.
+ * ```angular-ts
+ * @Component({
+ *   selector: 'posts',
+ *   template: `
+ *     <input [ngModel]="filter()" (ngModelChange)="filter.set($event)" />
+ *     @if (postsQuery.isPending()) {
+ *       Loading...
+ *     } @else if (postsQuery.isError()) {
+ *       <span>Error: {{ postsQuery.error()?.message }}</span>
+ *     } @else {
+ *       <ul>
+ *         @for (post of postsQuery.data(); track post.id) {
+ *           <li>{{ post.title }}</li>
+ *         }
+ *       </ul>
+ *     }
+ *   `,
+ * })
+ * export class Posts {
+ *   readonly filter = signal('')
  *
- *   todosQuery = injectQuery(() => ({
- *     queryKey: ['todos', this.filter()],
- *     queryFn: () => fetchTodos(this.filter()),
+ *   readonly postsQuery = injectQuery(() => ({
+ *     queryKey: ['posts', this.filter()],
+ *     queryFn: () => fetchPosts(this.filter()),
  *     // Signals can be combined with expressions
  *     enabled: !!this.filter(),
  *   }))
  * }
  * ```
- * @param injectQueryFn - A function that returns query options.
- * @param options - Additional configuration
- * @returns The query result.
- * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
  */
 export declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(injectQueryFn: () => UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, options?: InjectQueryOptions): CreateQueryResult<TData, TError>;
 /**
- * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
- *
- * **Basic example**
- * ```ts
- * class ServiceOrComponent {
- *   query = injectQuery(() => ({
- *     queryKey: ['repoData'],
- *     queryFn: () =>
- *       this.#http.get<Response>('https://api.github.com/repos/tanstack/query'),
- *   }))
- * }
- * ```
- *
- * Similar to `computed` from Angular, the function passed to `injectQuery` will be run in the reactive context.
- * In the example below, the query will be automatically enabled and executed when the filter signal changes
- * to a truthy value. When the filter signal changes back to a falsy value, the query will be disabled.
+ * This overload accepts the general {@link CreateQueryOptions} shape rather than the `initialData`-aware
+ * overloads above, so whether `data` is defined can't be inferred from the call site — useful when wrapping
+ * `injectQuery` in your own helper function that forwards caller-provided options.
  *
- * **Reactive example**
- * ```ts
- * class ServiceOrComponent {
- *   filter = signal('')
- *
- *   todosQuery = injectQuery(() => ({
- *     queryKey: ['todos', this.filter()],
- *     queryFn: () => fetchTodos(this.filter()),
- *     // Signals can be combined with expressions
- *     enabled: !!this.filter(),
- *   }))
- * }
- * ```
- * @param injectQueryFn - A function that returns query options.
+ * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
+ * @param injectQueryFn - A function that returns query options. Similar to `computed` from Angular, this
+ * function runs in the reactive context, so signals read inside it (in `queryKey`, `enabled`, etc.) drive
+ * the query.
  * @param options - Additional configuration
  * @returns The query result.
- * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
  */
 export declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(injectQueryFn: () => CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, options?: InjectQueryOptions): CreateQueryResult<TData, TError>;

package/inject-query.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"inject-query.mjs","sources":["../src/inject-query.ts"],"sourcesContent":["import { QueryObserver } 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 { DefaultError, QueryKey } from '@tanstack/query-core'\nimport type {\n  CreateQueryOptions,\n  CreateQueryResult,\n  DefinedCreateQueryResult,\n} from './types'\nimport type {\n  DefinedInitialDataOptions,\n  UndefinedInitialDataOptions,\n} from './query-options'\n\nexport interface InjectQueryOptions {\n  /**\n   * The `Injector` in which to create the 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 a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.\n *\n * **Basic example**\n * ```ts\n * class ServiceOrComponent {\n *   query = injectQuery(() => ({\n *     queryKey: ['repoData'],\n *     queryFn: () =>\n *       this.#http.get<Response>('https://api.github.com/repos/tanstack/query'),\n *   }))\n * }\n * ```\n *\n * Similar to `computed` from Angular, the function passed to `injectQuery` will be run in the reactive context.\n * In the example below, the query will be automatically enabled and executed when the filter signal changes\n * to a truthy value. When the filter signal changes back to a falsy value, the query will be disabled.\n *\n * **Reactive example**\n * ```ts\n * class ServiceOrComponent {\n *   filter = signal('')\n *\n *   todosQuery = injectQuery(() => ({\n *     queryKey: ['todos', this.filter()],\n *     queryFn: () => fetchTodos(this.filter()),\n *     // Signals can be combined with expressions\n *     enabled: !!this.filter(),\n *   }))\n * }\n * ```\n * @param injectQueryFn - A function that returns query options.\n * @param options - Additional configuration\n * @returns The query result.\n * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries\n */\nexport function injectQuery<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  injectQueryFn: () => DefinedInitialDataOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey\n  >,\n  options?: InjectQueryOptions,\n): DefinedCreateQueryResult<TData, TError>\n\n/**\n * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.\n *\n * **Basic example**\n * ```ts\n * class ServiceOrComponent {\n *   query = injectQuery(() => ({\n *     queryKey: ['repoData'],\n *     queryFn: () =>\n *       this.#http.get<Response>('https://api.github.com/repos/tanstack/query'),\n *   }))\n * }\n * ```\n *\n * Similar to `computed` from Angular, the function passed to `injectQuery` will be run in the reactive context.\n * In the example below, the query will be automatically enabled and executed when the filter signal changes\n * to a truthy value. When the filter signal changes back to a falsy value, the query will be disabled.\n *\n * **Reactive example**\n * ```ts\n * class ServiceOrComponent {\n *   filter = signal('')\n *\n *   todosQuery = injectQuery(() => ({\n *     queryKey: ['todos', this.filter()],\n *     queryFn: () => fetchTodos(this.filter()),\n *     // Signals can be combined with expressions\n *     enabled: !!this.filter(),\n *   }))\n * }\n * ```\n * @param injectQueryFn - A function that returns query options.\n * @param options - Additional configuration\n * @returns The query result.\n * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries\n */\nexport function injectQuery<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  injectQueryFn: () => UndefinedInitialDataOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey\n  >,\n  options?: InjectQueryOptions,\n): CreateQueryResult<TData, TError>\n\n/**\n * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.\n *\n * **Basic example**\n * ```ts\n * class ServiceOrComponent {\n *   query = injectQuery(() => ({\n *     queryKey: ['repoData'],\n *     queryFn: () =>\n *       this.#http.get<Response>('https://api.github.com/repos/tanstack/query'),\n *   }))\n * }\n * ```\n *\n * Similar to `computed` from Angular, the function passed to `injectQuery` will be run in the reactive context.\n * In the example below, the query will be automatically enabled and executed when the filter signal changes\n * to a truthy value. When the filter signal changes back to a falsy value, the query will be disabled.\n *\n * **Reactive example**\n * ```ts\n * class ServiceOrComponent {\n *   filter = signal('')\n *\n *   todosQuery = injectQuery(() => ({\n *     queryKey: ['todos', this.filter()],\n *     queryFn: () => fetchTodos(this.filter()),\n *     // Signals can be combined with expressions\n *     enabled: !!this.filter(),\n *   }))\n * }\n * ```\n * @param injectQueryFn - A function that returns query options.\n * @param options - Additional configuration\n * @returns The query result.\n * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries\n */\nexport function injectQuery<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  injectQueryFn: () => CreateQueryOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey\n  >,\n  options?: InjectQueryOptions,\n): CreateQueryResult<TData, TError>\n\n/**\n * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.\n *\n * **Basic example**\n * ```ts\n * class ServiceOrComponent {\n *   query = injectQuery(() => ({\n *     queryKey: ['repoData'],\n *     queryFn: () =>\n *       this.#http.get<Response>('https://api.github.com/repos/tanstack/query'),\n *   }))\n * }\n * ```\n *\n * Similar to `computed` from Angular, the function passed to `injectQuery` will be run in the reactive context.\n * In the example below, the query will be automatically enabled and executed when the filter signal changes\n * to a truthy value. When the filter signal changes back to a falsy value, the query will be disabled.\n *\n * **Reactive example**\n * ```ts\n * class ServiceOrComponent {\n *   filter = signal('')\n *\n *   todosQuery = injectQuery(() => ({\n *     queryKey: ['todos', this.filter()],\n *     queryFn: () => fetchTodos(this.filter()),\n *     // Signals can be combined with expressions\n *     enabled: !!this.filter(),\n *   }))\n * }\n * ```\n * @param injectQueryFn - A function that returns query options.\n * @param options - Additional configuration\n * @returns The query result.\n * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries\n */\nexport function injectQuery(\n  injectQueryFn: () => CreateQueryOptions,\n  options?: InjectQueryOptions,\n) {\n  !options?.injector && assertInInjectionContext(injectQuery)\n  return runInInjectionContext(options?.injector ?? inject(Injector), () =>\n    createBaseQuery(injectQueryFn, QueryObserver),\n  ) as unknown as CreateQueryResult\n}\n"],"names":[],"mappings":";;;AAyNO,SAAS,YACd,eACA,SACA;AACA,IAAC,mCAAS,aAAY,yBAAyB,WAAW;AAC1D,SAAO;AAAA,KAAsB,mCAAS,aAAY,OAAO,QAAQ;AAAA,IAAG,MAClE,gBAAgB,eAAe,aAAa;AAAA,EAAA;AAEhD;"}
+{"version":3,"file":"inject-query.mjs","sources":["../src/inject-query.ts"],"sourcesContent":["import { QueryObserver } 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 { DefaultError, QueryKey } from '@tanstack/query-core'\nimport type {\n  CreateQueryOptions,\n  CreateQueryResult,\n  DefinedCreateQueryResult,\n} from './types'\nimport type {\n  DefinedInitialDataOptions,\n  UndefinedInitialDataOptions,\n} from './query-options'\n\nexport interface InjectQueryOptions {\n  /**\n   * The `Injector` in which to create the 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 * This overload is selected when `initialData` is set on the options returned by `injectQueryFn`, so the\n * resulting `data` signal is never `undefined` (unless a `select` changes `TData` to include `undefined`).\n *\n * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries\n * @see {@link queryOptions} to share these options between `injectQuery` and imperative APIs like\n * `queryClient.fetchQuery`.\n * @param injectQueryFn - A function returning the {@link DefinedInitialDataOptions} to use — everything you\n * can pass to `injectQuery`, with `initialData` set. Similar to `computed` from Angular, this function runs\n * in the reactive context, so signals read inside it (in `queryKey`, `enabled`, etc.) drive the query.\n * @param options - Additional configuration\n * @returns The query result, typed so that `data` is never `undefined` (unless a `select` changes `TData` to\n * include `undefined`).\n *\n * @example\n * ```angular-ts\n * @Component({\n *   selector: 'posts',\n *   template: `\n *     <!-- `postsQuery.data()` is `Post[]`, never `undefined`, thanks to `initialData` — even if a\n *     refetch fails, so the list stays visible alongside the error. -->\n *     @if (postsQuery.isError()) {\n *       <span>Error: {{ postsQuery.error()?.message }}</span>\n *     }\n *     <ul>\n *       @for (post of postsQuery.data(); track post.id) {\n *         <li>{{ post.title }}</li>\n *       }\n *     </ul>\n *   `,\n * })\n * export class Posts {\n *   readonly postsQuery = injectQuery(() => ({\n *     queryKey: ['posts'],\n *     queryFn: fetchPosts,\n *     initialData: [],\n *   }))\n * }\n * ```\n */\nexport function injectQuery<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  injectQueryFn: () => DefinedInitialDataOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey\n  >,\n  options?: InjectQueryOptions,\n): DefinedCreateQueryResult<TData, TError>\n\n/**\n * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.\n *\n * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries\n * @see {@link queryOptions} to share these options between `injectQuery` and imperative APIs like\n * `queryClient.fetchQuery`.\n * @param injectQueryFn - A function returning the {@link UndefinedInitialDataOptions} to use — everything\n * you can pass to `injectQuery`. Similar to `computed` from Angular, this function runs in the reactive\n * context, so signals read inside it (in `queryKey`, `enabled`, etc.) drive the query.\n * @param options - Additional configuration\n * @returns The query result. `status()` is `'pending'` if there is no cached data to display, `'error'` if\n * the last fetch attempt failed, or `'success'` if the query has data to display. `isPending`/`isSuccess`/\n * `isError` are type-guard methods for convenience.\n *\n * @example\n * ```angular-ts\n * @Component({\n *   selector: 'posts',\n *   template: `\n *     @if (postsQuery.isPending()) {\n *       Loading...\n *     } @else if (postsQuery.isError()) {\n *       <span>Error: {{ postsQuery.error()?.message }}</span>\n *     } @else {\n *       <ul>\n *         @for (post of postsQuery.data(); track post.id) {\n *           <li>{{ post.title }}</li>\n *         }\n *       </ul>\n *     }\n *   `,\n * })\n * export class Posts {\n *   readonly postsQuery = injectQuery(() => ({\n *     queryKey: ['posts'],\n *     queryFn: fetchPosts,\n *   }))\n * }\n * ```\n *\n * @example\n * Similar to `computed` from Angular, the function passed to `injectQuery` runs in the reactive context. In\n * the example below, the query is automatically enabled and executed when the filter signal changes to a\n * truthy value. When the filter signal changes back to a falsy value, the query is disabled.\n * ```angular-ts\n * @Component({\n *   selector: 'posts',\n *   template: `\n *     <input [ngModel]=\"filter()\" (ngModelChange)=\"filter.set($event)\" />\n *     @if (postsQuery.isPending()) {\n *       Loading...\n *     } @else if (postsQuery.isError()) {\n *       <span>Error: {{ postsQuery.error()?.message }}</span>\n *     } @else {\n *       <ul>\n *         @for (post of postsQuery.data(); track post.id) {\n *           <li>{{ post.title }}</li>\n *         }\n *       </ul>\n *     }\n *   `,\n * })\n * export class Posts {\n *   readonly filter = signal('')\n *\n *   readonly postsQuery = injectQuery(() => ({\n *     queryKey: ['posts', this.filter()],\n *     queryFn: () => fetchPosts(this.filter()),\n *     // Signals can be combined with expressions\n *     enabled: !!this.filter(),\n *   }))\n * }\n * ```\n */\nexport function injectQuery<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  injectQueryFn: () => UndefinedInitialDataOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey\n  >,\n  options?: InjectQueryOptions,\n): CreateQueryResult<TData, TError>\n\n/**\n * This overload accepts the general {@link CreateQueryOptions} shape rather than the `initialData`-aware\n * overloads above, so whether `data` is defined can't be inferred from the call site — useful when wrapping\n * `injectQuery` in your own helper function that forwards caller-provided options.\n *\n * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries\n * @param injectQueryFn - A function that returns query options. Similar to `computed` from Angular, this\n * function runs in the reactive context, so signals read inside it (in `queryKey`, `enabled`, etc.) drive\n * the query.\n * @param options - Additional configuration\n * @returns The query result.\n */\nexport function injectQuery<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  injectQueryFn: () => CreateQueryOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey\n  >,\n  options?: InjectQueryOptions,\n): CreateQueryResult<TData, TError>\n\nexport function injectQuery(\n  injectQueryFn: () => CreateQueryOptions,\n  options?: InjectQueryOptions,\n) {\n  !options?.injector && assertInInjectionContext(injectQuery)\n  return runInInjectionContext(options?.injector ?? inject(Injector), () =>\n    createBaseQuery(injectQueryFn, QueryObserver),\n  ) as unknown as CreateQueryResult\n}\n"],"names":[],"mappings":";;;AAuMO,SAAS,YACd,eACA,SACA;AACA,IAAC,mCAAS,aAAY,yBAAyB,WAAW;AAC1D,SAAO;AAAA,KAAsB,mCAAS,aAAY,OAAO,QAAQ;AAAA,IAAG,MAClE,gBAAgB,eAAe,aAAa;AAAA,EAAA;AAEhD;"}

package/mutation-options.d.ts

@@ -1,39 +1,84 @@
 import { DefaultError, WithRequired } from '@tanstack/query-core';
 import { CreateMutationOptions } from './types.js';
 /**
- * Allows sharing and re-using mutation options in a type-safe way.
+ * You can generally pass everything to `mutationOptions` that you can also pass to `injectMutation`. A
+ * `mutationKey` is required on this overload so the mutation can be looked up later, e.g. with
+ * `injectMutationState`.
  *
- * **Example**
+ * @see {@link injectMutation} to run the mutation these options describe.
+ * @param options - The mutation options to use, identical to what you'd pass to `injectMutation`, with a
+ * required `mutationKey`.
+ * @returns The same options object, unchanged.
  *
- * ```ts
+ * @example
+ * Looking the mutation up elsewhere via its `mutationKey`, e.g. for a global "saving…" indicator:
+ * ```angular-ts
+ * import { mutationOptions, injectMutationState } from '@tanstack/angular-query-experimental'
+ *
+ * const createPostOptions = mutationOptions({
+ *   mutationKey: ['posts', 'create'],
+ *   mutationFn: createPost,
+ * })
+ *
+ * @Component({
+ *   selector: 'saving-indicator',
+ *   template: `
+ *     @if (isCreatingPost()) {
+ *       <span>Saving…</span>
+ *     }
+ *   `,
+ * })
+ * export class SavingIndicator {
+ *   readonly #pendingCreates = injectMutationState(() => ({
+ *     filters: { mutationKey: createPostOptions.mutationKey, status: 'pending' },
+ *   }))
+ *   readonly isCreatingPost = computed(() => this.#pendingCreates().length > 0)
+ * }
+ * ```
+ */
+export declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: WithRequired<CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): WithRequired<CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
+/**
+ * You can generally pass everything to `mutationOptions` that you can also pass to `injectMutation`. No
+ * `mutationKey` is required on this overload — use this when you don't need to target the mutation via a
+ * `mutationKey` filter later (e.g. with `injectMutationState`); it can still be observed through other
+ * filters, such as `status`.
+ *
+ * @see {@link injectMutation} to run the mutation these options describe.
+ * @param options - The mutation options to use, identical to what you'd pass to `injectMutation`, without a
+ * `mutationKey`.
+ * @returns The same options object, unchanged.
+ * @remarks See the other overload's example for looking a mutation up via `injectMutationState`.
+ *
+ * @example
+ * Sharing options across services, so `QueriesService` stays the single place a mutation is defined:
+ * ```angular-ts
+ * import { mutationOptions, injectMutation } from '@tanstack/angular-query-experimental'
+ *
+ * @Injectable({ providedIn: 'root' })
  * export class QueriesService {
- *   private http = inject(HttpClient)
- *   private queryClient = inject(QueryClient)
+ *   readonly #queryClient = inject(QueryClient)
  *
  *   updatePost(id: number) {
  *     return mutationOptions({
- *       mutationFn: (post: Post) => Promise.resolve(post),
- *       mutationKey: ["updatePost", id],
- *       onSuccess: (newPost) => {
- *         //           ^? newPost: Post
- *         this.queryClient.setQueryData(["posts", id], newPost)
- *       },
- *     });
+ *       mutationFn: (post: Partial<Post>) => putPost(id, post),
+ *       onSuccess: (newPost) => this.#queryClient.setQueryData(['posts', id], newPost),
+ *     })
  *   }
  * }
  *
- * class ComponentOrService {
- *   queries = inject(QueriesService)
- *   id = signal(0)
- *   mutation = injectMutation(() => this.queries.updatePost(this.id()))
+ * @Component({
+ *   selector: 'post',
+ *   template: `<button (click)="save()">Save</button>`,
+ * })
+ * export class Post {
+ *   readonly queries = inject(QueriesService)
+ *   readonly id = signal(0)
+ *   readonly updatePostMutation = injectMutation(() => this.queries.updatePost(this.id()))
  *
  *   save() {
- *     this.mutation.mutate({ title: 'New Title' })
+ *     this.updatePostMutation.mutate({ title: 'New Title' })
  *   }
  * }
  * ```
- * @param options - The mutation options.
- * @returns Mutation options.
  */
-export declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: WithRequired<CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): WithRequired<CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
 export declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: Omit<CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): Omit<CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;

package/mutation-options.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"mutation-options.mjs","sources":["../src/mutation-options.ts"],"sourcesContent":["import type { DefaultError, WithRequired } from '@tanstack/query-core'\nimport type { CreateMutationOptions } from './types'\n\n/**\n * Allows sharing and re-using mutation options in a type-safe way.\n *\n * **Example**\n *\n * ```ts\n * export class QueriesService {\n *   private http = inject(HttpClient)\n *   private queryClient = inject(QueryClient)\n *\n *   updatePost(id: number) {\n *     return mutationOptions({\n *       mutationFn: (post: Post) => Promise.resolve(post),\n *       mutationKey: [\"updatePost\", id],\n *       onSuccess: (newPost) => {\n *         //           ^? newPost: Post\n *         this.queryClient.setQueryData([\"posts\", id], newPost)\n *       },\n *     });\n *   }\n * }\n *\n * class ComponentOrService {\n *   queries = inject(QueriesService)\n *   id = signal(0)\n *   mutation = injectMutation(() => this.queries.updatePost(this.id()))\n *\n *   save() {\n *     this.mutation.mutate({ title: 'New Title' })\n *   }\n * }\n * ```\n * @param options - The mutation options.\n * @returns Mutation options.\n */\nexport function mutationOptions<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n>(\n  options: WithRequired<\n    CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n    'mutationKey'\n  >,\n): WithRequired<\n  CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n  'mutationKey'\n>\nexport function mutationOptions<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n>(\n  options: Omit<\n    CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n    'mutationKey'\n  >,\n): Omit<\n  CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n  'mutationKey'\n>\n\n/**\n * Allows sharing and re-using mutation options in a type-safe way.\n *\n * **Example**\n *\n * ```ts\n * export class QueriesService {\n *   private http = inject(HttpClient)\n *   private queryClient = inject(QueryClient)\n *\n *   updatePost(id: number) {\n *     return mutationOptions({\n *       mutationFn: (post: Post) => Promise.resolve(post),\n *       mutationKey: [\"updatePost\", id],\n *       onSuccess: (newPost) => {\n *         //           ^? newPost: Post\n *         this.queryClient.setQueryData([\"posts\", id], newPost)\n *       },\n *     });\n *   }\n * }\n *\n * class ComponentOrService {\n *   queries = inject(QueriesService)\n *   id = signal(0)\n *   mutation = injectMutation(() => this.queries.updatePost(this.id()))\n *\n *   save() {\n *     this.mutation.mutate({ title: 'New Title' })\n *   }\n * }\n * ```\n * @param options - The mutation options.\n * @returns Mutation options.\n */\nexport function mutationOptions<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n>(\n  options: CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n): CreateMutationOptions<TData, TError, TVariables, TOnMutateResult> {\n  return options\n}\n"],"names":[],"mappings":"AAsGO,SAAS,gBAMd,SACmE;AACnE,SAAO;AACT;"}
+{"version":3,"file":"mutation-options.mjs","sources":["../src/mutation-options.ts"],"sourcesContent":["import type { DefaultError, WithRequired } from '@tanstack/query-core'\nimport type { CreateMutationOptions } from './types'\n\n/**\n * You can generally pass everything to `mutationOptions` that you can also pass to `injectMutation`. A\n * `mutationKey` is required on this overload so the mutation can be looked up later, e.g. with\n * `injectMutationState`.\n *\n * @see {@link injectMutation} to run the mutation these options describe.\n * @param options - The mutation options to use, identical to what you'd pass to `injectMutation`, with a\n * required `mutationKey`.\n * @returns The same options object, unchanged.\n *\n * @example\n * Looking the mutation up elsewhere via its `mutationKey`, e.g. for a global \"saving…\" indicator:\n * ```angular-ts\n * import { mutationOptions, injectMutationState } from '@tanstack/angular-query-experimental'\n *\n * const createPostOptions = mutationOptions({\n *   mutationKey: ['posts', 'create'],\n *   mutationFn: createPost,\n * })\n *\n * @Component({\n *   selector: 'saving-indicator',\n *   template: `\n *     @if (isCreatingPost()) {\n *       <span>Saving…</span>\n *     }\n *   `,\n * })\n * export class SavingIndicator {\n *   readonly #pendingCreates = injectMutationState(() => ({\n *     filters: { mutationKey: createPostOptions.mutationKey, status: 'pending' },\n *   }))\n *   readonly isCreatingPost = computed(() => this.#pendingCreates().length > 0)\n * }\n * ```\n */\nexport function mutationOptions<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n>(\n  options: WithRequired<\n    CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n    'mutationKey'\n  >,\n): WithRequired<\n  CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n  'mutationKey'\n>\n/**\n * You can generally pass everything to `mutationOptions` that you can also pass to `injectMutation`. No\n * `mutationKey` is required on this overload — use this when you don't need to target the mutation via a\n * `mutationKey` filter later (e.g. with `injectMutationState`); it can still be observed through other\n * filters, such as `status`.\n *\n * @see {@link injectMutation} to run the mutation these options describe.\n * @param options - The mutation options to use, identical to what you'd pass to `injectMutation`, without a\n * `mutationKey`.\n * @returns The same options object, unchanged.\n * @remarks See the other overload's example for looking a mutation up via `injectMutationState`.\n *\n * @example\n * Sharing options across services, so `QueriesService` stays the single place a mutation is defined:\n * ```angular-ts\n * import { mutationOptions, injectMutation } from '@tanstack/angular-query-experimental'\n *\n * @Injectable({ providedIn: 'root' })\n * export class QueriesService {\n *   readonly #queryClient = inject(QueryClient)\n *\n *   updatePost(id: number) {\n *     return mutationOptions({\n *       mutationFn: (post: Partial<Post>) => putPost(id, post),\n *       onSuccess: (newPost) => this.#queryClient.setQueryData(['posts', id], newPost),\n *     })\n *   }\n * }\n *\n * @Component({\n *   selector: 'post',\n *   template: `<button (click)=\"save()\">Save</button>`,\n * })\n * export class Post {\n *   readonly queries = inject(QueriesService)\n *   readonly id = signal(0)\n *   readonly updatePostMutation = injectMutation(() => this.queries.updatePost(this.id()))\n *\n *   save() {\n *     this.updatePostMutation.mutate({ title: 'New Title' })\n *   }\n * }\n * ```\n */\nexport function mutationOptions<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n>(\n  options: Omit<\n    CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n    'mutationKey'\n  >,\n): Omit<\n  CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n  'mutationKey'\n>\nexport function mutationOptions<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n>(\n  options: CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n): CreateMutationOptions<TData, TError, TVariables, TOnMutateResult> {\n  return options\n}\n"],"names":[],"mappings":"AA+GO,SAAS,gBAMd,SACmE;AACnE,SAAO;AACT;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/angular-query-experimental",
-  "version": "5.102.8",
+  "version": "5.103.1",
   "description": "Signals for managing, caching and syncing asynchronous and remote data in Angular",
   "author": "Arnoud de Vries",
   "license": "MIT",
@@ -61,10 +61,10 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@tanstack/query-core": "5.102.8"
+    "@tanstack/query-core": "5.103.1"
   },
   "optionalDependencies": {
-    "@tanstack/query-devtools": "5.102.8"
+    "@tanstack/query-devtools": "5.103.1"
   },
   "peerDependencies": {
     "@angular/common": ">=16.0.0",

package/providers.d.ts

@@ -2,39 +2,45 @@ import { InjectionToken, Provider } from '@angular/core';
 import { QueryClient } from '@tanstack/query-core';
 /**
  * Usually {@link provideTanStackQuery} is used once to set up TanStack Query and the
- * {@link https://tanstack.com/query/latest/docs/reference/QueryClient|QueryClient}
- * for the entire application. Internally it calls `provideQueryClient`.
- * You can use `provideQueryClient` to provide a different `QueryClient` instance for a part
- * of the application or for unit testing purposes.
+ * [`QueryClient`](https://tanstack.com/query/latest/docs/reference/QueryClient) for the entire application —
+ * it calls `provideQueryClient` internally. Use `provideQueryClient` directly to provide a different
+ * `QueryClient` instance for part of the application, or for unit testing.
  * @param queryClient - A `QueryClient` instance, or an `InjectionToken` which provides a `QueryClient`.
- * @returns a provider object that can be used to provide the `QueryClient` instance.
+ * @returns A provider object that can be used to provide the `QueryClient` instance.
+ *
+ * @example
+ * Providing a test-only `QueryClient` in a component test, without wiring up `provideTanStackQuery`'s other
+ * defaults:
+ * ```ts
+ * TestBed.configureTestingModule({
+ *   providers: [provideQueryClient(new QueryClient())],
+ * })
+ * ```
  */
 export declare function provideQueryClient(queryClient: QueryClient | InjectionToken<QueryClient>): Provider;
 /**
- * Sets up providers necessary to enable TanStack Query functionality for Angular applications.
- *
- * Allows configuring a `QueryClient` and optional features such as developer tools.
+ * Sets up providers necessary to enable TanStack Query functionality for Angular applications. Allows
+ * configuring a `QueryClient` and optional features such as developer tools.
  *
- * **Example - standalone**
+ * @see https://tanstack.com/query/v5/docs/framework/angular/quick-start
+ * @see {@link withDevtools}
+ * @param queryClient - A `QueryClient` instance, or an `InjectionToken` which provides a `QueryClient`.
+ * @param features - Optional features to configure additional Query functionality.
+ * @returns A set of providers to set up TanStack Query.
  *
+ * @example
  * ```ts
- * import {
- *   provideTanStackQuery,
- *   QueryClient,
- * } from '@tanstack/angular-query-experimental'
+ * import { provideTanStackQuery, QueryClient } from '@tanstack/angular-query-experimental'
  *
  * bootstrapApplication(AppComponent, {
  *   providers: [provideTanStackQuery(new QueryClient())],
  * })
  * ```
  *
- * **Example - NgModule-based**
- *
+ * @example
+ * The same, in an `NgModule`-based application:
  * ```ts
- * import {
- *   provideTanStackQuery,
- *   QueryClient,
- * } from '@tanstack/angular-query-experimental'
+ * import { provideTanStackQuery, QueryClient } from '@tanstack/angular-query-experimental'
  *
  * @NgModule({
  *   declarations: [AppComponent],
@@ -45,26 +51,26 @@ export declare function provideQueryClient(queryClient: QueryClient | InjectionT
  * export class AppModule {}
  * ```
  *
- * You can also enable optional developer tools by adding `withDevtools`. By
- * default the tools will then be loaded when your app is in development mode.
+ * @example
+ * Enabling optional developer tools by adding `withDevtools` — by default, the tools are then loaded when
+ * your app is in development mode:
  * ```ts
  * import {
  *   provideTanStackQuery,
- *   withDevtools
+ *   withDevtools,
  *   QueryClient,
  * } from '@tanstack/angular-query-experimental'
  *
- * bootstrapApplication(AppComponent,
- *   {
- *     providers: [
- *       provideTanStackQuery(new QueryClient(), withDevtools())
- *     ]
- *   }
- * )
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideTanStackQuery(new QueryClient(), withDevtools())],
+ * })
  * ```
  *
- * **Example: using an InjectionToken**
- *
+ * @example
+ * Using an `InjectionToken` for the `QueryClient` — an advanced optimization that lets TanStack Query be
+ * absent from the main application bundle, useful for including it on lazy-loaded routes only while still
+ * sharing a `QueryClient`. This is a small optimization; for most applications it's preferable to provide
+ * the `QueryClient` in the main application config, as in the examples above:
  * ```ts
  * export const MY_QUERY_CLIENT = new InjectionToken('', {
  *   factory: () => new QueryClient(),
@@ -73,24 +79,15 @@ export declare function provideQueryClient(queryClient: QueryClient | InjectionT
  * // In a lazy loaded route or lazy loaded component's providers array:
  * providers: [provideTanStackQuery(MY_QUERY_CLIENT)]
  * ```
- * Using an InjectionToken for the QueryClient is an advanced optimization which allows TanStack Query to be absent from the main application bundle.
- * This can be beneficial if you want to include TanStack Query on lazy loaded routes only while still sharing a `QueryClient`.
- *
- * Note that this is a small optimization and for most applications it's preferable to provide the `QueryClient` in the main application config.
- * @param queryClient - A `QueryClient` instance, or an `InjectionToken` which provides a `QueryClient`.
- * @param features - Optional features to configure additional Query functionality.
- * @returns A set of providers to set up TanStack Query.
- * @see https://tanstack.com/query/v5/docs/framework/angular/quick-start
- * @see withDevtools
  */
 export declare function provideTanStackQuery(queryClient: QueryClient | InjectionToken<QueryClient>, ...features: Array<QueryFeatures>): Array<Provider>;
 /**
  * Sets up providers necessary to enable TanStack Query functionality for Angular applications.
  *
  * Allows configuring a `QueryClient`.
+ * @see https://tanstack.com/query/v5/docs/framework/angular/quick-start
  * @param queryClient - A `QueryClient` instance.
  * @returns A set of providers to set up TanStack Query.
- * @see https://tanstack.com/query/v5/docs/framework/angular/quick-start
  * @deprecated Use `provideTanStackQuery` instead.
  */
 export declare function provideAngularQuery(queryClient: QueryClient): Array<Provider>;
@@ -105,8 +102,8 @@ export interface QueryFeature<TFeatureKind extends QueryFeatureKind> {
 }
 /**
  * Helper function to create an object that represents a Query feature.
- * @param kind -
- * @param providers -
+ * @param kind - The kind of feature, e.g. `'Devtools'`.
+ * @param providers - The Angular providers this feature contributes to `provideTanStackQuery`.
  * @returns A Query feature.
  */
 export declare function queryFeature<TFeatureKind extends QueryFeatureKind>(kind: TFeatureKind, providers: Array<Provider>): QueryFeature<TFeatureKind>;

package/providers.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"providers.mjs","sources":["../src/providers.ts"],"sourcesContent":["import { DestroyRef, InjectionToken, inject } from '@angular/core'\nimport { QueryClient } from '@tanstack/query-core'\nimport type { Provider } from '@angular/core'\n\n/**\n * Usually {@link provideTanStackQuery} is used once to set up TanStack Query and the\n * {@link https://tanstack.com/query/latest/docs/reference/QueryClient|QueryClient}\n * for the entire application. Internally it calls `provideQueryClient`.\n * You can use `provideQueryClient` to provide a different `QueryClient` instance for a part\n * of the application or for unit testing purposes.\n * @param queryClient - A `QueryClient` instance, or an `InjectionToken` which provides a `QueryClient`.\n * @returns a provider object that can be used to provide the `QueryClient` instance.\n */\nexport function provideQueryClient(\n  queryClient: QueryClient | InjectionToken<QueryClient>,\n): Provider {\n  return {\n    provide: QueryClient,\n    useFactory: () => {\n      const client =\n        queryClient instanceof InjectionToken\n          ? inject(queryClient)\n          : queryClient\n      // Unmount the query client on injector destroy\n      inject(DestroyRef).onDestroy(() => client.unmount())\n      client.mount()\n      return client\n    },\n  }\n}\n\n/**\n * Sets up providers necessary to enable TanStack Query functionality for Angular applications.\n *\n * Allows configuring a `QueryClient` and optional features such as developer tools.\n *\n * **Example - standalone**\n *\n * ```ts\n * import {\n *   provideTanStackQuery,\n *   QueryClient,\n * } from '@tanstack/angular-query-experimental'\n *\n * bootstrapApplication(AppComponent, {\n *   providers: [provideTanStackQuery(new QueryClient())],\n * })\n * ```\n *\n * **Example - NgModule-based**\n *\n * ```ts\n * import {\n *   provideTanStackQuery,\n *   QueryClient,\n * } from '@tanstack/angular-query-experimental'\n *\n * @NgModule({\n *   declarations: [AppComponent],\n *   imports: [BrowserModule],\n *   providers: [provideTanStackQuery(new QueryClient())],\n *   bootstrap: [AppComponent],\n * })\n * export class AppModule {}\n * ```\n *\n * You can also enable optional developer tools by adding `withDevtools`. By\n * default the tools will then be loaded when your app is in development mode.\n * ```ts\n * import {\n *   provideTanStackQuery,\n *   withDevtools\n *   QueryClient,\n * } from '@tanstack/angular-query-experimental'\n *\n * bootstrapApplication(AppComponent,\n *   {\n *     providers: [\n *       provideTanStackQuery(new QueryClient(), withDevtools())\n *     ]\n *   }\n * )\n * ```\n *\n * **Example: using an InjectionToken**\n *\n * ```ts\n * export const MY_QUERY_CLIENT = new InjectionToken('', {\n *   factory: () => new QueryClient(),\n * })\n *\n * // In a lazy loaded route or lazy loaded component's providers array:\n * providers: [provideTanStackQuery(MY_QUERY_CLIENT)]\n * ```\n * Using an InjectionToken for the QueryClient is an advanced optimization which allows TanStack Query to be absent from the main application bundle.\n * This can be beneficial if you want to include TanStack Query on lazy loaded routes only while still sharing a `QueryClient`.\n *\n * Note that this is a small optimization and for most applications it's preferable to provide the `QueryClient` in the main application config.\n * @param queryClient - A `QueryClient` instance, or an `InjectionToken` which provides a `QueryClient`.\n * @param features - Optional features to configure additional Query functionality.\n * @returns A set of providers to set up TanStack Query.\n * @see https://tanstack.com/query/v5/docs/framework/angular/quick-start\n * @see withDevtools\n */\nexport function provideTanStackQuery(\n  queryClient: QueryClient | InjectionToken<QueryClient>,\n  ...features: Array<QueryFeatures>\n): Array<Provider> {\n  return [\n    provideQueryClient(queryClient),\n    features.map((feature) => feature.ɵproviders),\n  ]\n}\n\n/**\n * Sets up providers necessary to enable TanStack Query functionality for Angular applications.\n *\n * Allows configuring a `QueryClient`.\n * @param queryClient - A `QueryClient` instance.\n * @returns A set of providers to set up TanStack Query.\n * @see https://tanstack.com/query/v5/docs/framework/angular/quick-start\n * @deprecated Use `provideTanStackQuery` instead.\n */\nexport function provideAngularQuery(queryClient: QueryClient): Array<Provider> {\n  return provideTanStackQuery(queryClient)\n}\n\nconst queryFeatures = ['Devtools', 'PersistQueryClient'] as const\n\ntype QueryFeatureKind = (typeof queryFeatures)[number]\n\n/**\n * Helper type to represent a Query feature.\n */\nexport interface QueryFeature<TFeatureKind extends QueryFeatureKind> {\n  ɵkind: TFeatureKind\n  ɵproviders: Array<Provider>\n}\n\n/**\n * Helper function to create an object that represents a Query feature.\n * @param kind -\n * @param providers -\n * @returns A Query feature.\n */\nexport function queryFeature<TFeatureKind extends QueryFeatureKind>(\n  kind: TFeatureKind,\n  providers: Array<Provider>,\n): QueryFeature<TFeatureKind> {\n  return { ɵkind: kind, ɵproviders: providers }\n}\n\n/**\n * A type alias that represents a feature which enables developer tools.\n * The type is used to describe the return value of the `withDevtools` function.\n * @see {@link withDevtools}\n */\nexport type DevtoolsFeature = QueryFeature<'Devtools'>\n\n/**\n * A type alias that represents a feature which enables persistence.\n * The type is used to describe the return value of the `withPersistQueryClient` function.\n */\nexport type PersistQueryClientFeature = QueryFeature<'PersistQueryClient'>\n\n/**\n * A type alias that represents all Query features available for use with `provideTanStackQuery`.\n * Features can be enabled by adding special functions to the `provideTanStackQuery` call.\n * See documentation for each symbol to find corresponding function name. See also `provideTanStackQuery`\n * documentation on how to use those functions.\n * @see {@link provideTanStackQuery}\n */\nexport type QueryFeatures = DevtoolsFeature | PersistQueryClientFeature\n"],"names":[],"mappings":";;AAaO,SAAS,mBACd,aACU;AACV,SAAO;AAAA,IACL,SAAS;AAAA,IACT,YAAY,MAAM;AAChB,YAAM,SACJ,uBAAuB,iBACnB,OAAO,WAAW,IAClB;AAEN,aAAO,UAAU,EAAE,UAAU,MAAM,OAAO,SAAS;AACnD,aAAO,MAAA;AACP,aAAO;AAAA,IACT;AAAA,EAAA;AAEJ;AA2EO,SAAS,qBACd,gBACG,UACc;AACjB,SAAO;AAAA,IACL,mBAAmB,WAAW;AAAA,IAC9B,SAAS,IAAI,CAAC,YAAY,QAAQ,UAAU;AAAA,EAAA;AAEhD;AAWO,SAAS,oBAAoB,aAA2C;AAC7E,SAAO,qBAAqB,WAAW;AACzC;AAoBO,SAAS,aACd,MACA,WAC4B;AAC5B,SAAO,EAAE,OAAO,MAAM,YAAY,UAAA;AACpC;"}
+{"version":3,"file":"providers.mjs","sources":["../src/providers.ts"],"sourcesContent":["import { DestroyRef, InjectionToken, inject } from '@angular/core'\nimport { QueryClient } from '@tanstack/query-core'\nimport type { Provider } from '@angular/core'\n\n/**\n * Usually {@link provideTanStackQuery} is used once to set up TanStack Query and the\n * [`QueryClient`](https://tanstack.com/query/latest/docs/reference/QueryClient) for the entire application —\n * it calls `provideQueryClient` internally. Use `provideQueryClient` directly to provide a different\n * `QueryClient` instance for part of the application, or for unit testing.\n * @param queryClient - A `QueryClient` instance, or an `InjectionToken` which provides a `QueryClient`.\n * @returns A provider object that can be used to provide the `QueryClient` instance.\n *\n * @example\n * Providing a test-only `QueryClient` in a component test, without wiring up `provideTanStackQuery`'s other\n * defaults:\n * ```ts\n * TestBed.configureTestingModule({\n *   providers: [provideQueryClient(new QueryClient())],\n * })\n * ```\n */\nexport function provideQueryClient(\n  queryClient: QueryClient | InjectionToken<QueryClient>,\n): Provider {\n  return {\n    provide: QueryClient,\n    useFactory: () => {\n      const client =\n        queryClient instanceof InjectionToken\n          ? inject(queryClient)\n          : queryClient\n      // Unmount the query client on injector destroy\n      inject(DestroyRef).onDestroy(() => client.unmount())\n      client.mount()\n      return client\n    },\n  }\n}\n\n/**\n * Sets up providers necessary to enable TanStack Query functionality for Angular applications. Allows\n * configuring a `QueryClient` and optional features such as developer tools.\n *\n * @see https://tanstack.com/query/v5/docs/framework/angular/quick-start\n * @see {@link withDevtools}\n * @param queryClient - A `QueryClient` instance, or an `InjectionToken` which provides a `QueryClient`.\n * @param features - Optional features to configure additional Query functionality.\n * @returns A set of providers to set up TanStack Query.\n *\n * @example\n * ```ts\n * import { provideTanStackQuery, QueryClient } from '@tanstack/angular-query-experimental'\n *\n * bootstrapApplication(AppComponent, {\n *   providers: [provideTanStackQuery(new QueryClient())],\n * })\n * ```\n *\n * @example\n * The same, in an `NgModule`-based application:\n * ```ts\n * import { provideTanStackQuery, QueryClient } from '@tanstack/angular-query-experimental'\n *\n * @NgModule({\n *   declarations: [AppComponent],\n *   imports: [BrowserModule],\n *   providers: [provideTanStackQuery(new QueryClient())],\n *   bootstrap: [AppComponent],\n * })\n * export class AppModule {}\n * ```\n *\n * @example\n * Enabling optional developer tools by adding `withDevtools` — by default, the tools are then loaded when\n * your app is in development mode:\n * ```ts\n * import {\n *   provideTanStackQuery,\n *   withDevtools,\n *   QueryClient,\n * } from '@tanstack/angular-query-experimental'\n *\n * bootstrapApplication(AppComponent, {\n *   providers: [provideTanStackQuery(new QueryClient(), withDevtools())],\n * })\n * ```\n *\n * @example\n * Using an `InjectionToken` for the `QueryClient` — an advanced optimization that lets TanStack Query be\n * absent from the main application bundle, useful for including it on lazy-loaded routes only while still\n * sharing a `QueryClient`. This is a small optimization; for most applications it's preferable to provide\n * the `QueryClient` in the main application config, as in the examples above:\n * ```ts\n * export const MY_QUERY_CLIENT = new InjectionToken('', {\n *   factory: () => new QueryClient(),\n * })\n *\n * // In a lazy loaded route or lazy loaded component's providers array:\n * providers: [provideTanStackQuery(MY_QUERY_CLIENT)]\n * ```\n */\nexport function provideTanStackQuery(\n  queryClient: QueryClient | InjectionToken<QueryClient>,\n  ...features: Array<QueryFeatures>\n): Array<Provider> {\n  return [\n    provideQueryClient(queryClient),\n    features.map((feature) => feature.ɵproviders),\n  ]\n}\n\n/**\n * Sets up providers necessary to enable TanStack Query functionality for Angular applications.\n *\n * Allows configuring a `QueryClient`.\n * @see https://tanstack.com/query/v5/docs/framework/angular/quick-start\n * @param queryClient - A `QueryClient` instance.\n * @returns A set of providers to set up TanStack Query.\n * @deprecated Use `provideTanStackQuery` instead.\n */\nexport function provideAngularQuery(queryClient: QueryClient): Array<Provider> {\n  return provideTanStackQuery(queryClient)\n}\n\nconst queryFeatures = ['Devtools', 'PersistQueryClient'] as const\n\ntype QueryFeatureKind = (typeof queryFeatures)[number]\n\n/**\n * Helper type to represent a Query feature.\n */\nexport interface QueryFeature<TFeatureKind extends QueryFeatureKind> {\n  ɵkind: TFeatureKind\n  ɵproviders: Array<Provider>\n}\n\n/**\n * Helper function to create an object that represents a Query feature.\n * @param kind - The kind of feature, e.g. `'Devtools'`.\n * @param providers - The Angular providers this feature contributes to `provideTanStackQuery`.\n * @returns A Query feature.\n */\nexport function queryFeature<TFeatureKind extends QueryFeatureKind>(\n  kind: TFeatureKind,\n  providers: Array<Provider>,\n): QueryFeature<TFeatureKind> {\n  return { ɵkind: kind, ɵproviders: providers }\n}\n\n/**\n * A type alias that represents a feature which enables developer tools.\n * The type is used to describe the return value of the `withDevtools` function.\n * @see {@link withDevtools}\n */\nexport type DevtoolsFeature = QueryFeature<'Devtools'>\n\n/**\n * A type alias that represents a feature which enables persistence.\n * The type is used to describe the return value of the `withPersistQueryClient` function.\n */\nexport type PersistQueryClientFeature = QueryFeature<'PersistQueryClient'>\n\n/**\n * A type alias that represents all Query features available for use with `provideTanStackQuery`.\n * Features can be enabled by adding special functions to the `provideTanStackQuery` call.\n * See documentation for each symbol to find corresponding function name. See also `provideTanStackQuery`\n * documentation on how to use those functions.\n * @see {@link provideTanStackQuery}\n */\nexport type QueryFeatures = DevtoolsFeature | PersistQueryClientFeature\n"],"names":[],"mappings":";;AAqBO,SAAS,mBACd,aACU;AACV,SAAO;AAAA,IACL,SAAS;AAAA,IACT,YAAY,MAAM;AAChB,YAAM,SACJ,uBAAuB,iBACnB,OAAO,WAAW,IAClB;AAEN,aAAO,UAAU,EAAE,UAAU,MAAM,OAAO,SAAS;AACnD,aAAO,MAAA;AACP,aAAO;AAAA,IACT;AAAA,EAAA;AAEJ;AAgEO,SAAS,qBACd,gBACG,UACc;AACjB,SAAO;AAAA,IACL,mBAAmB,WAAW;AAAA,IAC9B,SAAS,IAAI,CAAC,YAAY,QAAQ,UAAU;AAAA,EAAA;AAEhD;AAWO,SAAS,oBAAoB,aAA2C;AAC7E,SAAO,qBAAqB,WAAW;AACzC;AAoBO,SAAS,aACd,MACA,WAC4B;AAC5B,SAAO,EAAE,OAAO,MAAM,YAAY,UAAA;AACpC;"}