@tanstack/angular-query-experimental 5.33.0 → 5.34.2

package/build/inject-query.d.ts

@@ -2,6 +2,105 @@ import type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core';
 import type { Injector } from '@angular/core';
 import type { CreateQueryOptions, CreateQueryResult, DefinedCreateQueryResult } from './types';
 import type { DefinedInitialDataOptions, UndefinedInitialDataOptions } from './query-options';
-export declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: (client: QueryClient) => UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, injector?: Injector): CreateQueryResult<TData, TError>;
-export declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: (client: QueryClient) => DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, injector?: Injector): DefinedCreateQueryResult<TData, TError>;
-export declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: (client: QueryClient) => CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, injector?: Injector): CreateQueryResult<TData, TError>;
+/**
+ * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
+ *
+ * **Basic example**
+ * ```ts
+ * class ServiceOrComponent {
+ *   query = injectQuery(() => ({
+ *     queryKey: ['repoData'],
+ *     queryFn: () =>
+ *       this.#http.get<Response>('https://api.github.com/repos/tanstack/query'),
+ *   }))
+ * }
+ * ```
+ *
+ * **The options function can utilize signals**
+ * ```ts
+ * class ServiceOrComponent {
+ *   filter = signal('')
+ *
+ *   todosQuery = injectQuery(() => ({
+ *     queryKey: ['todos', this.filter()],
+ *     queryFn: () => fetchTodos(this.filter()),
+ *     // Signals can be combined with expressions
+ *     enabled: !!this.filter(),
+ *   }))
+ * }
+ * ```
+ * @param optionsFn - A function that returns query options.
+ * @param injector - The Angular injector to use.
+ * @returns The query result.
+ * @public
+ * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
+ */
+export declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(optionsFn: (client: QueryClient) => DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, injector?: Injector): DefinedCreateQueryResult<TData, TError>;
+/**
+ * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
+ *
+ * **Basic example**
+ * ```ts
+ * class ServiceOrComponent {
+ *   query = injectQuery(() => ({
+ *     queryKey: ['repoData'],
+ *     queryFn: () =>
+ *       this.#http.get<Response>('https://api.github.com/repos/tanstack/query'),
+ *   }))
+ * }
+ * ```
+ *
+ * **The options function can utilize signals**
+ * ```ts
+ * class ServiceOrComponent {
+ *   filter = signal('')
+ *
+ *   todosQuery = injectQuery(() => ({
+ *     queryKey: ['todos', this.filter()],
+ *     queryFn: () => fetchTodos(this.filter()),
+ *     // Signals can be combined with expressions
+ *     enabled: !!this.filter(),
+ *   }))
+ * }
+ * ```
+ * @param optionsFn - A function that returns query options.
+ * @param injector - The Angular injector to use.
+ * @returns The query result.
+ * @public
+ * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
+ */
+export declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(optionsFn: (client: QueryClient) => UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, injector?: Injector): CreateQueryResult<TData, TError>;
+/**
+ * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
+ *
+ * **Basic example**
+ * ```ts
+ * class ServiceOrComponent {
+ *   query = injectQuery(() => ({
+ *     queryKey: ['repoData'],
+ *     queryFn: () =>
+ *       this.#http.get<Response>('https://api.github.com/repos/tanstack/query'),
+ *   }))
+ * }
+ * ```
+ *
+ * **The options function can utilize signals**
+ * ```ts
+ * class ServiceOrComponent {
+ *   filter = signal('')
+ *
+ *   todosQuery = injectQuery(() => ({
+ *     queryKey: ['todos', this.filter()],
+ *     queryFn: () => fetchTodos(this.filter()),
+ *     // Signals can be combined with expressions
+ *     enabled: !!this.filter(),
+ *   }))
+ * }
+ * ```
+ * @param optionsFn - A function that returns query options.
+ * @param injector - The Angular injector to use.
+ * @returns The query result.
+ * @public
+ * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
+ */
+export declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(optionsFn: (client: QueryClient) => CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, injector?: Injector): CreateQueryResult<TData, TError>;

package/build/providers.d.ts

@@ -1,3 +1,42 @@
 import type { EnvironmentProviders } from '@angular/core';
 import type { QueryClient } from '@tanstack/query-core';
+/**
+ * Sets up providers necessary to enable TanStack Query functionality for Angular applications.
+ *
+ * Allows to configure a `QueryClient`.
+ *
+ * **Example - standalone**
+ *
+ * ```ts
+ * import {
+ *   provideAngularQuery,
+ *   QueryClient,
+ * } from '@tanstack/angular-query-experimental'
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideAngularQuery(new QueryClient())],
+ * })
+ * ```
+ *
+ * **Example - NgModule-based**
+ *
+ * ```ts
+ * import {
+ *   provideAngularQuery,
+ *   QueryClient,
+ * } from '@tanstack/angular-query-experimental'
+ *
+ * @NgModule({
+ *   declarations: [AppComponent],
+ *   imports: [BrowserModule],
+ *   providers: [provideAngularQuery(new QueryClient())],
+ *   bootstrap: [AppComponent],
+ * })
+ * export class AppModule {}
+ * ```
+ * @param queryClient - A `QueryClient` instance.
+ * @returns A set of providers to set up TanStack Query.
+ * @public
+ * @see https://tanstack.com/query/v5/docs/framework/angular/quick-start
+ */
 export declare function provideAngularQuery(queryClient: QueryClient): EnvironmentProviders;

package/build/query-options.d.ts

@@ -1,15 +1,65 @@
 import type { DataTag, DefaultError, QueryKey } from '@tanstack/query-core';
 import type { CreateQueryOptions } from './types';
+/**
+ * @public
+ */
 export type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
     initialData?: undefined;
 };
 type NonUndefinedGuard<T> = T extends undefined ? never : T;
+/**
+ * @public
+ */
 export type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
     initialData: NonUndefinedGuard<TQueryFnData> | (() => NonUndefinedGuard<TQueryFnData>);
 };
+/**
+ * Allows to share and re-use query options in a type-safe way.
+ *
+ * The `queryKey` will be tagged with the type from `queryFn`.
+ *
+ * **Example**
+ *
+ * ```ts
+ *  const { queryKey } = queryOptions({
+ *     queryKey: ['key'],
+ *     queryFn: () => Promise.resolve(5),
+ *     //  ^?  Promise<number>
+ *   })
+ *
+ *   const queryClient = new QueryClient()
+ *   const data = queryClient.getQueryData(queryKey)
+ *   //    ^?  number | undefined
+ * ```
+ * @param options - The query options to tag with the type from `queryFn`.
+ * @returns The tagged query options.
+ * @public
+ */
 export declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {
     queryKey: DataTag<TQueryKey, TQueryFnData>;
 };
+/**
+ * Allows to share and re-use query options in a type-safe way.
+ *
+ * The `queryKey` will be tagged with the type from `queryFn`.
+ *
+ * **Example**
+ *
+ * ```ts
+ *  const { queryKey } = queryOptions({
+ *     queryKey: ['key'],
+ *     queryFn: () => Promise.resolve(5),
+ *     //  ^?  Promise<number>
+ *   })
+ *
+ *   const queryClient = new QueryClient()
+ *   const data = queryClient.getQueryData(queryKey)
+ *   //    ^?  number | undefined
+ * ```
+ * @param options - The query options to tag with the type from `queryFn`.
+ * @returns The tagged query options.
+ * @public
+ */
 export declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {
     queryKey: DataTag<TQueryKey, TQueryFnData>;
 };

package/build/signal-proxy.d.ts

@@ -4,10 +4,8 @@ export type MapToSignals<T> = {
 };
 /**
  * Exposes fields of an object passed via an Angular `Signal` as `Computed` signals.
- *
  * Functions on the object are passed through as-is.
- *
  * @param inputSignal - `Signal` that must return an object.
- *
+ * @returns A proxy object with the same fields as the input object, but with each field wrapped in a `Computed` signal.
  */
 export declare function signalProxy<TInput extends Record<string | symbol, any>>(inputSignal: Signal<TInput>): MapToSignals<TInput>;

package/build/types.d.ts

@@ -1,42 +1,93 @@
 import type { DefaultError, DefinedInfiniteQueryObserverResult, DefinedQueryObserverResult, InfiniteQueryObserverOptions, InfiniteQueryObserverResult, MutateFunction, MutationObserverOptions, MutationObserverResult, OmitKeyof, QueryKey, QueryObserverOptions, QueryObserverResult } from '@tanstack/query-core';
 import type { MapToSignals } from './signal-proxy';
+/**
+ * @public
+ */
 export interface CreateBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {
 }
+/**
+ * @public
+ */
 export interface CreateQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'suspense'> {
 }
+/**
+ * @public
+ */
 type CreateStatusBasedQueryResult<TStatus extends QueryObserverResult['status'], TData = unknown, TError = DefaultError> = Extract<QueryObserverResult<TData, TError>, {
     status: TStatus;
 }>;
+/**
+ * @public
+ */
 export interface BaseQueryNarrowing<TData = unknown, TError = DefaultError> {
     isSuccess: (this: CreateBaseQueryResult<TData, TError>) => this is CreateBaseQueryResult<TData, TError, CreateStatusBasedQueryResult<'success', TData, TError>>;
     isError: (this: CreateBaseQueryResult<TData, TError>) => this is CreateBaseQueryResult<TData, TError, CreateStatusBasedQueryResult<'error', TData, TError>>;
     isPending: (this: CreateBaseQueryResult<TData, TError>) => this is CreateBaseQueryResult<TData, TError, CreateStatusBasedQueryResult<'pending', TData, TError>>;
 }
+/**
+ * @public
+ */
 export interface CreateInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'suspense'> {
 }
+/**
+ * @public
+ */
 export type CreateBaseQueryResult<TData = unknown, TError = DefaultError, TState = QueryObserverResult<TData, TError>> = BaseQueryNarrowing<TData, TError> & MapToSignals<OmitKeyof<TState, keyof BaseQueryNarrowing, 'safely'>>;
+/**
+ * @public
+ */
 export type CreateQueryResult<TData = unknown, TError = DefaultError> = CreateBaseQueryResult<TData, TError>;
+/**
+ * @public
+ */
 export type DefinedCreateQueryResult<TData = unknown, TError = DefaultError, TDefinedQueryObserver = DefinedQueryObserverResult<TData, TError>> = MapToSignals<TDefinedQueryObserver>;
+/**
+ * @public
+ */
 export type CreateInfiniteQueryResult<TData = unknown, TError = DefaultError> = MapToSignals<InfiniteQueryObserverResult<TData, TError>>;
+/**
+ * @public
+ */
 export type DefinedCreateInfiniteQueryResult<TData = unknown, TError = DefaultError, TDefinedInfiniteQueryObserver = DefinedInfiniteQueryObserverResult<TData, TError>> = MapToSignals<TDefinedInfiniteQueryObserver>;
+/**
+ * @public
+ */
 export interface CreateMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TContext>, '_defaulted'> {
 }
+/**
+ * @public
+ */
 export type CreateMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TContext>>) => void;
+/**
+ * @public
+ */
 export type CreateMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = MutateFunction<TData, TError, TVariables, TContext>;
+/**
+ * @public
+ */
 export type CreateBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TContext>, {
     mutate: CreateMutateFunction<TData, TError, TVariables, TContext>;
 }> & {
     mutateAsync: CreateMutateAsyncFunction<TData, TError, TVariables, TContext>;
 };
+/**
+ * @public
+ */
 type CreateStatusBasedMutationResult<TStatus extends CreateBaseMutationResult['status'], TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown> = Extract<CreateBaseMutationResult<TData, TError, TVariables, TContext>, {
     status: TStatus;
 }>;
+/**
+ * @public
+ */
 export interface BaseMutationNarrowing<TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown> {
     isSuccess: (this: CreateMutationResult<TData, TError, TVariables, TContext>) => this is CreateMutationResult<TData, TError, TVariables, TContext, CreateStatusBasedMutationResult<'success', TData, TError, TVariables, TContext>>;
     isError: (this: CreateMutationResult<TData, TError, TVariables, TContext>) => this is CreateMutationResult<TData, TError, TVariables, TContext, CreateStatusBasedMutationResult<'error', TData, TError, TVariables, TContext>>;
     isPending: (this: CreateMutationResult<TData, TError, TVariables, TContext>) => this is CreateMutationResult<TData, TError, TVariables, TContext, CreateStatusBasedMutationResult<'pending', TData, TError, TVariables, TContext>>;
     isIdle: (this: CreateMutationResult<TData, TError, TVariables, TContext>) => this is CreateMutationResult<TData, TError, TVariables, TContext, CreateStatusBasedMutationResult<'idle', TData, TError, TVariables, TContext>>;
 }
+/**
+ * @public
+ */
 export type CreateMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown, TState = CreateStatusBasedMutationResult<CreateBaseMutationResult['status'], TData, TError, TVariables, TContext>> = BaseMutationNarrowing<TData, TError, TVariables, TContext> & MapToSignals<OmitKeyof<TState, keyof BaseMutationNarrowing, 'safely'>>;
 type Override<TTargetA, TTargetB> = {
     [AKey in keyof TTargetA]: AKey extends keyof TTargetB ? TTargetB[AKey] : TTargetA[AKey];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/angular-query-experimental",
-  "version": "5.33.0",
+  "version": "5.34.2",
   "description": "Signals for managing, caching and syncing asynchronous and remote data in Angular",
   "author": "Arnoud de Vries",
   "license": "MIT",
@@ -34,7 +34,7 @@
   ],
   "dependencies": {
     "tslib": "^2.6.2",
-    "@tanstack/query-core": "5.32.1"
+    "@tanstack/query-core": "5.34.2"
   },
   "devDependencies": {
     "@analogjs/vite-plugin-angular": "^1.1.2",

package/src/__tests__/inject-mutation-state.test.ts

@@ -3,7 +3,6 @@ import { QueryClient } from '@tanstack/query-core'
 import { TestBed } from '@angular/core/testing'
 import { describe, expect, test, vi } from 'vitest'
 import { By } from '@angular/platform-browser'
-import { JsonPipe } from '@angular/common'
 import { injectMutation } from '../inject-mutation'
 import { injectMutationState } from '../inject-mutation-state'
 import { provideAngularQuery } from '../providers'
@@ -139,7 +138,6 @@ describe('injectMutationState', () => {
           }
         `,
         standalone: true,
-        imports: [JsonPipe],
       })
       class FakeComponent {
         name = input.required<string>()

package/src/create-base-query.ts

@@ -31,7 +31,7 @@ export function createBaseQuery<
   TQueryData,
   TQueryKey extends QueryKey,
 >(
-  options: (
+  optionsFn: (
     client: QueryClient,
   ) => CreateBaseQueryOptions<
     TQueryFnData,
@@ -57,7 +57,7 @@ export function createBaseQuery<
        */
       const defaultedOptionsSignal = computed(() => {
         const defaultedOptions = queryClient.defaultQueryOptions(
-          options(queryClient),
+          optionsFn(queryClient),
         )
         defaultedOptions._optimisticResults = 'optimistic'
         return defaultedOptions

package/src/index.ts

@@ -20,9 +20,5 @@ export * from './inject-mutation'
 export * from './inject-mutation-state'
 export * from './inject-queries'
 export * from './inject-query'
-export {
-  injectQueryClient,
-  provideQueryClient,
-  QUERY_CLIENT,
-} from './inject-query-client'
+export { injectQueryClient, provideQueryClient } from './inject-query-client'
 export { provideAngularQuery } from './providers'

package/src/infinite-query-options.ts

@@ -41,6 +41,14 @@ export type DefinedInitialDataInfiniteOptions<
     | (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>)
 }
 
+/**
+ * Allows to share and re-use infinite query options in a type-safe way.
+ *
+ * The `queryKey` will be tagged with the type from `queryFn`.
+ * @param options - The infinite query options to tag with the type from `queryFn`.
+ * @returns The tagged infinite query options.
+ * @public
+ */
 export function infiniteQueryOptions<
   TQueryFnData,
   TError = DefaultError,
@@ -65,6 +73,14 @@ export function infiniteQueryOptions<
   queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>>
 }
 
+/**
+ * Allows to share and re-use infinite query options in a type-safe way.
+ *
+ * The `queryKey` will be tagged with the type from `queryFn`.
+ * @param options - The infinite query options to tag with the type from `queryFn`.
+ * @returns The tagged infinite query options.
+ * @public
+ */
 export function infiniteQueryOptions<
   TQueryFnData,
   TError = DefaultError,
@@ -89,6 +105,14 @@ export function infiniteQueryOptions<
   queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>>
 }
 
+/**
+ * Allows to share and re-use infinite query options in a type-safe way.
+ *
+ * The `queryKey` will be tagged with the type from `queryFn`.
+ * @param options - The infinite query options to tag with the type from `queryFn`.
+ * @returns The tagged infinite query options.
+ * @public
+ */
 export function infiniteQueryOptions(options: unknown) {
   return options
 }

package/src/inject-infinite-query.ts

@@ -20,6 +20,14 @@ import type {
   UndefinedInitialDataInfiniteOptions,
 } from './infinite-query-options'
 
+/**
+ * Injects an infinite query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
+ * Infinite queries can additively "load more" data onto an existing set of data or "infinite scroll"
+ * @param optionsFn - A function that returns infinite query options.
+ * @param injector - The Angular injector to use.
+ * @returns The infinite query result.
+ * @public
+ */
 export function injectInfiniteQuery<
   TQueryFnData,
   TError = DefaultError,
@@ -27,7 +35,7 @@ export function injectInfiniteQuery<
   TQueryKey extends QueryKey = QueryKey,
   TPageParam = unknown,
 >(
-  options: (
+  optionsFn: (
     client: QueryClient,
   ) => UndefinedInitialDataInfiniteOptions<
     TQueryFnData,
@@ -39,6 +47,14 @@ export function injectInfiniteQuery<
   injector?: Injector,
 ): CreateInfiniteQueryResult<TData, TError>
 
+/**
+ * Injects an infinite query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
+ * Infinite queries can additively "load more" data onto an existing set of data or "infinite scroll"
+ * @param optionsFn - A function that returns infinite query options.
+ * @param injector - The Angular injector to use.
+ * @returns The infinite query result.
+ * @public
+ */
 export function injectInfiniteQuery<
   TQueryFnData,
   TError = DefaultError,
@@ -46,7 +62,7 @@ export function injectInfiniteQuery<
   TQueryKey extends QueryKey = QueryKey,
   TPageParam = unknown,
 >(
-  options: (
+  optionsFn: (
     client: QueryClient,
   ) => DefinedInitialDataInfiniteOptions<
     TQueryFnData,
@@ -58,6 +74,14 @@ export function injectInfiniteQuery<
   injector?: Injector,
 ): DefinedCreateInfiniteQueryResult<TData, TError>
 
+/**
+ * Injects an infinite query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
+ * Infinite queries can additively "load more" data onto an existing set of data or "infinite scroll"
+ * @param optionsFn - A function that returns infinite query options.
+ * @param injector - The Angular injector to use.
+ * @returns The infinite query result.
+ * @public
+ */
 export function injectInfiniteQuery<
   TQueryFnData,
   TError = DefaultError,
@@ -65,7 +89,7 @@ export function injectInfiniteQuery<
   TQueryKey extends QueryKey = QueryKey,
   TPageParam = unknown,
 >(
-  options: (
+  optionsFn: (
     client: QueryClient,
   ) => CreateInfiniteQueryOptions<
     TQueryFnData,
@@ -78,14 +102,22 @@ export function injectInfiniteQuery<
   injector?: Injector,
 ): CreateInfiniteQueryResult<TData, TError>
 
+/**
+ * Injects an infinite query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
+ * Infinite queries can additively "load more" data onto an existing set of data or "infinite scroll"
+ * @param optionsFn - A function that returns infinite query options.
+ * @param injector - The Angular injector to use.
+ * @returns The infinite query result.
+ * @public
+ */
 export function injectInfiniteQuery(
-  options: (client: QueryClient) => CreateInfiniteQueryOptions,
+  optionsFn: (client: QueryClient) => CreateInfiniteQueryOptions,
   injector?: Injector,
 ) {
   return assertInjector(injectInfiniteQuery, injector, () => {
     const queryClient = injectQueryClient()
     return createBaseQuery(
-      options,
+      optionsFn,
       InfiniteQueryObserver as typeof QueryObserver,
       queryClient,
     )

package/src/inject-is-fetching.ts

@@ -4,6 +4,16 @@ import { assertInjector } from './util/assert-injector/assert-injector'
 import { injectQueryClient } from './inject-query-client'
 import type { Injector, Signal } from '@angular/core'
 
+/**
+ * Injects a signal that tracks the number of queries that your application is loading or
+ * fetching in the background.
+ *
+ * Can be used for app-wide loading indicators
+ * @param filters - The filters to apply to the query.
+ * @param injector - The Angular injector to use.
+ * @returns signal with number of loading or fetching queries.
+ * @public
+ */
 export function injectIsFetching(
   filters?: QueryFilters,
   injector?: Injector,

package/src/inject-is-mutating.ts

@@ -4,6 +4,15 @@ import { assertInjector } from './util/assert-injector/assert-injector'
 import { injectQueryClient } from './inject-query-client'
 import type { Injector, Signal } from '@angular/core'
 
+/**
+ * Injects a signal that tracks the number of mutations that your application is fetching.
+ *
+ * Can be used for app-wide loading indicators
+ * @param filters - The filters to apply to the query.
+ * @param injector - The Angular injector to use.
+ * @returns signal with number of fetching mutations.
+ * @public
+ */
 export function injectIsMutating(
   filters?: MutationFilters,
   injector?: Injector,

package/src/inject-mutation-state.ts

@@ -43,10 +43,20 @@ function getResult<TResult = MutationState>(
     )
 }
 
+/**
+ * @public
+ */
 export interface InjectMutationStateOptions {
   injector?: Injector
 }
 
+/**
+ * Injects a signal that tracks the state of all mutations.
+ * @param mutationStateOptionsFn - A function that returns mutation state options.
+ * @param options - The Angular injector to use.
+ * @returns The signal that tracks the state of all mutations.
+ * @public
+ */
 export function injectMutationState<TResult = MutationState>(
   mutationStateOptionsFn: () => MutationStateOptions<TResult> = () => ({}),
   options?: InjectMutationStateOptions,

package/src/inject-mutation.ts

@@ -26,13 +26,22 @@ import type {
   CreateMutationResult,
 } from './types'
 
+/**
+ * Injects a mutation: an imperative function that can be invoked which typically performs server side effects.
+ *
+ * Unlike queries, mutations are not run automatically.
+ * @param optionsFn - A function that returns mutation options.
+ * @param injector - The Angular injector to use.
+ * @returns The mutation.
+ * @public
+ */
 export function injectMutation<
   TData = unknown,
   TError = DefaultError,
   TVariables = void,
   TContext = unknown,
 >(
-  options: (
+  optionsFn: (
     client: QueryClient,
   ) => CreateMutationOptions<TData, TError, TVariables, TContext>,
   injector?: Injector,
@@ -50,7 +59,7 @@ export function injectMutation<
           TError,
           TVariables,
           TContext
-        >(queryClient, options(queryClient))
+        >(queryClient, optionsFn(queryClient))
         const mutate: CreateMutateFunction<
           TData,
           TError,
@@ -61,7 +70,7 @@ export function injectMutation<
         }
 
         effect(() => {
-          observer.setOptions(options(queryClient))
+          observer.setOptions(optionsFn(queryClient))
         })
 
         const result = signal(observer.getCurrentResult())

package/src/inject-queries.ts

@@ -119,6 +119,7 @@ type GetResults<T> =
 
 /**
  * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
+ * @public
  */
 export type QueriesOptions<
   T extends Array<any>,
@@ -161,6 +162,7 @@ export type QueriesOptions<
 
 /**
  * QueriesResults reducer recursively maps type param to results
+ * @public
  */
 export type QueriesResults<
   T extends Array<any>,
@@ -196,6 +198,9 @@ export type QueriesResults<
           : // Fallback
             Array<QueryObserverResult>
 
+/**
+ * @public
+ */
 export function injectQueries<
   T extends Array<any>,
   TCombinedResult = QueriesResults<T>,