@tanstack/angular-query-experimental 5.72.1 → 5.72.3

package/src/inject-mutation-state.ts

@@ -18,6 +18,11 @@ type MutationStateOptions<TResult = MutationState> = {
   select?: (mutation: Mutation) => TResult
 }
 
+/**
+ *
+ * @param mutationCache
+ * @param options
+ */
 function getResult<TResult = MutationState>(
   mutationCache: MutationCache,
   options: MutationStateOptions<TResult>,
@@ -34,18 +39,23 @@ function getResult<TResult = MutationState>(
  * @public
  */
 export interface InjectMutationStateOptions {
+  /**
+   * The `Injector` in which to create the mutation state signal.
+   *
+   * If this is not provided, the current injection context will be used instead (via `inject`).
+   */
   injector?: Injector
 }
 
 /**
  * Injects a signal that tracks the state of all mutations.
- * @param mutationStateOptionsFn - A function that returns mutation state options.
+ * @param injectMutationStateFn - 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> = () => ({}),
+  injectMutationStateFn: () => MutationStateOptions<TResult> = () => ({}),
   options?: InjectMutationStateOptions,
 ): Signal<Array<TResult>> {
   return assertInjector(injectMutationState, options?.injector, () => {
@@ -61,7 +71,7 @@ export function injectMutationState<TResult = MutationState>(
      */
     const resultFromOptionsSignal = computed(() => {
       return [
-        getResult(mutationCache, mutationStateOptionsFn()),
+        getResult(mutationCache, injectMutationStateFn()),
         performance.now(),
       ] as const
     })
@@ -91,7 +101,7 @@ export function injectMutationState<TResult = MutationState>(
           const [lastResult] = effectiveResultSignal()
           const nextResult = replaceEqualDeep(
             lastResult,
-            getResult(mutationCache, mutationStateOptionsFn()),
+            getResult(mutationCache, injectMutationStateFn()),
           )
           if (lastResult !== nextResult) {
             ngZone.run(() => {

package/src/inject-mutation.ts

@@ -20,12 +20,21 @@ import type { DefaultError, MutationObserverResult } from '@tanstack/query-core'
 import type { CreateMutateFunction, CreateMutationResult } from './types'
 import type { CreateMutationOptions } from './mutation-options'
 
+export interface InjectMutationOptions {
+  /**
+   * The `Injector` in which to create the mutation.
+   *
+   * If this is not provided, the current injection context will be used instead (via `inject`).
+   */
+  injector?: Injector
+}
+
 /**
  * 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.
+ * @param injectMutationFn - A function that returns mutation options.
+ * @param options - Additional configuration
  * @returns The mutation.
  * @public
  */
@@ -35,10 +44,15 @@ export function injectMutation<
   TVariables = void,
   TContext = unknown,
 >(
-  optionsFn: () => CreateMutationOptions<TData, TError, TVariables, TContext>,
-  injector?: Injector,
+  injectMutationFn: () => CreateMutationOptions<
+    TData,
+    TError,
+    TVariables,
+    TContext
+  >,
+  options?: InjectMutationOptions,
 ): CreateMutationResult<TData, TError, TVariables, TContext> {
-  return assertInjector(injectMutation, injector, () => {
+  return assertInjector(injectMutation, options?.injector, () => {
     const destroyRef = inject(DestroyRef)
     const ngZone = inject(NgZone)
     const queryClient = inject(QueryClient)
@@ -48,7 +62,7 @@ export function injectMutation<
      * making it reactive. Wrapping options in a function ensures embedded expressions
      * are preserved and can keep being applied after signal changes
      */
-    const optionsSignal = computed(optionsFn)
+    const optionsSignal = computed(injectMutationFn)
 
     const observerSignal = (() => {
       let instance: MutationObserver<
@@ -93,14 +107,14 @@ export function injectMutation<
     effect(
       () => {
         const observer = observerSignal()
-        const options = optionsSignal()
+        const observerOptions = optionsSignal()
 
         untracked(() => {
-          observer.setOptions(options)
+          observer.setOptions(observerOptions)
         })
       },
       {
-        injector,
+        injector: options?.injector,
       },
     )
 
@@ -133,7 +147,7 @@ export function injectMutation<
         })
       },
       {
-        injector,
+        injector: options?.injector,
       },
     )
 

package/src/inject-queries.ts

@@ -197,6 +197,7 @@ export type QueriesResults<
  * @param root0.queries
  * @param root0.combine
  * @param injector
+ * @param injector
  * @public
  */
 export function injectQueries<

package/src/inject-query.ts

@@ -13,6 +13,15 @@ import type {
   UndefinedInitialDataOptions,
 } from './query-options'
 
+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
+}
+
 /**
  * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
  *
@@ -44,8 +53,8 @@ import type {
  *   }))
  * }
  * ```
- * @param optionsFn - A function that returns query options.
- * @param injector - The Angular injector to use.
+ * @param injectQueryFn - A function that returns query options.
+ * @param options - Additional configuration
  * @returns The query result.
  * @public
  * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
@@ -56,13 +65,13 @@ export function injectQuery<
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
 >(
-  optionsFn: () => DefinedInitialDataOptions<
+  injectQueryFn: () => DefinedInitialDataOptions<
     TQueryFnData,
     TError,
     TData,
     TQueryKey
   >,
-  injector?: Injector,
+  options?: InjectQueryOptions,
 ): DefinedCreateQueryResult<TData, TError>
 
 /**
@@ -96,8 +105,8 @@ export function injectQuery<
  *   }))
  * }
  * ```
- * @param optionsFn - A function that returns query options.
- * @param injector - The Angular injector to use.
+ * @param injectQueryFn - A function that returns query options.
+ * @param options - Additional configuration
  * @returns The query result.
  * @public
  * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
@@ -108,13 +117,13 @@ export function injectQuery<
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
 >(
-  optionsFn: () => UndefinedInitialDataOptions<
+  injectQueryFn: () => UndefinedInitialDataOptions<
     TQueryFnData,
     TError,
     TData,
     TQueryKey
   >,
-  injector?: Injector,
+  options?: InjectQueryOptions,
 ): CreateQueryResult<TData, TError>
 
 /**
@@ -148,8 +157,8 @@ export function injectQuery<
  *   }))
  * }
  * ```
- * @param optionsFn - A function that returns query options.
- * @param injector - The Angular injector to use.
+ * @param injectQueryFn - A function that returns query options.
+ * @param options - Additional configuration
  * @returns The query result.
  * @public
  * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
@@ -160,8 +169,13 @@ export function injectQuery<
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
 >(
-  optionsFn: () => CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-  injector?: Injector,
+  injectQueryFn: () => CreateQueryOptions<
+    TQueryFnData,
+    TError,
+    TData,
+    TQueryKey
+  >,
+  options?: InjectQueryOptions,
 ): CreateQueryResult<TData, TError>
 
 /**
@@ -195,17 +209,17 @@ export function injectQuery<
  *   }))
  * }
  * ```
- * @param optionsFn - A function that returns query options.
- * @param injector - The Angular injector to use.
+ * @param injectQueryFn - A function that returns query options.
+ * @param options - Additional configuration
  * @returns The query result.
  * @public
  * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
  */
 export function injectQuery(
-  optionsFn: () => CreateQueryOptions,
-  injector?: Injector,
+  injectQueryFn: () => CreateQueryOptions,
+  options?: InjectQueryOptions,
 ) {
-  return assertInjector(injectQuery, injector, () =>
-    createBaseQuery(optionsFn, QueryObserver),
+  return assertInjector(injectQuery, options?.injector, () =>
+    createBaseQuery(injectQueryFn, QueryObserver),
   ) as unknown as CreateQueryResult
 }

package/src/providers.ts

@@ -233,17 +233,17 @@ export interface DevtoolsOptions {
  * If you need more control over when devtools are loaded, you can use the `loadDevtools` option. This is particularly useful if you want to load devtools based on environment configurations. For instance, you might have a test environment running in production mode but still require devtools to be available.
  *
  * If you need more control over where devtools are rendered, consider `injectDevtoolsPanel`. This allows rendering devtools inside your own devtools for example.
- * @param optionsFn - A function that returns `DevtoolsOptions`.
+ * @param withDevtoolsFn - A function that returns `DevtoolsOptions`.
  * @returns A set of providers for use with `provideTanStackQuery`.
  * @public
  * @see {@link provideTanStackQuery}
  * @see {@link DevtoolsOptions}
  */
 export function withDevtools(
-  optionsFn?: () => DevtoolsOptions,
+  withDevtoolsFn?: () => DevtoolsOptions,
 ): DeveloperToolsFeature {
   let providers: Array<Provider> = []
-  if (!isDevMode() && !optionsFn) {
+  if (!isDevMode() && !withDevtoolsFn) {
     providers = []
   } else {
     providers = [
@@ -258,7 +258,7 @@ export function withDevtools(
           })
           const destroyRef = inject(DestroyRef)
 
-          const options = computed(() => optionsFn?.() ?? {})
+          const options = computed(() => withDevtoolsFn?.() ?? {})
 
           let devtools: TanstackQueryDevtools | null = null
           let el: HTMLElement | null = null

package/src/util/assert-injector/assert-injector.ts

@@ -23,13 +23,11 @@ import {
  * After assertion, `assertInjector` runs the `runner` function with the guaranteed `Injector`
  * whether it is the default `Injector` within the current **Injection Context**
  * or the custom `Injector` that was passed in.
- *
  * @template {() => any} Runner - Runner is a function that can return anything
- * @param {Function} fn - the Function to pass in `assertInInjectionContext`
- * @param {Injector | undefined | null} injector - the optional "custom" Injector
- * @param {Runner} runner - the runner fn
- * @returns {ReturnType<Runner>} result - returns the result of the Runner
- *
+ * @param fn - the Function to pass in `assertInInjectionContext`
+ * @param injector - the optional "custom" Injector
+ * @param runner - the runner fn
+ * @returns result - returns the result of the Runner
  * @example
  * ```ts
  * function injectValue(injector?: Injector) {
@@ -48,11 +46,9 @@ export function assertInjector<TRunner extends () => any>(
  * `assertInjector` extends `assertInInjectionContext` with an optional `Injector`
  * After assertion, `assertInjector` returns a guaranteed `Injector` whether it is the default `Injector`
  * within the current **Injection Context** or the custom `Injector` that was passed in.
- *
- * @param {Function} fn - the Function to pass in `assertInInjectionContext`
- * @param {Injector | undefined | null} injector - the optional "custom" Injector
+ * @param fn - the Function to pass in `assertInInjectionContext`
+ * @param injector - the optional "custom" Injector
  * @returns Injector
- *
  * @example
  * ```ts
  * function injectDestroy(injector?: Injector) {
@@ -68,6 +64,12 @@ export function assertInjector(
   fn: Function,
   injector: Injector | undefined | null,
 ): Injector
+/**
+ * @param fn - the Function to pass in `assertInInjectionContext`
+ * @param injector - the optional "custom" Injector
+ * @param runner - the runner fn
+ * @returns any
+ */
 export function assertInjector(
   fn: Function,
   injector: Injector | undefined | null,