@tanstack/angular-query-experimental 5.103.2 → 5.104.0

package/{inject-queries.d.ts → dist/inject-queries.d.mts}

@@ -1,43 +1,44 @@
-import { Injector, Signal } from '@angular/core';
-import { DefaultError, OmitKeyof, QueriesPlaceholderDataFunction, QueryFunction, QueryKey, ThrowOnError } from '@tanstack/query-core';
-import { CreateQueryOptions, CreateQueryResult, DefinedCreateQueryResult } from './types.js';
+import { CreateQueryOptions, CreateQueryResult, DefinedCreateQueryResult } from "./types.mjs";
+import { Injector, Signal } from "@angular/core";
+import { DefaultError, OmitKeyof, QueriesPlaceholderDataFunction, QueryFunction, QueryKey, ThrowOnError } from "@tanstack/query-core";
+//#region src/inject-queries.d.ts
 type QueryObserverOptionsForCreateQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData'> & {
-    placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>;
+  placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>;
 };
 type MAXIMUM_DEPTH = 20;
 type SkipTokenForCreateQueries = symbol;
 type GetCreateQueryOptionsForCreateQueries<T> = T extends {
-    queryFnData: infer TQueryFnData;
-    error?: infer TError;
-    data: infer TData;
+  queryFnData: infer TQueryFnData;
+  error?: infer TError;
+  data: infer TData;
 } ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData> : T extends {
-    queryFnData: infer TQueryFnData;
-    error?: infer TError;
+  queryFnData: infer TQueryFnData;
+  error?: infer TError;
 } ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError> : T extends {
-    data: infer TData;
-    error?: infer TError;
+  data: infer TData;
+  error?: infer TError;
 } ? QueryObserverOptionsForCreateQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? QueryObserverOptionsForCreateQueries<TQueryFnData> : T extends {
-    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> | SkipTokenForCreateQueries;
-    select?: (data: any) => infer TData;
-    throwOnError?: ThrowOnError<any, infer TError, any, any>;
+  queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> | SkipTokenForCreateQueries;
+  select?: (data: any) => infer TData;
+  throwOnError?: ThrowOnError<any, infer TError, any, any>;
 } ? QueryObserverOptionsForCreateQueries<TQueryFnData, unknown extends TError ? DefaultError : TError, unknown extends TData ? TQueryFnData : TData, TQueryKey> : QueryObserverOptionsForCreateQueries;
 type GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {
-    initialData?: infer TInitialData;
-} ? unknown extends TInitialData ? CreateQueryResult<TData, TError> : TInitialData extends TData ? DefinedCreateQueryResult<TData, TError> : TInitialData extends () => infer TInitialDataResult ? unknown extends TInitialDataResult ? CreateQueryResult<TData, TError> : TInitialDataResult extends TData ? DefinedCreateQueryResult<TData, TError> : CreateQueryResult<TData, TError> : CreateQueryResult<TData, TError> : CreateQueryResult<TData, TError>;
+  initialData?: infer TInitialData;
+} ? unknown extends TInitialData ? CreateQueryResult<TData, TError> : TInitialData extends TData ? DefinedCreateQueryResult<TData, TError> : TInitialData extends (() => infer TInitialDataResult) ? unknown extends TInitialDataResult ? CreateQueryResult<TData, TError> : TInitialDataResult extends TData ? DefinedCreateQueryResult<TData, TError> : CreateQueryResult<TData, TError> : CreateQueryResult<TData, TError> : CreateQueryResult<TData, TError>;
 type GetCreateQueryResult<T> = T extends {
-    queryFnData: any;
-    error?: infer TError;
-    data: infer TData;
+  queryFnData: any;
+  error?: infer TError;
+  data: infer TData;
 } ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends {
-    queryFnData: infer TQueryFnData;
-    error?: infer TError;
+  queryFnData: infer TQueryFnData;
+  error?: infer TError;
 } ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends {
-    data: infer TData;
-    error?: infer TError;
+  data: infer TData;
+  error?: infer TError;
 } ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [any, infer TError, infer TData] ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [infer TQueryFnData, infer TError] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends [infer TQueryFnData] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData> : T extends {
-    queryFn?: QueryFunction<infer TQueryFnData, any> | SkipTokenForCreateQueries;
-    select?: (data: any) => infer TData;
-    throwOnError?: ThrowOnError<any, infer TError, any, any>;
+  queryFn?: QueryFunction<infer TQueryFnData, any> | SkipTokenForCreateQueries;
+  select?: (data: any) => infer TData;
+  throwOnError?: ThrowOnError<any, infer TError, any, any>;
 } ? GetDefinedOrUndefinedQueryResult<T, unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : CreateQueryResult;
 /**
  * The `queries` array accepted by `injectQueries`. Recursively unwraps each tuple element so every entry's
@@ -52,15 +53,7 @@ type GetCreateQueryResult<T> = T extends {
  * @template TDepth - The internal recursion-depth counter, checked against the 20-element limit. It is not
  * meant to be set explicitly.
  */
-export type QueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<QueryObserverOptionsForCreateQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetCreateQueryOptionsForCreateQueries<Head>] : T extends [infer Head, ...infer Tails] ? QueriesOptions<[
-    ...Tails
-], [
-    ...TResults,
-    GetCreateQueryOptionsForCreateQueries<Head>
-], [
-    ...TDepth,
-    1
-]> : ReadonlyArray<unknown> extends T ? T : T extends Array<QueryObserverOptionsForCreateQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<QueryObserverOptionsForCreateQueries>;
+export type QueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<QueryObserverOptionsForCreateQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetCreateQueryOptionsForCreateQueries<Head>] : T extends [infer Head, ...infer Tails] ? QueriesOptions<[...Tails], [...TResults, GetCreateQueryOptionsForCreateQueries<Head>], [...TDepth, 1]> : ReadonlyArray<unknown> extends T ? T : T extends Array<QueryObserverOptionsForCreateQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<QueryObserverOptionsForCreateQueries>;
 /**
  * The result type returned by `injectQueries`, when no `combine` is provided. Mirrors {@link QueriesOptions}:
  * each tuple element's result type is inferred individually, up to 20 elements — past that, tuple recursion
@@ -73,24 +66,10 @@ export type QueriesOptions<T extends Array<any>, TResults extends Array<any> = [
  * @template TDepth - The internal recursion-depth counter, checked against the 20-element limit. It is not
  * meant to be set explicitly.
  */
-export type QueriesResults<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<CreateQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetCreateQueryResult<Head>] : T extends [infer Head, ...infer Tails] ? QueriesResults<[
-    ...Tails
-], [
-    ...TResults,
-    GetCreateQueryResult<Head>
-], [
-    ...TDepth,
-    1
-]> : {
-    [K in keyof T]: GetCreateQueryResult<T[K]>;
-};
+export type QueriesResults<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<CreateQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetCreateQueryResult<Head>] : T extends [infer Head, ...infer Tails] ? QueriesResults<[...Tails], [...TResults, GetCreateQueryResult<Head>], [...TDepth, 1]> : { [K in keyof T]: GetCreateQueryResult<T[K]>; };
 export interface InjectQueriesOptions<T extends Array<any>, TCombinedResult = QueriesResults<T>> {
-    queries: readonly [...QueriesOptions<T>] | readonly [
-        ...{
-            [K in keyof T]: GetCreateQueryOptionsForCreateQueries<T[K]>;
-        }
-    ];
-    combine?: (result: QueriesResults<T>) => TCombinedResult;
+  queries: readonly [...QueriesOptions<T>] | readonly [...{ [K in keyof T]: GetCreateQueryOptionsForCreateQueries<T[K]>; }];
+  combine?: (result: QueriesResults<T>) => TCombinedResult;
 }
 /**
  * Injects a signal to fetch a variable number of queries.
@@ -227,4 +206,5 @@ export interface InjectQueriesOptions<T extends Array<any>, TCombinedResult = Qu
  * ```
  */
 export declare function injectQueries<T extends Array<any>, TCombinedResult = QueriesResults<T>>(optionsFn: () => InjectQueriesOptions<T, TCombinedResult>, injector?: Injector): Signal<TCombinedResult>;
-export {};
+//#endregion
+//# sourceMappingURL=inject-queries.d.mts.map

package/dist/inject-queries.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-queries.d.mts","names":[],"sources":["../src/inject-queries.ts"],"mappings":";;;;KAsCK,qCACH,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,YAC3B,UACF,mBAAmB,cAAc,QAAQ,OAAO;EAGhD,kBAAkB,eAAe,+BAA+B;;KAI7D;KAGA;KAEA,sCAAsC,KAEzC;EACE,mBAAmB;EACnB,cAAc;EACd,YAAY;IAEV,qCAAqC,cAAc,QAAQ,SAC3D;EAAY,mBAAmB;EAAc,cAAc;IACzD,qCAAqC,cAAc,UACnD;EAAY,YAAY;EAAO,cAAc;IAC3C,8CAA8C,QAAQ,SAEtD,iBAAiB,oBAAoB,cAAc,SACjD,qCAAqC,cAAc,QAAQ,SAC3D,iBAAiB,oBAAoB,UACnC,qCAAqC,cAAc,UACnD,iBAAiB,gBACf,qCAAqC,gBAErC;EACI,UACI,oBAAoB,oBAAoB,aACxC;EACJ,UAAU,oBAAoB;EAC9B,eAAe,wBAAwB;IAEzC,qCACE,8BACgB,SAAS,eAAe,wBACxB,QAAQ,eAAe,OACvC,aAGF;KAGb,iCAAiC,GAAG,OAAO,oBAAoB;EAClE,oBAAoB;oBAEF,eACd,kBAAkB,OAAO,UACzB,qBAAqB,QACnB,yBAAyB,OAAO,UAChC,kCAAiC,sCACf,qBACd,kBAAkB,OAAO,UACzB,2BAA2B,QACzB,yBAAyB,OAAO,UAChC,kBAAkB,OAAO,UAC7B,kBAAkB,OAAO,UAC/B,kBAAkB,OAAO;KAExB,qBAAqB,KAExB;EAAY;EAAkB,cAAc;EAAQ,YAAY;IAC5D,iCAAiC,GAAG,OAAO,UAC3C;EAAY,mBAAmB;EAAc,cAAc;IACzD,iCAAiC,GAAG,cAAc,UAClD;EAAY,YAAY;EAAO,cAAc;IAC3C,iCAAiC,GAAG,OAAO,UAE3C,sBAAsB,cAAc,SAClC,iCAAiC,GAAG,OAAO,UAC3C,iBAAiB,oBAAoB,UACnC,iCAAiC,GAAG,cAAc,UAClD,iBAAiB,gBACf,iCAAiC,GAAG,gBAEpC;EACI,UACI,oBAAoB,qBACpB;EACJ,UAAU,oBAAoB;EAC9B,eAAe,wBAAwB;IAEzC,iCACE,mBACgB,QAAQ,eAAe,uBACvB,SAAS,eAAe,UAG1C;;;;;;;;;;;;;;YAeN,eACV,UAAU,YACV,iBAAiB,iBACjB,eAAe,8BACb,yBAAyB,gBACzB,MAAM,wCACN,oBAEE,iBAAiB,YACX,UAAU,sCAAsC,SACpD,iBAAiB,eAAe,SAC9B,mBACM,YACA,UAAU,sCAAsC,YAChD,cAEN,+BAA+B,IAC7B,IAGA,UAAU,MACN,2CACQ,oBACA,cACA,aACA,cAGV,MACE,qCACE,cACA,QACA,OACA,cAIJ,MAAM;;;;;;;;;;;;;YAcR,eACV,UAAU,YACV,iBAAiB,iBACjB,eAAe,8BACb,yBAAyB,gBACzB,MAAM,qBACN,oBAEE,iBAAiB,YACX,UAAU,qBAAqB,SACnC,iBAAiB,eAAe,SAC9B,mBACM,YACA,UAAU,qBAAqB,YAC/B,iBAEH,WAAW,IAAI,qBAAqB,EAAE;iBAElC,qBACf,UAAU,YACV,kBAAkB,eAAe;EAEjC,sBACiB,eAAe,sBAEpB,WAAW,IAAI,sCAAsC,EAAE;EAEnE,WAAW,QAAQ,eAAe,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAyI3B,cACd,UAAU,YACV,kBAAkB,eAAe,IAEjC,iBAAiB,qBAAqB,GAAG,kBACzC,WAAW,WACV,OAAO"}

package/dist/inject-queries.mjs

@@ -0,0 +1,203 @@
+import { signalProxy } from "./signal-proxy.mjs";
+import { injectIsRestoring } from "./inject-is-restoring.mjs";
+import { DestroyRef, Injector, NgZone, assertInInjectionContext, computed, effect, inject, runInInjectionContext, signal, untracked } from "@angular/core";
+import { QueriesObserver, QueryClient, notifyManager } from "@tanstack/query-core";
+//#region src/inject-queries.ts
+/**
+* Injects a signal to fetch a variable number of queries.
+*
+* The `queries` key accepts an array with query option objects mostly identical to `injectQuery`'s. Having
+* the same query key more than once in the array of query objects may cause some data to be shared between
+* queries. To avoid this, consider de-duplicating the queries and map the results back to the desired
+* structure.
+*
+* The `combine` option can be used to combine the results of the queries into a single value. The result
+* will be structurally shared to be as referentially stable as possible.
+*
+* @remarks Unlike `injectQuery`, `injectQueries` cannot infer the `data` argument of an _inline_ `select`
+* from its sibling `queryFn`. Because `injectQueries` infers the type of the whole `queries` array at once,
+* the `select` parameter of a query object written inline cannot be contextually typed from that same
+* object's `queryFn`, so it falls back to `unknown` — a
+* [known TypeScript limitation](https://github.com/TanStack/query/issues/6556). Annotate the `select`
+* parameter explicitly, or define the query with {@link queryOptions}, which resolves its types in a single
+* object _before_ it reaches `injectQueries`, to work around this — see the example below.
+* @param optionsFn - A function returning the queries' options — an array of query option objects under
+* `queries`, and an optional `combine`. Similar to `computed` from Angular, this function runs in the
+* reactive context, so signals read inside it (e.g. to build the `queries` array) drive the queries.
+* @param injector - The `Injector` in which to create the queries. If this is not provided, the current
+* injection context will be used instead (via `inject`).
+* @returns A `Signal` with the combined result. Without `combine`, this is an array with all the query
+* results, in the same order as the input. When `combine` is provided, this is the value returned by
+* `combine` instead.
+*
+* @example
+* ```angular-ts
+* @Component({
+*   selector: 'posts',
+*   template: `
+*     <ul>
+*       @for (query of postQueries(); track $index) {
+*         @if (query.isPending()) {
+*           <li>Loading...</li>
+*         } @else if (query.isError()) {
+*           <li>Error: {{ query.error()?.message }}</li>
+*         } @else {
+*           <li>{{ query.data().title }}</li>
+*         }
+*       }
+*     </ul>
+*   `,
+* })
+* export class Posts {
+*   readonly ids = signal([1, 2, 3])
+*
+*   readonly postQueries = injectQueries(() => ({
+*     queries: this.ids().map((id) => ({
+*       queryKey: ['post', id],
+*       queryFn: () => fetchPost(id),
+*       staleTime: Infinity,
+*     })),
+*   }))
+* }
+* ```
+*
+* @example
+* Combining results into a single value:
+* ```angular-ts
+* @Component({
+*   selector: 'posts',
+*   template: `
+*     @if (combined().isPending) {
+*       Loading...
+*     } @else if (combined().isError) {
+*       Error loading posts
+*     } @else {
+*       <ul>
+*         @for (post of combined().data; track post?.id) {
+*           <li>{{ post?.title }}</li>
+*         }
+*       </ul>
+*     }
+*   `,
+* })
+* export class Posts {
+*   readonly ids = signal([1, 2, 3])
+*
+*   readonly combined = injectQueries(() => ({
+*     queries: this.ids().map((id) => ({
+*       queryKey: ['post', id],
+*       queryFn: () => fetchPost(id),
+*     })),
+*     combine: (postQueries) => ({
+*       data: postQueries.map((query) => query.data),
+*       isPending: postQueries.some((query) => query.isPending),
+*       isError: postQueries.some((query) => query.isError),
+*     }),
+*   }))
+* }
+* ```
+*
+* @example
+* Typing `select` via {@link queryOptions}. Note that spreading a `queryOptions` result and overriding
+* `select` inline still falls back to `unknown` — wrap the spread in `queryOptions` again so the override is
+* resolved before it reaches `injectQueries`:
+* ```angular-ts
+* const postOptions = (id: number) =>
+*   queryOptions({
+*     queryKey: ['post', id],
+*     queryFn: () => fetchPost(id),
+*   })
+*
+* @Component({
+*   selector: 'post-title',
+*   template: `<h1>{{ fixed()[0].data() }}</h1>`,
+* })
+* export class PostTitle {
+*   readonly id = signal(1)
+*
+*   readonly broken = injectQueries(() => ({
+*     queries: [
+*       {
+*         ...postOptions(this.id()),
+*         // ❌ `data` is `unknown` here
+*         select: (data) => data.title,
+*       },
+*     ],
+*   }))
+*
+*   readonly fixed = injectQueries(() => ({
+*     queries: [
+*       queryOptions({
+*         ...postOptions(this.id()),
+*         // ✅ `data` is `Post`
+*         select: (data) => data.title,
+*       }),
+*     ],
+*   }))
+* }
+* ```
+*/
+function injectQueries(optionsFn, injector) {
+	!injector && assertInInjectionContext(injectQueries);
+	return runInInjectionContext(injector ?? inject(Injector), () => {
+		const destroyRef = inject(DestroyRef);
+		const ngZone = inject(NgZone);
+		const queryClient = inject(QueryClient);
+		const isRestoring = injectIsRestoring();
+		/**
+		* Signal that has the default options from query client applied
+		* computed() is used so signals can be inserted into the options
+		* making it reactive. Wrapping options in a function ensures embedded expressions
+		* are preserved and can keep being applied after signal changes
+		*/
+		const optionsSignal = computed(() => {
+			return optionsFn();
+		});
+		const defaultedQueries = computed(() => {
+			return optionsSignal().queries.map((opts) => {
+				const defaultedOptions = queryClient.defaultQueryOptions(opts);
+				defaultedOptions._optimisticResults = isRestoring() ? "isRestoring" : "optimistic";
+				return defaultedOptions;
+			});
+		});
+		const observerSignal = (() => {
+			let instance = null;
+			return computed(() => {
+				return instance ||= new QueriesObserver(queryClient, defaultedQueries(), optionsSignal());
+			});
+		})();
+		const optimisticResultSignal = computed(() => observerSignal().getOptimisticResult(defaultedQueries(), optionsSignal().combine));
+		effect(() => {
+			observerSignal().setQueries(defaultedQueries(), optionsSignal());
+		});
+		const optimisticCombinedResultSignal = computed(() => {
+			const [_optimisticResult, getCombinedResult, trackResult] = optimisticResultSignal();
+			return getCombinedResult(trackResult());
+		});
+		const resultFromSubscriberSignal = signal(null);
+		effect(() => {
+			const observer = observerSignal();
+			const [_optimisticResult, getCombinedResult] = optimisticResultSignal();
+			untracked(() => {
+				const unsubscribe = isRestoring() ? () => void 0 : ngZone.runOutsideAngular(() => observer.subscribe(notifyManager.batchCalls((state) => {
+					resultFromSubscriberSignal.set(getCombinedResult(state));
+				})));
+				destroyRef.onDestroy(unsubscribe);
+			});
+		});
+		const resultSignal = computed(() => {
+			const subscriberResult = resultFromSubscriberSignal();
+			const optimisticResult = optimisticCombinedResultSignal();
+			return subscriberResult ?? optimisticResult;
+		});
+		return computed(() => {
+			const result = resultSignal();
+			const { combine } = optionsSignal();
+			return combine ? result : result.map((query) => signalProxy(signal(query)));
+		});
+	});
+}
+//#endregion
+export { injectQueries };
+
+//# sourceMappingURL=inject-queries.mjs.map

package/dist/inject-queries.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-queries.mjs","names":[],"sources":["../src/inject-queries.ts"],"sourcesContent":["import {\n  QueriesObserver,\n  QueryClient,\n  notifyManager,\n} from '@tanstack/query-core'\nimport {\n  DestroyRef,\n  Injector,\n  NgZone,\n  assertInInjectionContext,\n  computed,\n  effect,\n  inject,\n  runInInjectionContext,\n  signal,\n  untracked,\n} from '@angular/core'\nimport { signalProxy } from './signal-proxy'\nimport { injectIsRestoring } from './inject-is-restoring'\nimport type {\n  DefaultError,\n  OmitKeyof,\n  QueriesObserverOptions,\n  QueriesPlaceholderDataFunction,\n  QueryFunction,\n  QueryKey,\n  QueryObserverOptions,\n  ThrowOnError,\n} from '@tanstack/query-core'\nimport type {\n  CreateQueryOptions,\n  CreateQueryResult,\n  DefinedCreateQueryResult,\n} from './types'\nimport type { Signal } from '@angular/core'\n\n// This defines the `CreateQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.\n// `placeholderData` function always gets undefined passed\ntype QueryObserverOptionsForCreateQueries<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n> = OmitKeyof<\n  CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n  'placeholderData'\n> & {\n  placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>\n}\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForCreateQueries = symbol\n\ntype GetCreateQueryOptionsForCreateQueries<T> =\n  // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n  T extends {\n    queryFnData: infer TQueryFnData\n    error?: infer TError\n    data: infer TData\n  }\n    ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData>\n    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n      ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError>\n      : T extends { data: infer TData; error?: infer TError }\n        ? QueryObserverOptionsForCreateQueries<unknown, TError, TData>\n        : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n          T extends [infer TQueryFnData, infer TError, infer TData]\n          ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData>\n          : T extends [infer TQueryFnData, infer TError]\n            ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError>\n            : T extends [infer TQueryFnData]\n              ? QueryObserverOptionsForCreateQueries<TQueryFnData>\n              : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n                T extends {\n                    queryFn?:\n                      | QueryFunction<infer TQueryFnData, infer TQueryKey>\n                      | SkipTokenForCreateQueries\n                    select?: (data: any) => infer TData\n                    throwOnError?: ThrowOnError<any, infer TError, any, any>\n                  }\n                ? QueryObserverOptionsForCreateQueries<\n                    TQueryFnData,\n                    unknown extends TError ? DefaultError : TError,\n                    unknown extends TData ? TQueryFnData : TData,\n                    TQueryKey\n                  >\n                : // Fallback\n                  QueryObserverOptionsForCreateQueries\n\n// A defined initialData setting should return a DefinedCreateQueryResult rather than CreateQueryResult\ntype GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {\n  initialData?: infer TInitialData\n}\n  ? unknown extends TInitialData\n    ? CreateQueryResult<TData, TError>\n    : TInitialData extends TData\n      ? DefinedCreateQueryResult<TData, TError>\n      : TInitialData extends () => infer TInitialDataResult\n        ? unknown extends TInitialDataResult\n          ? CreateQueryResult<TData, TError>\n          : TInitialDataResult extends TData\n            ? DefinedCreateQueryResult<TData, TError>\n            : CreateQueryResult<TData, TError>\n        : CreateQueryResult<TData, TError>\n  : CreateQueryResult<TData, TError>\n\ntype GetCreateQueryResult<T> =\n  // Part 1: responsible for mapping explicit type parameter to function result, if object\n  T extends { queryFnData: any; error?: infer TError; data: infer TData }\n    ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n      ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>\n      : T extends { data: infer TData; error?: infer TError }\n        ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n        : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n          T extends [any, infer TError, infer TData]\n          ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n          : T extends [infer TQueryFnData, infer TError]\n            ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>\n            : T extends [infer TQueryFnData]\n              ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData>\n              : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n                T extends {\n                    queryFn?:\n                      | QueryFunction<infer TQueryFnData, any>\n                      | SkipTokenForCreateQueries\n                    select?: (data: any) => infer TData\n                    throwOnError?: ThrowOnError<any, infer TError, any, any>\n                  }\n                ? GetDefinedOrUndefinedQueryResult<\n                    T,\n                    unknown extends TData ? TQueryFnData : TData,\n                    unknown extends TError ? DefaultError : TError\n                  >\n                : // Fallback\n                  CreateQueryResult\n\n/**\n * The `queries` array accepted by `injectQueries`. Recursively unwraps each tuple element so every entry's\n * `queryFn`/`select`/`throwOnError` are inferred individually, up to 20 elements — past that, tuple\n * recursion falls back to a single homogeneous options type. An opaque array (e.g. `unknown[]`) is returned\n * as-is; a non-tuple array of a known element type is mapped to that element type instead, with no such\n * limit.\n *\n * @template T - The type of the `queries` array as written at the call site.\n * @template TResults - The internal accumulator that this type builds during recursion. It is not meant to\n * be set explicitly.\n * @template TDepth - The internal recursion-depth counter, checked against the 20-element limit. It is not\n * meant to be set explicitly.\n */\nexport type QueriesOptions<\n  T extends Array<any>,\n  TResults extends Array<any> = [],\n  TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n  ? Array<QueryObserverOptionsForCreateQueries>\n  : T extends []\n    ? []\n    : T extends [infer Head]\n      ? [...TResults, GetCreateQueryOptionsForCreateQueries<Head>]\n      : T extends [infer Head, ...infer Tails]\n        ? QueriesOptions<\n            [...Tails],\n            [...TResults, GetCreateQueryOptionsForCreateQueries<Head>],\n            [...TDepth, 1]\n          >\n        : ReadonlyArray<unknown> extends T\n          ? T\n          : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogeneous type!\n            // use this to infer the param types in the case of Array.map() argument\n            T extends Array<\n                QueryObserverOptionsForCreateQueries<\n                  infer TQueryFnData,\n                  infer TError,\n                  infer TData,\n                  infer TQueryKey\n                >\n              >\n            ? Array<\n                QueryObserverOptionsForCreateQueries<\n                  TQueryFnData,\n                  TError,\n                  TData,\n                  TQueryKey\n                >\n              >\n            : // Fallback\n              Array<QueryObserverOptionsForCreateQueries>\n\n/**\n * The result type returned by `injectQueries`, when no `combine` is provided. Mirrors {@link QueriesOptions}:\n * each tuple element's result type is inferred individually, up to 20 elements — past that, tuple recursion\n * falls back to a single homogeneous {@link CreateQueryResult} type. A non-tuple array is mapped per-element\n * instead, with no such limit — every entry keeps its individually inferred type regardless of array length.\n *\n * @template T - The type of the `queries` array, as inferred by {@link QueriesOptions}.\n * @template TResults - The internal accumulator that this type builds during recursion. It is not meant to\n * be set explicitly.\n * @template TDepth - The internal recursion-depth counter, checked against the 20-element limit. It is not\n * meant to be set explicitly.\n */\nexport type QueriesResults<\n  T extends Array<any>,\n  TResults extends Array<any> = [],\n  TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n  ? Array<CreateQueryResult>\n  : T extends []\n    ? []\n    : T extends [infer Head]\n      ? [...TResults, GetCreateQueryResult<Head>]\n      : T extends [infer Head, ...infer Tails]\n        ? QueriesResults<\n            [...Tails],\n            [...TResults, GetCreateQueryResult<Head>],\n            [...TDepth, 1]\n          >\n        : { [K in keyof T]: GetCreateQueryResult<T[K]> }\n\nexport interface InjectQueriesOptions<\n  T extends Array<any>,\n  TCombinedResult = QueriesResults<T>,\n> {\n  queries:\n    | readonly [...QueriesOptions<T>]\n    | readonly [\n        ...{ [K in keyof T]: GetCreateQueryOptionsForCreateQueries<T[K]> },\n      ]\n  combine?: (result: QueriesResults<T>) => TCombinedResult\n}\n\n/**\n * Injects a signal to fetch a variable number of queries.\n *\n * The `queries` key accepts an array with query option objects mostly identical to `injectQuery`'s. Having\n * the same query key more than once in the array of query objects may cause some data to be shared between\n * queries. To avoid this, consider de-duplicating the queries and map the results back to the desired\n * structure.\n *\n * The `combine` option can be used to combine the results of the queries into a single value. The result\n * will be structurally shared to be as referentially stable as possible.\n *\n * @remarks Unlike `injectQuery`, `injectQueries` cannot infer the `data` argument of an _inline_ `select`\n * from its sibling `queryFn`. Because `injectQueries` infers the type of the whole `queries` array at once,\n * the `select` parameter of a query object written inline cannot be contextually typed from that same\n * object's `queryFn`, so it falls back to `unknown` — a\n * [known TypeScript limitation](https://github.com/TanStack/query/issues/6556). Annotate the `select`\n * parameter explicitly, or define the query with {@link queryOptions}, which resolves its types in a single\n * object _before_ it reaches `injectQueries`, to work around this — see the example below.\n * @param optionsFn - A function returning the queries' options — an array of query option objects under\n * `queries`, and an optional `combine`. Similar to `computed` from Angular, this function runs in the\n * reactive context, so signals read inside it (e.g. to build the `queries` array) drive the queries.\n * @param injector - The `Injector` in which to create the queries. If this is not provided, the current\n * injection context will be used instead (via `inject`).\n * @returns A `Signal` with the combined result. Without `combine`, this is an array with all the query\n * results, in the same order as the input. When `combine` is provided, this is the value returned by\n * `combine` instead.\n *\n * @example\n * ```angular-ts\n * @Component({\n *   selector: 'posts',\n *   template: `\n *     <ul>\n *       @for (query of postQueries(); track $index) {\n *         @if (query.isPending()) {\n *           <li>Loading...</li>\n *         } @else if (query.isError()) {\n *           <li>Error: {{ query.error()?.message }}</li>\n *         } @else {\n *           <li>{{ query.data().title }}</li>\n *         }\n *       }\n *     </ul>\n *   `,\n * })\n * export class Posts {\n *   readonly ids = signal([1, 2, 3])\n *\n *   readonly postQueries = injectQueries(() => ({\n *     queries: this.ids().map((id) => ({\n *       queryKey: ['post', id],\n *       queryFn: () => fetchPost(id),\n *       staleTime: Infinity,\n *     })),\n *   }))\n * }\n * ```\n *\n * @example\n * Combining results into a single value:\n * ```angular-ts\n * @Component({\n *   selector: 'posts',\n *   template: `\n *     @if (combined().isPending) {\n *       Loading...\n *     } @else if (combined().isError) {\n *       Error loading posts\n *     } @else {\n *       <ul>\n *         @for (post of combined().data; track post?.id) {\n *           <li>{{ post?.title }}</li>\n *         }\n *       </ul>\n *     }\n *   `,\n * })\n * export class Posts {\n *   readonly ids = signal([1, 2, 3])\n *\n *   readonly combined = injectQueries(() => ({\n *     queries: this.ids().map((id) => ({\n *       queryKey: ['post', id],\n *       queryFn: () => fetchPost(id),\n *     })),\n *     combine: (postQueries) => ({\n *       data: postQueries.map((query) => query.data),\n *       isPending: postQueries.some((query) => query.isPending),\n *       isError: postQueries.some((query) => query.isError),\n *     }),\n *   }))\n * }\n * ```\n *\n * @example\n * Typing `select` via {@link queryOptions}. Note that spreading a `queryOptions` result and overriding\n * `select` inline still falls back to `unknown` — wrap the spread in `queryOptions` again so the override is\n * resolved before it reaches `injectQueries`:\n * ```angular-ts\n * const postOptions = (id: number) =>\n *   queryOptions({\n *     queryKey: ['post', id],\n *     queryFn: () => fetchPost(id),\n *   })\n *\n * @Component({\n *   selector: 'post-title',\n *   template: `<h1>{{ fixed()[0].data() }}</h1>`,\n * })\n * export class PostTitle {\n *   readonly id = signal(1)\n *\n *   readonly broken = injectQueries(() => ({\n *     queries: [\n *       {\n *         ...postOptions(this.id()),\n *         // ❌ `data` is `unknown` here\n *         select: (data) => data.title,\n *       },\n *     ],\n *   }))\n *\n *   readonly fixed = injectQueries(() => ({\n *     queries: [\n *       queryOptions({\n *         ...postOptions(this.id()),\n *         // ✅ `data` is `Post`\n *         select: (data) => data.title,\n *       }),\n *     ],\n *   }))\n * }\n * ```\n */\nexport function injectQueries<\n  T extends Array<any>,\n  TCombinedResult = QueriesResults<T>,\n>(\n  optionsFn: () => InjectQueriesOptions<T, TCombinedResult>,\n  injector?: Injector,\n): Signal<TCombinedResult> {\n  !injector && assertInInjectionContext(injectQueries)\n  return runInInjectionContext(injector ?? inject(Injector), () => {\n    const destroyRef = inject(DestroyRef)\n    const ngZone = inject(NgZone)\n    const queryClient = inject(QueryClient)\n    const isRestoring = injectIsRestoring()\n\n    /**\n     * Signal that has the default options from query client applied\n     * computed() is used so signals can be inserted into the options\n     * making it reactive. Wrapping options in a function ensures embedded expressions\n     * are preserved and can keep being applied after signal changes\n     */\n    const optionsSignal = computed(() => {\n      return optionsFn()\n    })\n\n    const defaultedQueries = computed(() => {\n      return optionsSignal().queries.map((opts) => {\n        const defaultedOptions = queryClient.defaultQueryOptions(\n          opts as QueryObserverOptions,\n        )\n        // Make sure the results are already in fetching state before subscribing or updating options\n        defaultedOptions._optimisticResults = isRestoring()\n          ? 'isRestoring'\n          : 'optimistic'\n\n        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n        return defaultedOptions as QueryObserverOptions\n      })\n    })\n\n    const observerSignal = (() => {\n      let instance: QueriesObserver<TCombinedResult> | null = null\n\n      return computed(() => {\n        return (instance ||= new QueriesObserver<TCombinedResult>(\n          queryClient,\n          defaultedQueries(),\n          optionsSignal() as QueriesObserverOptions<TCombinedResult>,\n        ))\n      })\n    })()\n\n    const optimisticResultSignal = computed(() =>\n      observerSignal().getOptimisticResult(\n        defaultedQueries(),\n        (optionsSignal() as QueriesObserverOptions<TCombinedResult>).combine,\n      ),\n    )\n\n    // Do not notify on updates because of changes in the options because\n    // these changes should already be reflected in the optimistic result.\n    effect(() => {\n      observerSignal().setQueries(\n        defaultedQueries(),\n        optionsSignal() as QueriesObserverOptions<TCombinedResult>,\n      )\n    })\n\n    const optimisticCombinedResultSignal = computed(() => {\n      const [_optimisticResult, getCombinedResult, trackResult] =\n        optimisticResultSignal()\n      return getCombinedResult(trackResult())\n    })\n\n    const resultFromSubscriberSignal = signal<TCombinedResult | null>(null)\n\n    effect(() => {\n      const observer = observerSignal()\n      const [_optimisticResult, getCombinedResult] = optimisticResultSignal()\n\n      untracked(() => {\n        const unsubscribe = isRestoring()\n          ? () => undefined\n          : ngZone.runOutsideAngular(() =>\n              observer.subscribe(\n                notifyManager.batchCalls((state) => {\n                  resultFromSubscriberSignal.set(getCombinedResult(state))\n                }),\n              ),\n            )\n\n        destroyRef.onDestroy(unsubscribe)\n      })\n    })\n\n    const resultSignal = computed(() => {\n      const subscriberResult = resultFromSubscriberSignal()\n      const optimisticResult = optimisticCombinedResultSignal()\n      return subscriberResult ?? optimisticResult\n    })\n\n    return computed(() => {\n      const result = resultSignal()\n      const { combine } = optionsSignal()\n\n      return combine\n        ? result\n        : (result as QueriesResults<T>).map((query) =>\n            signalProxy(signal(query)),\n          )\n    })\n  }) as unknown as Signal<TCombinedResult>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgXA,SAAgB,cAId,WACA,UACyB;CACzB,CAAC,YAAY,yBAAyB,aAAa;CACnD,OAAO,sBAAsB,YAAY,OAAO,QAAQ,SAAS;EAC/D,MAAM,aAAa,OAAO,UAAU;EACpC,MAAM,SAAS,OAAO,MAAM;EAC5B,MAAM,cAAc,OAAO,WAAW;EACtC,MAAM,cAAc,kBAAkB;;;;;;;EAQtC,MAAM,gBAAgB,eAAe;GACnC,OAAO,UAAU;EACnB,CAAC;EAED,MAAM,mBAAmB,eAAe;GACtC,OAAO,cAAc,CAAC,CAAC,QAAQ,KAAK,SAAS;IAC3C,MAAM,mBAAmB,YAAY,oBACnC,IACF;IAEA,iBAAiB,qBAAqB,YAAY,IAC9C,gBACA;IAGJ,OAAO;GACT,CAAC;EACH,CAAC;EAED,MAAM,wBAAwB;GAC5B,IAAI,WAAoD;GAExD,OAAO,eAAe;IACpB,OAAQ,aAAa,IAAI,gBACvB,aACA,iBAAiB,GACjB,cAAc,CAChB;GACF,CAAC;EACH,EAAA,CAAG;EAEH,MAAM,yBAAyB,eAC7B,eAAe,CAAC,CAAC,oBACf,iBAAiB,GAChB,cAAc,CAAC,CAA6C,OAC/D,CACF;EAIA,aAAa;GACX,eAAe,CAAC,CAAC,WACf,iBAAiB,GACjB,cAAc,CAChB;EACF,CAAC;EAED,MAAM,iCAAiC,eAAe;GACpD,MAAM,CAAC,mBAAmB,mBAAmB,eAC3C,uBAAuB;GACzB,OAAO,kBAAkB,YAAY,CAAC;EACxC,CAAC;EAED,MAAM,6BAA6B,OAA+B,IAAI;EAEtE,aAAa;GACX,MAAM,WAAW,eAAe;GAChC,MAAM,CAAC,mBAAmB,qBAAqB,uBAAuB;GAEtE,gBAAgB;IACd,MAAM,cAAc,YAAY,UACtB,KAAA,IACN,OAAO,wBACL,SAAS,UACP,cAAc,YAAY,UAAU;KAClC,2BAA2B,IAAI,kBAAkB,KAAK,CAAC;IACzD,CAAC,CACH,CACF;IAEJ,WAAW,UAAU,WAAW;GAClC,CAAC;EACH,CAAC;EAED,MAAM,eAAe,eAAe;GAClC,MAAM,mBAAmB,2BAA2B;GACpD,MAAM,mBAAmB,+BAA+B;GACxD,OAAO,oBAAoB;EAC7B,CAAC;EAED,OAAO,eAAe;GACpB,MAAM,SAAS,aAAa;GAC5B,MAAM,EAAE,YAAY,cAAc;GAElC,OAAO,UACH,SACC,OAA6B,KAAK,UACjC,YAAY,OAAO,KAAK,CAAC,CAC3B;EACN,CAAC;CACH,CAAC;AACH"}

package/{inject-query-client.d.ts → dist/inject-query-client.d.mts}

@@ -1,5 +1,6 @@
-import { Injector, InjectOptions } from '@angular/core';
-import { QueryClient } from '@tanstack/query-core';
+import { InjectOptions, Injector } from "@angular/core";
+import { QueryClient } from "@tanstack/query-core";
+//#region src/inject-query-client.d.ts
 /**
  * Injects a `QueryClient` instance and allows passing a custom injector.
  * @param injectOptions - Type of the options argument to inject and optionally a custom injector.
@@ -14,5 +15,7 @@ import { QueryClient } from '@tanstack/query-core';
  * ```
  */
 export declare function injectQueryClient(injectOptions?: InjectOptions & {
-    injector?: Injector;
+  injector?: Injector;
 }): QueryClient;
+//#endregion
+//# sourceMappingURL=inject-query-client.d.mts.map

package/dist/inject-query-client.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-query-client.d.mts","names":[],"sources":["../src/inject-query-client.ts"],"mappings":";;;;;;;;;;;;;;;;wBAiBgB,kBACd,gBAAe;EAAkB,WAAW;IAAe"}

package/dist/inject-query-client.mjs

@@ -0,0 +1,23 @@
+import { Injector, inject } from "@angular/core";
+import { QueryClient } from "@tanstack/query-core";
+//#region src/inject-query-client.ts
+/**
+* Injects a `QueryClient` instance and allows passing a custom injector.
+* @param injectOptions - Type of the options argument to inject and optionally a custom injector.
+* @returns The `QueryClient` instance.
+* @deprecated Use `inject(QueryClient)` instead.
+* If you need to get a `QueryClient` from a custom injector, use `injector.get(QueryClient)`.
+*
+*
+* **Example**
+* ```ts
+* const queryClient = injectQueryClient();
+* ```
+*/
+function injectQueryClient(injectOptions = {}) {
+	return (injectOptions.injector ?? inject(Injector)).get(QueryClient);
+}
+//#endregion
+export { injectQueryClient };
+
+//# sourceMappingURL=inject-query-client.mjs.map

package/dist/inject-query-client.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-query-client.mjs","names":[],"sources":["../src/inject-query-client.ts"],"sourcesContent":["import { Injector, inject } from '@angular/core'\nimport { QueryClient } from '@tanstack/query-core'\nimport type { InjectOptions } from '@angular/core'\n\n/**\n * Injects a `QueryClient` instance and allows passing a custom injector.\n * @param injectOptions - Type of the options argument to inject and optionally a custom injector.\n * @returns The `QueryClient` instance.\n * @deprecated Use `inject(QueryClient)` instead.\n * If you need to get a `QueryClient` from a custom injector, use `injector.get(QueryClient)`.\n *\n *\n * **Example**\n * ```ts\n * const queryClient = injectQueryClient();\n * ```\n */\nexport function injectQueryClient(\n  injectOptions: InjectOptions & { injector?: Injector } = {},\n) {\n  return (injectOptions.injector ?? inject(Injector)).get(QueryClient)\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAiBA,SAAgB,kBACd,gBAAyD,CAAC,GAC1D;CACA,QAAQ,cAAc,YAAY,OAAO,QAAQ,EAAA,CAAG,IAAI,WAAW;AACrE"}

package/{inject-query.d.ts → dist/inject-query.d.mts}

@@ -1,14 +1,15 @@
-import { Injector } from '@angular/core';
-import { DefaultError, QueryKey } from '@tanstack/query-core';
-import { CreateQueryOptions, CreateQueryResult, DefinedCreateQueryResult } from './types.js';
-import { DefinedInitialDataOptions, UndefinedInitialDataOptions } from './query-options.js';
+import { CreateQueryOptions, CreateQueryResult, DefinedCreateQueryResult } from "./types.mjs";
+import { DefinedInitialDataOptions, UndefinedInitialDataOptions } from "./query-options.mjs";
+import { Injector } from "@angular/core";
+import { DefaultError, QueryKey } from "@tanstack/query-core";
+//#region src/inject-query.d.ts
 export interface InjectQueryOptions {
-    /**
-     * The `Injector` in which to create the query.
-     *
-     * If this is not provided, the current injection context will be used instead (via `inject`).
-     */
-    injector?: Injector;
+  /**
+   * The `Injector` in which to create the query.
+   *
+   * If this is not provided, the current injection context will be used instead (via `inject`).
+   */
+  injector?: Injector;
 }
 /**
  * This overload is selected when `initialData` is set on the options returned by `injectQueryFn`, so the
@@ -139,3 +140,5 @@ export declare function injectQuery<TQueryFnData = unknown, TError = DefaultErro
  * @returns The query result.
  */
 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>;
+//#endregion
+//# sourceMappingURL=inject-query.d.mts.map

package/dist/inject-query.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-query.d.mts","names":[],"sources":["../src/inject-query.ts"],"mappings":";;;;;iBAmBiB;;;;;;EAMf,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA2CG,YACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,qBAAqB,0BACnB,cACA,QACA,OACA,YAEF,UAAU,qBACT,yBAAyB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA4EnB,YACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,qBAAqB,4BACnB,cACA,QACA,OACA,YAEF,UAAU,qBACT,kBAAkB,OAAO;;;;;;;;;;;;;wBAcZ,YACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,qBAAqB,mBACnB,cACA,QACA,OACA,YAEF,UAAU,qBACT,kBAAkB,OAAO"}

package/dist/inject-query.mjs

@@ -0,0 +1,12 @@
+import { createBaseQuery } from "./create-base-query.mjs";
+import { Injector, assertInInjectionContext, inject, runInInjectionContext } from "@angular/core";
+import { QueryObserver } from "@tanstack/query-core";
+//#region src/inject-query.ts
+function injectQuery(injectQueryFn, options) {
+	!options?.injector && assertInInjectionContext(injectQuery);
+	return runInInjectionContext(options?.injector ?? inject(Injector), () => createBaseQuery(injectQueryFn, QueryObserver));
+}
+//#endregion
+export { injectQuery };
+
+//# sourceMappingURL=inject-query.mjs.map

package/dist/inject-query.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-query.mjs","names":[],"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"],"mappings":";;;;AAuMA,SAAgB,YACd,eACA,SACA;CACA,CAAC,SAAS,YAAY,yBAAyB,WAAW;CAC1D,OAAO,sBAAsB,SAAS,YAAY,OAAO,QAAQ,SAC/D,gBAAgB,eAAe,aAAa,CAC9C;AACF"}

package/{mutation-options.d.ts → dist/mutation-options.d.mts}

@@ -1,5 +1,6 @@
-import { DefaultError, WithRequired } from '@tanstack/query-core';
-import { CreateMutationOptions } from './types.js';
+import { CreateMutationOptions } from "./types.mjs";
+import { DefaultError, WithRequired } from "@tanstack/query-core";
+//#region src/mutation-options.d.ts
 /**
  * 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
@@ -82,3 +83,5 @@ export declare function mutationOptions<TData = unknown, TError = DefaultError,
  * ```
  */
 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'>;
+//#endregion
+//# sourceMappingURL=mutation-options.d.mts.map

package/dist/mutation-options.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation-options.d.mts","names":[],"sources":["../src/mutation-options.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAuCgB,gBACd,iBACA,SAAS,cACT,mBACA,2BAEA,SAAS,aACP,sBAAsB,OAAO,QAAQ,YAAY,mCAGlD,aACD,sBAAsB,OAAO,QAAQ,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA+CnC,gBACd,iBACA,SAAS,cACT,mBACA,2BAEA,SAAS,KACP,sBAAsB,OAAO,QAAQ,YAAY,mCAGlD,KACD,sBAAsB,OAAO,QAAQ,YAAY"}

package/dist/mutation-options.mjs

@@ -0,0 +1,8 @@
+//#region src/mutation-options.ts
+function mutationOptions(options) {
+	return options;
+}
+//#endregion
+export { mutationOptions };
+
+//# sourceMappingURL=mutation-options.mjs.map

package/dist/mutation-options.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation-options.mjs","names":[],"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"],"mappings":";AA+GA,SAAgB,gBAMd,SACmE;CACnE,OAAO;AACT"}

package/dist/pending-tasks-compat.d.mts

@@ -0,0 +1,9 @@
+import { InjectionToken } from "@angular/core";
+//#region src/pending-tasks-compat.d.ts
+type PendingTasksCompat = {
+  add: () => PendingTaskRef;
+};
+export type PendingTaskRef = () => void;
+export declare const PENDING_TASKS: InjectionToken<PendingTasksCompat>;
+//#endregion
+//# sourceMappingURL=pending-tasks-compat.d.mts.map

package/dist/pending-tasks-compat.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pending-tasks-compat.d.mts","names":[],"sources":["../src/pending-tasks-compat.ts"],"mappings":";;KAIK;EAAuB,WAAW;;YAE3B;qBAEC,eAAa,eAAA"}

package/dist/pending-tasks-compat.mjs

@@ -0,0 +1,13 @@
+import * as ng from "@angular/core";
+import { InjectionToken, inject } from "@angular/core";
+import { noop } from "@tanstack/query-core";
+//#region src/pending-tasks-compat.ts
+const PENDING_TASKS = new InjectionToken("PENDING_TASKS", { factory: () => {
+	const token = Reflect.get(ng, "PendingTasks");
+	const svc = token ? inject(token, { optional: true }) : null;
+	return { add: svc ? () => svc.add() : () => noop };
+} });
+//#endregion
+export { PENDING_TASKS };
+
+//# sourceMappingURL=pending-tasks-compat.mjs.map

package/dist/pending-tasks-compat.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pending-tasks-compat.mjs","names":[],"sources":["../src/pending-tasks-compat.ts"],"sourcesContent":["import { InjectionToken, inject } from '@angular/core'\nimport * as ng from '@angular/core'\nimport { noop } from '@tanstack/query-core'\n\ntype PendingTasksCompat = { add: () => PendingTaskRef }\n\nexport type PendingTaskRef = () => void\n\nexport const PENDING_TASKS = new InjectionToken<PendingTasksCompat>(\n  'PENDING_TASKS',\n  {\n    factory: (): PendingTasksCompat => {\n      // Access via Reflect so bundlers stay quiet when the token is absent (Angular < 19).\n      const token = Reflect.get(ng, 'PendingTasks') as unknown as\n        Parameters<typeof inject>[0] | undefined\n\n      const svc: PendingTasksCompat | null = token\n        ? (inject(token, { optional: true }) as PendingTasksCompat | null)\n        : null\n\n      // Without PendingTasks we fall back to a stable no-op shim.\n      return {\n        add: svc ? () => svc.add() : () => noop,\n      }\n    },\n  },\n)\n"],"mappings":";;;;AAQA,MAAa,gBAAgB,IAAI,eAC/B,iBACA,EACE,eAAmC;CAEjC,MAAM,QAAQ,QAAQ,IAAI,IAAI,cAAc;CAG5C,MAAM,MAAiC,QAClC,OAAO,OAAO,EAAE,UAAU,KAAK,CAAC,IACjC;CAGJ,OAAO,EACL,KAAK,YAAY,IAAI,IAAI,UAAU,KACrC;AACF,EACF,CACF"}

package/{providers.d.ts → dist/providers.d.mts}

@@ -1,5 +1,6 @@
-import { InjectionToken, Provider } from '@angular/core';
-import { QueryClient } from '@tanstack/query-core';
+import { InjectionToken, Provider } from "@angular/core";
+import { QueryClient } from "@tanstack/query-core";
+//#region src/providers.d.ts
 /**
  * Usually {@link provideTanStackQuery} is used once to set up TanStack Query and the
  * [`QueryClient`](https://tanstack.com/query/latest/docs/reference/QueryClient) for the entire application —
@@ -97,8 +98,8 @@ type QueryFeatureKind = (typeof queryFeatures)[number];
  * Helper type to represent a Query feature.
  */
 export interface QueryFeature<TFeatureKind extends QueryFeatureKind> {
-    ɵkind: TFeatureKind;
-    ɵproviders: Array<Provider>;
+  ɵkind: TFeatureKind;
+  ɵproviders: Array<Provider>;
 }
 /**
  * Helper function to create an object that represents a Query feature.
@@ -126,4 +127,5 @@ export type PersistQueryClientFeature = QueryFeature<'PersistQueryClient'>;
  * @see {@link provideTanStackQuery}
  */
 export type QueryFeatures = DevtoolsFeature | PersistQueryClientFeature;
-export {};
+//#endregion
+//# sourceMappingURL=providers.d.mts.map

package/dist/providers.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.d.mts","names":[],"sources":["../src/providers.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;wBAqBgB,mBACd,aAAa,cAAc,eAAe,eACzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8Ea,qBACd,aAAa,cAAc,eAAe,iBACvC,UAAU,MAAM,iBAClB,MAAM;;;;;;;;;;wBAgBO,oBAAoB,aAAa,cAAc,MAAM;cAI/D;KAED,2BAA2B;;;;iBAKf,aAAa,qBAAqB;EACjD,OAAO;EACP,YAAY,MAAM;;;;;;;;wBASJ,aAAa,qBAAqB,kBAChD,MAAM,cACN,WAAW,MAAM,YAChB,aAAa;;;;;;YASJ,kBAAkB;;;;;YAMlB,4BAA4B;;;;;;;;YAS5B,gBAAgB,kBAAkB"}