@tanstack/angular-query-experimental 5.103.1 → 5.103.3

package/dist/inject-mutation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-mutation.mjs","names":[],"sources":["../src/inject-mutation.ts"],"sourcesContent":["import {\n  Injector,\n  NgZone,\n  assertInInjectionContext,\n  computed,\n  effect,\n  inject,\n  signal,\n  untracked,\n} from '@angular/core'\nimport {\n  MutationObserver,\n  QueryClient,\n  noop,\n  notifyManager,\n  shouldThrowError,\n} from '@tanstack/query-core'\nimport { signalProxy } from './signal-proxy'\nimport { PENDING_TASKS } from './pending-tasks-compat'\nimport type { PendingTaskRef } from './pending-tasks-compat'\nimport type { DefaultError, MutationObserverResult } from '@tanstack/query-core'\nimport type {\n  CreateMutateFunction,\n  CreateMutationOptions,\n  CreateMutationResult,\n} from './types'\n\nexport interface InjectMutationOptions {\n  /**\n   * The `Injector` in which to create the mutation.\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 * Unlike queries, mutations are typically used to create/update/delete data or perform server side-effects.\n * `injectMutation` is the function for that. Unlike queries, mutations are not run automatically.\n *\n * @remarks `mutate`/`mutateAsync` also accept per-call `onSuccess`/`onError`/`onSettled` callbacks as a\n * second argument, useful for triggering call-site side effects (e.g. navigation) without coupling them to\n * the shared mutation definition. Callbacks defined in `injectMutationFn` fire for every mutation; per-call\n * callbacks fire only for the latest call you've made — `mutateAsync` gives you a promise per call instead,\n * so you can await `Promise.all`/`Promise.allSettled` over several calls and see each one's outcome.\n * @see {@link mutationOptions} to share these options across multiple `injectMutation` call sites, or to look\n * the mutation up elsewhere via its `mutationKey` (e.g. with `injectMutationState`).\n * @param injectMutationFn - A function that returns mutation options. Similar to `computed` from Angular,\n * this function runs in the reactive context, so signals read inside it drive the mutation's options.\n * @param options - Additional configuration\n * @returns The mutation result. Value fields are exposed as a `Signal` — read `data`/`error` by calling them\n * (e.g. `mutation.data()`) — while function fields (`mutate`, `mutateAsync`, `reset`) are called directly,\n * unchanged. `isSuccess`/`isError`/`isPending`/`isIdle` are type-guard methods you can call to narrow whether\n * `data` is defined.\n *\n * @example\n * ```angular-ts\n * @Component({\n *   selector: 'todos',\n *   template: `\n *     @if (addMutation.isPending()) {\n *       <span>Adding todo...</span>\n *     } @else if (addMutation.isError()) {\n *       <div>An error occurred: {{ addMutation.error()?.message }}</div>\n *     }\n *     <button (click)=\"addMutation.mutate('Item')\">Add</button>\n *   `,\n * })\n * export class Todos {\n *   readonly #queryClient = inject(QueryClient)\n *\n *   readonly addMutation = injectMutation(() => ({\n *     mutationFn: addTodo,\n *     onSuccess: () => this.#queryClient.invalidateQueries({ queryKey: ['todos'] }),\n *   }))\n * }\n * ```\n *\n * @example\n * Optimistic update via `onMutate`, rolling back on `onError`:\n * ```angular-ts\n * @Component({\n *   selector: 'todos',\n *   template: `<button (click)=\"addMutation.mutate('Item')\">Add</button>`,\n * })\n * export class Todos {\n *   readonly #queryClient = inject(QueryClient)\n *\n *   readonly addMutation = injectMutation(() => ({\n *     mutationFn: addTodo,\n *     onMutate: async (newTodo) => {\n *       await this.#queryClient.cancelQueries({ queryKey: ['todos'] })\n *       const previousTodos = this.#queryClient.getQueryData<Array<string>>(['todos'])\n *\n *       this.#queryClient.setQueryData<Array<string>>(['todos'], (old) => [\n *         ...(old ?? []),\n *         newTodo,\n *       ])\n *\n *       // Passed to `onError` as `onMutateResult` if the mutation fails.\n *       return { previousTodos }\n *     },\n *     onError: (_err, _newTodo, onMutateResult) => {\n *       this.#queryClient.setQueryData(['todos'], onMutateResult?.previousTodos)\n *     },\n *     onSettled: () => {\n *       this.#queryClient.invalidateQueries({ queryKey: ['todos'] })\n *     },\n *   }))\n * }\n * ```\n *\n * @example\n * Callbacks passed per call to `mutate` only fire for the last call — `mutateAsync` gives you a promise per\n * call instead, so you can wait for all of them when they succeed:\n * ```angular-ts\n * @Component({\n *   selector: 'todos',\n *   template: `\n *     <button (click)=\"handleAddAll(['Todo 1', 'Todo 2', 'Todo 3'])\">Add all</button>\n *   `,\n * })\n * export class Todos {\n *   readonly #queryClient = inject(QueryClient)\n *\n *   readonly addMutation = injectMutation(() => ({\n *     mutationFn: addTodo,\n *     onSuccess: () => this.#queryClient.invalidateQueries({ queryKey: ['todos'] }),\n *   }))\n *\n *   async handleAddAll(todos: Array<string>) {\n *     try {\n *       await Promise.all(todos.map((todo) => this.addMutation.mutateAsync(todo)))\n *     } catch (error) {\n *       console.error('Failed to add todos:', error)\n *     }\n *   }\n * }\n * ```\n *\n * @example\n * If some of the mutations above can fail independently of the others, and you want to know which ones did —\n * rather than losing that information the moment the first one rejects — swap `Promise.all` for\n * `Promise.allSettled`:\n * ```angular-ts\n * @Component({\n *   selector: 'todos',\n *   template: `\n *     <button (click)=\"handleAddAll(['Todo 1', 'Todo 2', 'Todo 3'])\">Add all</button>\n *   `,\n * })\n * export class Todos {\n *   readonly #queryClient = inject(QueryClient)\n *\n *   readonly addMutation = injectMutation(() => ({\n *     mutationFn: addTodo,\n *     onSuccess: () => this.#queryClient.invalidateQueries({ queryKey: ['todos'] }),\n *   }))\n *\n *   async handleAddAll(todos: Array<string>) {\n *     const addResults = await Promise.allSettled(\n *       todos.map((todo) => this.addMutation.mutateAsync(todo)),\n *     )\n *\n *     addResults.forEach((addResult, index) => {\n *       if (addResult.status === 'rejected') {\n *         console.error(`Failed to add \"${todos[index]}\":`, addResult.reason)\n *       }\n *     })\n *   }\n * }\n * ```\n */\nexport function injectMutation<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n>(\n  injectMutationFn: () => CreateMutationOptions<\n    TData,\n    TError,\n    TVariables,\n    TOnMutateResult\n  >,\n  options?: InjectMutationOptions,\n): CreateMutationResult<TData, TError, TVariables, TOnMutateResult> {\n  !options?.injector && assertInInjectionContext(injectMutation)\n  const injector = options?.injector ?? inject(Injector)\n  const ngZone = injector.get(NgZone)\n  const pendingTasks = injector.get(PENDING_TASKS)\n  const queryClient = injector.get(QueryClient)\n\n  /**\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(injectMutationFn)\n\n  const observerSignal = (() => {\n    let instance: MutationObserver<\n      TData,\n      TError,\n      TVariables,\n      TOnMutateResult\n    > | null = null\n\n    return computed(() => {\n      return (instance ||= new MutationObserver(queryClient, optionsSignal()))\n    })\n  })()\n\n  const mutateFnSignal = computed<\n    CreateMutateFunction<TData, TError, TVariables, TOnMutateResult>\n  >(() => {\n    const observer = observerSignal()\n    return (\n      ...args: Parameters<\n        CreateMutateFunction<TData, TError, TVariables, TOnMutateResult>\n      >\n    ) => {\n      observer.mutate(args[0] as TVariables, args[1]).catch(noop)\n    }\n  })\n\n  /**\n   * Computed signal that gets result from mutation cache based on passed options\n   */\n  const resultFromInitialOptionsSignal = computed(() => {\n    const observer = observerSignal()\n    return observer.getCurrentResult()\n  })\n\n  /**\n   * Signal that contains result set by subscriber\n   */\n  const resultFromSubscriberSignal = signal<MutationObserverResult<\n    TData,\n    TError,\n    TVariables,\n    TOnMutateResult\n  > | null>(null)\n\n  effect(\n    () => {\n      const observer = observerSignal()\n      const observerOptions = optionsSignal()\n\n      untracked(() => {\n        observer.setOptions(observerOptions)\n      })\n    },\n    {\n      injector,\n    },\n  )\n\n  effect(\n    (onCleanup) => {\n      // observer.trackResult is not used as this optimization is not needed for Angular\n      const observer = observerSignal()\n      let pendingTaskRef: PendingTaskRef | null = null\n\n      untracked(() => {\n        const unsubscribe = ngZone.runOutsideAngular(() =>\n          observer.subscribe(\n            notifyManager.batchCalls((state) => {\n              ngZone.run(() => {\n                // Track pending task when mutation is pending\n                if (state.isPending && !pendingTaskRef) {\n                  pendingTaskRef = pendingTasks.add()\n                }\n\n                // Clear pending task when mutation is no longer pending\n                if (!state.isPending && pendingTaskRef) {\n                  pendingTaskRef()\n                  pendingTaskRef = null\n                }\n\n                if (\n                  state.isError &&\n                  shouldThrowError(observer.options.throwOnError, [state.error])\n                ) {\n                  ngZone.onError.emit(state.error)\n                  throw state.error\n                }\n\n                resultFromSubscriberSignal.set(state)\n              })\n            }),\n          ),\n        )\n        onCleanup(() => {\n          // Clean up any pending task on destroy\n          if (pendingTaskRef) {\n            pendingTaskRef()\n            pendingTaskRef = null\n          }\n          unsubscribe()\n        })\n      })\n    },\n    {\n      injector,\n    },\n  )\n\n  const resultSignal = computed(() => {\n    const resultFromSubscriber = resultFromSubscriberSignal()\n    const resultFromInitialOptions = resultFromInitialOptionsSignal()\n\n    const result = resultFromSubscriber ?? resultFromInitialOptions\n\n    return {\n      ...result,\n      mutate: mutateFnSignal(),\n      mutateAsync: result.mutate,\n    }\n  })\n\n  return signalProxy(resultSignal) as CreateMutationResult<\n    TData,\n    TError,\n    TVariables,\n    TOnMutateResult\n  >\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6KA,SAAgB,eAMd,kBAMA,SACkE;CAClE,CAAC,SAAS,YAAY,yBAAyB,cAAc;CAC7D,MAAM,WAAW,SAAS,YAAY,OAAO,QAAQ;CACrD,MAAM,SAAS,SAAS,IAAI,MAAM;CAClC,MAAM,eAAe,SAAS,IAAI,aAAa;CAC/C,MAAM,cAAc,SAAS,IAAI,WAAW;;;;;;CAO5C,MAAM,gBAAgB,SAAS,gBAAgB;CAE/C,MAAM,wBAAwB;EAC5B,IAAI,WAKO;EAEX,OAAO,eAAe;GACpB,OAAQ,aAAa,IAAI,iBAAiB,aAAa,cAAc,CAAC;EACxE,CAAC;CACH,EAAA,CAAG;CAEH,MAAM,iBAAiB,eAEf;EACN,MAAM,WAAW,eAAe;EAChC,QACE,GAAG,SAGA;GACH,SAAS,OAAO,KAAK,IAAkB,KAAK,EAAE,CAAC,CAAC,MAAM,IAAI;EAC5D;CACF,CAAC;;;;CAKD,MAAM,iCAAiC,eAAe;EAEpD,OADiB,eACH,CAAC,CAAC,iBAAiB;CACnC,CAAC;;;;CAKD,MAAM,6BAA6B,OAKzB,IAAI;CAEd,aACQ;EACJ,MAAM,WAAW,eAAe;EAChC,MAAM,kBAAkB,cAAc;EAEtC,gBAAgB;GACd,SAAS,WAAW,eAAe;EACrC,CAAC;CACH,GACA,EACE,SACF,CACF;CAEA,QACG,cAAc;EAEb,MAAM,WAAW,eAAe;EAChC,IAAI,iBAAwC;EAE5C,gBAAgB;GACd,MAAM,cAAc,OAAO,wBACzB,SAAS,UACP,cAAc,YAAY,UAAU;IAClC,OAAO,UAAU;KAEf,IAAI,MAAM,aAAa,CAAC,gBACtB,iBAAiB,aAAa,IAAI;KAIpC,IAAI,CAAC,MAAM,aAAa,gBAAgB;MACtC,eAAe;MACf,iBAAiB;KACnB;KAEA,IACE,MAAM,WACN,iBAAiB,SAAS,QAAQ,cAAc,CAAC,MAAM,KAAK,CAAC,GAC7D;MACA,OAAO,QAAQ,KAAK,MAAM,KAAK;MAC/B,MAAM,MAAM;KACd;KAEA,2BAA2B,IAAI,KAAK;IACtC,CAAC;GACH,CAAC,CACH,CACF;GACA,gBAAgB;IAEd,IAAI,gBAAgB;KAClB,eAAe;KACf,iBAAiB;IACnB;IACA,YAAY;GACd,CAAC;EACH,CAAC;CACH,GACA,EACE,SACF,CACF;CAEA,MAAM,eAAe,eAAe;EAClC,MAAM,uBAAuB,2BAA2B;EACxD,MAAM,2BAA2B,+BAA+B;EAEhE,MAAM,SAAS,wBAAwB;EAEvC,OAAO;GACL,GAAG;GACH,QAAQ,eAAe;GACvB,aAAa,OAAO;EACtB;CACF,CAAC;CAED,OAAO,YAAY,YAAY;AAMjC"}

package/dist/inject-queries-experimental/index.d.mts

@@ -0,0 +1,2 @@
+import { InjectQueriesOptions, QueriesOptions, QueriesResults, injectQueries } from "../inject-queries.mjs";
+export { InjectQueriesOptions, QueriesOptions, QueriesResults, injectQueries };

package/dist/inject-queries-experimental/index.mjs

@@ -0,0 +1,2 @@
+import { injectQueries } from "../inject-queries.mjs";
+export { injectQueries };

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>;
+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 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;
+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]>; };
+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;
 }
 /**
  * Injects a signal to fetch a variable number of queries.
@@ -226,5 +205,7 @@ 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 {};
+declare function injectQueries<T extends Array<any>, TCombinedResult = QueriesResults<T>>(optionsFn: () => InjectQueriesOptions<T, TCombinedResult>, injector?: Injector): Signal<TCombinedResult>;
+//#endregion
+export { InjectQueriesOptions, QueriesOptions, QueriesResults, injectQueries };
+//# 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;;;;;;;;;;;;;;KAeN,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;;;;;;;;;;;;;KAcR,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;UAElC,qBACf,UAAU,YACV,kBAAkB,eAAe;EAEjC,sBACiB,eAAe,sBAEpB,WAAW,IAAI,sCAAsC,EAAE;EAEnE,WAAW,QAAQ,eAAe,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyI3B,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        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;IAEJ,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.
@@ -13,6 +14,9 @@ import { QueryClient } from '@tanstack/query-core';
  * const queryClient = injectQueryClient();
  * ```
  */
-export declare function injectQueryClient(injectOptions?: InjectOptions & {
-    injector?: Injector;
+declare function injectQueryClient(injectOptions?: InjectOptions & {
+  injector?: Injector;
 }): QueryClient;
+//#endregion
+export { injectQueryClient };
+//# 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":";;;;;;;;;;;;;;;;iBAiBgB,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';
-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;
+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
+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;
 }
 /**
  * This overload is selected when `initialData` is set on the options returned by `injectQueryFn`, so the
@@ -50,7 +51,7 @@ export interface InjectQueryOptions {
  * }
  * ```
  */
-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>;
+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.
  *
@@ -125,7 +126,7 @@ export declare function injectQuery<TQueryFnData = unknown, TError = DefaultErro
  * }
  * ```
  */
-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>;
+declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(injectQueryFn: () => UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, options?: InjectQueryOptions): CreateQueryResult<TData, TError>;
 /**
  * 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
@@ -138,4 +139,7 @@ export declare function injectQuery<TQueryFnData = unknown, TError = DefaultErro
  * @param options - Additional configuration
  * @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>;
+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
+export { InjectQueryOptions, injectQuery };
+//# 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":";;;;;UAmBiB;;;;;;EAMf,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2CG,YACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,qBAAqB,0BACnB,cACA,QACA,OACA,YAEF,UAAU,qBACT,yBAAyB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4EnB,YACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,qBAAqB,4BACnB,cACA,QACA,OACA,YAEF,UAAU,qBACT,kBAAkB,OAAO;;;;;;;;;;;;;iBAcZ,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
@@ -36,7 +37,7 @@ import { CreateMutationOptions } from './types.js';
  * }
  * ```
  */
-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'>;
+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
@@ -81,4 +82,7 @@ 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'>;
+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
+export { mutationOptions };
+//# 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuCgB,gBACd,iBACA,SAAS,cACT,mBACA,2BAEA,SAAS,aACP,sBAAsB,OAAO,QAAQ,YAAY,mCAGlD,aACD,sBAAsB,OAAO,QAAQ,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+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