@tanstack/angular-query-experimental 5.72.1 → 5.72.3

package/build/index.d.ts

@@ -236,64 +236,99 @@ declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData
 /**
  * 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.
+ * @param injectInfiniteQueryFn - A function that returns infinite query options.
+ * @param options - Additional configuration.
  * @returns The infinite query result.
  * @public
  */
-declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(optionsFn: () => DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, injector?: Injector): DefinedCreateInfiniteQueryResult<TData, TError>;
+declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(injectInfiniteQueryFn: () => DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, options?: InjectInfiniteQueryOptions): 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.
+ * @param injectInfiniteQueryFn - A function that returns infinite query options.
+ * @param options - Additional configuration.
  * @returns The infinite query result.
  * @public
  */
-declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(optionsFn: () => UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, injector?: Injector): CreateInfiniteQueryResult<TData, TError>;
+declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(injectInfiniteQueryFn: () => UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, options?: InjectInfiniteQueryOptions): 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.
+ * @param injectInfiniteQueryFn - A function that returns infinite query options.
+ * @param options - Additional configuration.
  * @returns The infinite query result.
  * @public
  */
-declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(optionsFn: () => CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey, TPageParam>, injector?: Injector): CreateInfiniteQueryResult<TData, TError>;
+declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(injectInfiniteQueryFn: () => CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey, TPageParam>, options?: InjectInfiniteQueryOptions): CreateInfiniteQueryResult<TData, TError>;
+interface InjectInfiniteQueryOptions {
+    /**
+     * The `Injector` in which to create the infinite query.
+     *
+     * If this is not provided, the current injection context will be used instead (via `inject`).
+     */
+    injector?: Injector;
+}
+interface InjectInfiniteQueryOptions {
+    injector?: Injector;
+}
 
+interface InjectIsFetchingOptions {
+    /**
+     * The `Injector` in which to create the isFetching signal.
+     *
+     * If this is not provided, the current injection context will be used instead (via `inject`).
+     */
+    injector?: Injector;
+}
 /**
  * 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.
+ * @param options - Additional configuration
  * @returns signal with number of loading or fetching queries.
  * @public
  */
-declare function injectIsFetching(filters?: QueryFilters, injector?: Injector): Signal<number>;
+declare function injectIsFetching(filters?: QueryFilters, options?: InjectIsFetchingOptions): Signal<number>;
 
+interface InjectIsMutatingOptions {
+    /**
+     * The `Injector` in which to create the isMutating signal.
+     *
+     * If this is not provided, the current injection context will be used instead (via `inject`).
+     */
+    injector?: Injector;
+}
 /**
  * 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.
+ * @param options - Additional configuration
  * @returns signal with number of fetching mutations.
  * @public
  */
-declare function injectIsMutating(filters?: MutationFilters, injector?: Injector): Signal<number>;
+declare function injectIsMutating(filters?: MutationFilters, options?: InjectIsMutatingOptions): Signal<number>;
 
+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
  */
-declare function injectMutation<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(optionsFn: () => CreateMutationOptions<TData, TError, TVariables, TContext>, injector?: Injector): CreateMutationResult<TData, TError, TVariables, TContext>;
+declare function injectMutation<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(injectMutationFn: () => CreateMutationOptions<TData, TError, TVariables, TContext>, options?: InjectMutationOptions): CreateMutationResult<TData, TError, TVariables, TContext>;
 
 type MutationStateOptions<TResult = MutationState> = {
     filters?: MutationFilters;
@@ -303,16 +338,21 @@ type MutationStateOptions<TResult = MutationState> = {
  * @public
  */
 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
  */
-declare function injectMutationState<TResult = MutationState>(mutationStateOptionsFn?: () => MutationStateOptions<TResult>, options?: InjectMutationStateOptions): Signal<Array<TResult>>;
+declare function injectMutationState<TResult = MutationState>(injectMutationStateFn?: () => MutationStateOptions<TResult>, options?: InjectMutationStateOptions): Signal<Array<TResult>>;
 
 type QueryObserverOptionsForCreateQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<QueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'placeholderData'> & {
     placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>;
@@ -380,6 +420,7 @@ type QueriesResults<T extends Array<any>, TResult extends Array<any> = [], TDept
  * @param root0.queries
  * @param root0.combine
  * @param injector
+ * @param injector
  * @public
  */
 declare function injectQueries<T extends Array<any>, TCombinedResult = QueriesResults<T>>({ queries, ...options }: {
@@ -387,6 +428,14 @@ declare function injectQueries<T extends Array<any>, TCombinedResult = QueriesRe
     combine?: (result: QueriesResults<T>) => TCombinedResult;
 }, injector?: Injector): Signal<TCombinedResult>;
 
+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.
  *
@@ -418,13 +467,13 @@ declare function injectQueries<T extends Array<any>, TCombinedResult = QueriesRe
  *   }))
  * }
  * ```
- * @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
  */
-declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(optionsFn: () => DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, injector?: Injector): 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.
  *
@@ -456,13 +505,13 @@ declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TDat
  *   }))
  * }
  * ```
- * @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
  */
-declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(optionsFn: () => UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, injector?: Injector): 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>;
 /**
  * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
  *
@@ -494,13 +543,13 @@ declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TDat
  *   }))
  * }
  * ```
- * @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
  */
-declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(optionsFn: () => CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, injector?: Injector): 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>;
 
 /**
  * Injects a `QueryClient` instance and allows passing a custom injector.
@@ -693,13 +742,13 @@ 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}
  */
-declare function withDevtools(optionsFn?: () => DevtoolsOptions): DeveloperToolsFeature;
+declare function withDevtools(withDevtoolsFn?: () => DevtoolsOptions): DeveloperToolsFeature;
 /**
  * A type alias that represents all Query features available for use with `provideTanStackQuery`.
  * Features can be enabled by adding special functions to the `provideTanStackQuery` call.
@@ -712,4 +761,4 @@ type QueryFeatures = DeveloperToolsFeature;
 declare const queryFeatures: readonly ["DeveloperTools"];
 type QueryFeatureKind = (typeof queryFeatures)[number];
 
-export { type BaseMutationNarrowing, type BaseQueryNarrowing, type CreateBaseMutationResult, type CreateBaseQueryOptions, type CreateBaseQueryResult, type CreateInfiniteQueryOptions, type CreateInfiniteQueryResult, type CreateMutateAsyncFunction, type CreateMutateFunction, type CreateMutationOptions, type CreateMutationResult, type CreateQueryOptions, type CreateQueryResult, type DefinedCreateInfiniteQueryResult, type DefinedCreateQueryResult, type DefinedInitialDataInfiniteOptions, type DefinedInitialDataOptions, type DeveloperToolsFeature, type DevtoolsOptions, type InjectMutationStateOptions, type NonUndefinedGuard, type QueriesOptions, type QueriesResults, type QueryFeature, type QueryFeatureKind, type QueryFeatures, type UndefinedInitialDataInfiniteOptions, type UndefinedInitialDataOptions, infiniteQueryOptions, injectInfiniteQuery, injectIsFetching, injectIsMutating, injectMutation, injectMutationState, injectQueries, injectQuery, injectQueryClient, mutationOptions, provideAngularQuery, provideQueryClient, provideTanStackQuery, queryFeatures, queryOptions, withDevtools };
+export { type BaseMutationNarrowing, type BaseQueryNarrowing, type CreateBaseMutationResult, type CreateBaseQueryOptions, type CreateBaseQueryResult, type CreateInfiniteQueryOptions, type CreateInfiniteQueryResult, type CreateMutateAsyncFunction, type CreateMutateFunction, type CreateMutationOptions, type CreateMutationResult, type CreateQueryOptions, type CreateQueryResult, type DefinedCreateInfiniteQueryResult, type DefinedCreateQueryResult, type DefinedInitialDataInfiniteOptions, type DefinedInitialDataOptions, type DeveloperToolsFeature, type DevtoolsOptions, type InjectInfiniteQueryOptions, type InjectIsFetchingOptions, type InjectIsMutatingOptions, type InjectMutationOptions, type InjectMutationStateOptions, type InjectQueryOptions, type NonUndefinedGuard, type QueriesOptions, type QueriesResults, type QueryFeature, type QueryFeatureKind, type QueryFeatures, type UndefinedInitialDataInfiniteOptions, type UndefinedInitialDataOptions, infiniteQueryOptions, injectInfiniteQuery, injectIsFetching, injectIsMutating, injectMutation, injectMutationState, injectQueries, injectQuery, injectQueryClient, mutationOptions, provideAngularQuery, provideQueryClient, provideTanStackQuery, queryFeatures, queryOptions, withDevtools };

package/build/index.mjs

@@ -153,19 +153,22 @@ function assertInjector(fn, injector, runner) {
 }
 
 // src/inject-infinite-query.ts
-function injectInfiniteQuery(optionsFn, injector) {
+function injectInfiniteQuery(injectInfiniteQueryFn, options) {
   return assertInjector(
     injectInfiniteQuery,
-    injector,
-    () => createBaseQuery(optionsFn, InfiniteQueryObserver)
+    options?.injector,
+    () => createBaseQuery(
+      injectInfiniteQueryFn,
+      InfiniteQueryObserver
+    )
   );
 }
 
 // src/inject-is-fetching.ts
 import { DestroyRef as DestroyRef2, NgZone as NgZone2, inject as inject3, signal as signal2 } from "@angular/core";
 import { QueryClient as QueryClient2, notifyManager as notifyManager2 } from "@tanstack/query-core";
-function injectIsFetching(filters, injector) {
-  return assertInjector(injectIsFetching, injector, () => {
+function injectIsFetching(filters, options) {
+  return assertInjector(injectIsFetching, options?.injector, () => {
     const destroyRef = inject3(DestroyRef2);
     const ngZone = inject3(NgZone2);
     const queryClient = inject3(QueryClient2);
@@ -193,8 +196,8 @@ function injectIsFetching(filters, injector) {
 // src/inject-is-mutating.ts
 import { DestroyRef as DestroyRef3, NgZone as NgZone3, inject as inject4, signal as signal3 } from "@angular/core";
 import { QueryClient as QueryClient3, notifyManager as notifyManager3 } from "@tanstack/query-core";
-function injectIsMutating(filters, injector) {
-  return assertInjector(injectIsMutating, injector, () => {
+function injectIsMutating(filters, options) {
+  return assertInjector(injectIsMutating, options?.injector, () => {
     const destroyRef = inject4(DestroyRef3);
     const ngZone = inject4(NgZone3);
     const queryClient = inject4(QueryClient3);
@@ -234,12 +237,12 @@ import {
   QueryClient as QueryClient4,
   notifyManager as notifyManager4
 } from "@tanstack/query-core";
-function injectMutation(optionsFn, injector) {
-  return assertInjector(injectMutation, injector, () => {
+function injectMutation(injectMutationFn, options) {
+  return assertInjector(injectMutation, options?.injector, () => {
     const destroyRef = inject5(DestroyRef4);
     const ngZone = inject5(NgZone4);
     const queryClient = inject5(QueryClient4);
-    const optionsSignal = computed3(optionsFn);
+    const optionsSignal = computed3(injectMutationFn);
     const observerSignal = (() => {
       let instance = null;
       return computed3(() => {
@@ -260,13 +263,13 @@ function injectMutation(optionsFn, injector) {
     effect2(
       () => {
         const observer = observerSignal();
-        const options = optionsSignal();
+        const observerOptions = optionsSignal();
         untracked3(() => {
-          observer.setOptions(options);
+          observer.setOptions(observerOptions);
         });
       },
       {
-        injector
+        injector: options?.injector
       }
     );
     effect2(
@@ -292,7 +295,7 @@ function injectMutation(optionsFn, injector) {
         });
       },
       {
-        injector
+        injector: options?.injector
       }
     );
     const resultSignal = computed3(() => {
@@ -321,7 +324,7 @@ function getResult(mutationCache, options) {
     (mutation) => options.select ? options.select(mutation) : mutation.state
   );
 }
-function injectMutationState(mutationStateOptionsFn = () => ({}), options) {
+function injectMutationState(injectMutationStateFn = () => ({}), options) {
   return assertInjector(injectMutationState, options?.injector, () => {
     const destroyRef = inject6(DestroyRef5);
     const ngZone = inject6(NgZone5);
@@ -329,7 +332,7 @@ function injectMutationState(mutationStateOptionsFn = () => ({}), options) {
     const mutationCache = queryClient.getMutationCache();
     const resultFromOptionsSignal = computed4(() => {
       return [
-        getResult(mutationCache, mutationStateOptionsFn()),
+        getResult(mutationCache, injectMutationStateFn()),
         performance.now()
       ];
     });
@@ -347,7 +350,7 @@ function injectMutationState(mutationStateOptionsFn = () => ({}), options) {
           const [lastResult] = effectiveResultSignal();
           const nextResult = replaceEqualDeep(
             lastResult,
-            getResult(mutationCache, mutationStateOptionsFn())
+            getResult(mutationCache, injectMutationStateFn())
           );
           if (lastResult !== nextResult) {
             ngZone.run(() => {
@@ -417,11 +420,11 @@ function injectQueries({
 
 // src/inject-query.ts
 import { QueryObserver } from "@tanstack/query-core";
-function injectQuery(optionsFn, injector) {
+function injectQuery(injectQueryFn, options) {
   return assertInjector(
     injectQuery,
-    injector,
-    () => createBaseQuery(optionsFn, QueryObserver)
+    options?.injector,
+    () => createBaseQuery(injectQueryFn, QueryObserver)
   );
 }
 
@@ -473,9 +476,9 @@ function provideAngularQuery(queryClient) {
 function queryFeature(kind, providers) {
   return { \u0275kind: kind, \u0275providers: providers };
 }
-function withDevtools(optionsFn) {
+function withDevtools(withDevtoolsFn) {
   let providers = [];
-  if (!isDevMode() && !optionsFn) {
+  if (!isDevMode() && !withDevtoolsFn) {
     providers = [];
   } else {
     providers = [
@@ -489,7 +492,7 @@ function withDevtools(optionsFn) {
             optional: true
           });
           const destroyRef = inject9(DestroyRef7);
-          const options = computed6(() => optionsFn?.() ?? {});
+          const options = computed6(() => withDevtoolsFn?.() ?? {});
           let devtools = null;
           let el = null;
           const shouldLoadToolsSignal = computed6(() => {