@tanstack/angular-query-experimental 5.74.0 → 5.74.2

package/build/index.d.ts

@@ -233,6 +233,14 @@ declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData
     queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>>;
 };
 
+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;
+}
 /**
  * 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"
@@ -260,17 +268,6 @@ declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData
  * @public
  */
 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 {
     /**

package/build/index.mjs

@@ -18,6 +18,12 @@ function infiniteQueryOptions(options) {
 
 // src/inject-infinite-query.ts
 import { InfiniteQueryObserver } from "@tanstack/query-core";
+import {
+  Injector as Injector2,
+  assertInInjectionContext as assertInInjectionContext2,
+  inject as inject3,
+  runInInjectionContext
+} from "@angular/core";
 
 // src/create-base-query.ts
 import {
@@ -76,19 +82,19 @@ import {
   computed as computed2,
   inject
 } from "@angular/core";
-var IsRestoring = new InjectionToken("IsRestoring");
+var IS_RESTORING = new InjectionToken("");
 function injectIsRestoring(options) {
   !options?.injector && assertInInjectionContext(injectIsRestoring);
   const injector = options?.injector ?? inject(Injector);
   return injector.get(
-    IsRestoring,
+    IS_RESTORING,
     computed2(() => false),
     { optional: true }
   );
 }
 function provideIsRestoring(isRestoring) {
   return {
-    provide: IsRestoring,
+    provide: IS_RESTORING,
     useValue: isRestoring
   };
 }
@@ -161,25 +167,12 @@ function createBaseQuery(optionsFn, Observer) {
   );
 }
 
-// src/util/assert-injector/assert-injector.ts
-import {
-  Injector as Injector2,
-  assertInInjectionContext as assertInInjectionContext2,
-  inject as inject3,
-  runInInjectionContext
-} from "@angular/core";
-function assertInjector(fn, injector, runner) {
-  !injector && assertInInjectionContext2(fn);
-  const assertedInjector = injector ?? inject3(Injector2);
-  if (!runner) return assertedInjector;
-  return runInInjectionContext(assertedInjector, runner);
-}
-
 // src/inject-infinite-query.ts
 function injectInfiniteQuery(injectInfiniteQueryFn, options) {
-  return assertInjector(
-    injectInfiniteQuery,
-    options?.injector,
+  !options?.injector && assertInInjectionContext2(injectInfiniteQuery);
+  const injector = options?.injector ?? inject3(Injector2);
+  return runInInjectionContext(
+    injector,
     () => createBaseQuery(
       injectInfiniteQueryFn,
       InfiniteQueryObserver
@@ -188,67 +181,83 @@ function injectInfiniteQuery(injectInfiniteQueryFn, options) {
 }
 
 // src/inject-is-fetching.ts
-import { DestroyRef, NgZone as NgZone2, inject as inject4, signal as signal2 } from "@angular/core";
+import {
+  DestroyRef,
+  Injector as Injector3,
+  NgZone as NgZone2,
+  assertInInjectionContext as assertInInjectionContext3,
+  inject as inject4,
+  signal as signal2
+} from "@angular/core";
 import { QueryClient as QueryClient2, notifyManager as notifyManager2 } from "@tanstack/query-core";
 function injectIsFetching(filters, options) {
-  return assertInjector(injectIsFetching, options?.injector, () => {
-    const destroyRef = inject4(DestroyRef);
-    const ngZone = inject4(NgZone2);
-    const queryClient = inject4(QueryClient2);
-    const cache = queryClient.getQueryCache();
-    let isFetching = queryClient.isFetching(filters);
-    const result = signal2(isFetching);
-    const unsubscribe = ngZone.runOutsideAngular(
-      () => cache.subscribe(
-        notifyManager2.batchCalls(() => {
-          const newIsFetching = queryClient.isFetching(filters);
-          if (isFetching !== newIsFetching) {
-            isFetching = newIsFetching;
-            ngZone.run(() => {
-              result.set(isFetching);
-            });
-          }
-        })
-      )
-    );
-    destroyRef.onDestroy(unsubscribe);
-    return result;
-  });
+  !options?.injector && assertInInjectionContext3(injectIsFetching);
+  const injector = options?.injector ?? inject4(Injector3);
+  const destroyRef = injector.get(DestroyRef);
+  const ngZone = injector.get(NgZone2);
+  const queryClient = injector.get(QueryClient2);
+  const cache = queryClient.getQueryCache();
+  let isFetching = queryClient.isFetching(filters);
+  const result = signal2(isFetching);
+  const unsubscribe = ngZone.runOutsideAngular(
+    () => cache.subscribe(
+      notifyManager2.batchCalls(() => {
+        const newIsFetching = queryClient.isFetching(filters);
+        if (isFetching !== newIsFetching) {
+          isFetching = newIsFetching;
+          ngZone.run(() => {
+            result.set(isFetching);
+          });
+        }
+      })
+    )
+  );
+  destroyRef.onDestroy(unsubscribe);
+  return result;
 }
 
 // src/inject-is-mutating.ts
-import { DestroyRef as DestroyRef2, NgZone as NgZone3, inject as inject5, signal as signal3 } from "@angular/core";
+import {
+  DestroyRef as DestroyRef2,
+  Injector as Injector4,
+  NgZone as NgZone3,
+  assertInInjectionContext as assertInInjectionContext4,
+  inject as inject5,
+  signal as signal3
+} from "@angular/core";
 import { QueryClient as QueryClient3, notifyManager as notifyManager3 } from "@tanstack/query-core";
 function injectIsMutating(filters, options) {
-  return assertInjector(injectIsMutating, options?.injector, () => {
-    const destroyRef = inject5(DestroyRef2);
-    const ngZone = inject5(NgZone3);
-    const queryClient = inject5(QueryClient3);
-    const cache = queryClient.getMutationCache();
-    let isMutating = queryClient.isMutating(filters);
-    const result = signal3(isMutating);
-    const unsubscribe = ngZone.runOutsideAngular(
-      () => cache.subscribe(
-        notifyManager3.batchCalls(() => {
-          const newIsMutating = queryClient.isMutating(filters);
-          if (isMutating !== newIsMutating) {
-            isMutating = newIsMutating;
-            ngZone.run(() => {
-              result.set(isMutating);
-            });
-          }
-        })
-      )
-    );
-    destroyRef.onDestroy(unsubscribe);
-    return result;
-  });
+  !options?.injector && assertInInjectionContext4(injectIsMutating);
+  const injector = options?.injector ?? inject5(Injector4);
+  const destroyRef = injector.get(DestroyRef2);
+  const ngZone = injector.get(NgZone3);
+  const queryClient = injector.get(QueryClient3);
+  const cache = queryClient.getMutationCache();
+  let isMutating = queryClient.isMutating(filters);
+  const result = signal3(isMutating);
+  const unsubscribe = ngZone.runOutsideAngular(
+    () => cache.subscribe(
+      notifyManager3.batchCalls(() => {
+        const newIsMutating = queryClient.isMutating(filters);
+        if (isMutating !== newIsMutating) {
+          isMutating = newIsMutating;
+          ngZone.run(() => {
+            result.set(isMutating);
+          });
+        }
+      })
+    )
+  );
+  destroyRef.onDestroy(unsubscribe);
+  return result;
 }
 
 // src/inject-mutation.ts
 import {
   DestroyRef as DestroyRef3,
+  Injector as Injector5,
   NgZone as NgZone4,
+  assertInInjectionContext as assertInInjectionContext5,
   computed as computed4,
   effect as effect2,
   inject as inject6,
@@ -261,82 +270,88 @@ import {
   notifyManager as notifyManager4
 } from "@tanstack/query-core";
 function injectMutation(injectMutationFn, options) {
-  return assertInjector(injectMutation, options?.injector, () => {
-    const destroyRef = inject6(DestroyRef3);
-    const ngZone = inject6(NgZone4);
-    const queryClient = inject6(QueryClient4);
-    const optionsSignal = computed4(injectMutationFn);
-    const observerSignal = (() => {
-      let instance = null;
-      return computed4(() => {
-        return instance ||= new MutationObserver(queryClient, optionsSignal());
-      });
-    })();
-    const mutateFnSignal = computed4(() => {
-      const observer = observerSignal();
-      return (variables, mutateOptions) => {
-        observer.mutate(variables, mutateOptions).catch(noop);
-      };
+  !options?.injector && assertInInjectionContext5(injectMutation);
+  const injector = options?.injector ?? inject6(Injector5);
+  const destroyRef = injector.get(DestroyRef3);
+  const ngZone = injector.get(NgZone4);
+  const queryClient = injector.get(QueryClient4);
+  const optionsSignal = computed4(injectMutationFn);
+  const observerSignal = (() => {
+    let instance = null;
+    return computed4(() => {
+      return instance ||= new MutationObserver(queryClient, optionsSignal());
     });
-    const resultFromInitialOptionsSignal = computed4(() => {
+  })();
+  const mutateFnSignal = computed4(() => {
+    const observer = observerSignal();
+    return (variables, mutateOptions) => {
+      observer.mutate(variables, mutateOptions).catch(noop);
+    };
+  });
+  const resultFromInitialOptionsSignal = computed4(() => {
+    const observer = observerSignal();
+    return observer.getCurrentResult();
+  });
+  const resultFromSubscriberSignal = signal4(null);
+  effect2(
+    () => {
       const observer = observerSignal();
-      return observer.getCurrentResult();
-    });
-    const resultFromSubscriberSignal = signal4(null);
-    effect2(
-      () => {
-        const observer = observerSignal();
-        const observerOptions = optionsSignal();
-        untracked3(() => {
-          observer.setOptions(observerOptions);
-        });
-      },
-      {
-        injector: options?.injector
-      }
-    );
-    effect2(
-      () => {
-        const observer = observerSignal();
-        untracked3(() => {
-          const unsubscribe = ngZone.runOutsideAngular(
-            () => observer.subscribe(
-              notifyManager4.batchCalls((state) => {
-                ngZone.run(() => {
-                  if (state.isError && shouldThrowError(observer.options.throwOnError, [
-                    state.error
-                  ])) {
-                    ngZone.onError.emit(state.error);
-                    throw state.error;
-                  }
-                  resultFromSubscriberSignal.set(state);
-                });
-              })
-            )
-          );
-          destroyRef.onDestroy(unsubscribe);
-        });
-      },
-      {
-        injector: options?.injector
-      }
-    );
-    const resultSignal = computed4(() => {
-      const resultFromSubscriber = resultFromSubscriberSignal();
-      const resultFromInitialOptions = resultFromInitialOptionsSignal();
-      const result = resultFromSubscriber ?? resultFromInitialOptions;
-      return {
-        ...result,
-        mutate: mutateFnSignal(),
-        mutateAsync: result.mutate
-      };
-    });
-    return signalProxy(resultSignal);
+      const observerOptions = optionsSignal();
+      untracked3(() => {
+        observer.setOptions(observerOptions);
+      });
+    },
+    {
+      injector
+    }
+  );
+  effect2(
+    () => {
+      const observer = observerSignal();
+      untracked3(() => {
+        const unsubscribe = ngZone.runOutsideAngular(
+          () => observer.subscribe(
+            notifyManager4.batchCalls((state) => {
+              ngZone.run(() => {
+                if (state.isError && shouldThrowError(observer.options.throwOnError, [state.error])) {
+                  ngZone.onError.emit(state.error);
+                  throw state.error;
+                }
+                resultFromSubscriberSignal.set(state);
+              });
+            })
+          )
+        );
+        destroyRef.onDestroy(unsubscribe);
+      });
+    },
+    {
+      injector
+    }
+  );
+  const resultSignal = computed4(() => {
+    const resultFromSubscriber = resultFromSubscriberSignal();
+    const resultFromInitialOptions = resultFromInitialOptionsSignal();
+    const result = resultFromSubscriber ?? resultFromInitialOptions;
+    return {
+      ...result,
+      mutate: mutateFnSignal(),
+      mutateAsync: result.mutate
+    };
   });
+  return signalProxy(resultSignal);
 }
 
 // src/inject-mutation-state.ts
-import { DestroyRef as DestroyRef4, NgZone as NgZone5, computed as computed5, inject as inject7, signal as signal5 } from "@angular/core";
+import {
+  DestroyRef as DestroyRef4,
+  Injector as Injector6,
+  NgZone as NgZone5,
+  assertInInjectionContext as assertInInjectionContext6,
+  computed as computed5,
+  inject as inject7,
+  signal as signal5
+} from "@angular/core";
 import {
   QueryClient as QueryClient5,
   notifyManager as notifyManager5,
@@ -348,44 +363,44 @@ function getResult(mutationCache, options) {
   );
 }
 function injectMutationState(injectMutationStateFn = () => ({}), options) {
-  return assertInjector(injectMutationState, options?.injector, () => {
-    const destroyRef = inject7(DestroyRef4);
-    const ngZone = inject7(NgZone5);
-    const queryClient = inject7(QueryClient5);
-    const mutationCache = queryClient.getMutationCache();
-    const resultFromOptionsSignal = computed5(() => {
-      return [
-        getResult(mutationCache, injectMutationStateFn()),
-        performance.now()
-      ];
-    });
-    const resultFromSubscriberSignal = signal5(
-      null
-    );
-    const effectiveResultSignal = computed5(() => {
-      const optionsResult = resultFromOptionsSignal();
-      const subscriberResult = resultFromSubscriberSignal();
-      return subscriberResult && subscriberResult[1] > optionsResult[1] ? subscriberResult[0] : optionsResult[0];
-    });
-    const unsubscribe = ngZone.runOutsideAngular(
-      () => mutationCache.subscribe(
-        notifyManager5.batchCalls(() => {
-          const [lastResult] = effectiveResultSignal();
-          const nextResult = replaceEqualDeep(
-            lastResult,
-            getResult(mutationCache, injectMutationStateFn())
-          );
-          if (lastResult !== nextResult) {
-            ngZone.run(() => {
-              resultFromSubscriberSignal.set([nextResult, performance.now()]);
-            });
-          }
-        })
-      )
-    );
-    destroyRef.onDestroy(unsubscribe);
-    return effectiveResultSignal;
+  !options?.injector && assertInInjectionContext6(injectMutationState);
+  const injector = options?.injector ?? inject7(Injector6);
+  const destroyRef = injector.get(DestroyRef4);
+  const ngZone = injector.get(NgZone5);
+  const queryClient = injector.get(QueryClient5);
+  const mutationCache = queryClient.getMutationCache();
+  const resultFromOptionsSignal = computed5(() => {
+    return [
+      getResult(mutationCache, injectMutationStateFn()),
+      performance.now()
+    ];
   });
+  const resultFromSubscriberSignal = signal5(
+    null
+  );
+  const effectiveResultSignal = computed5(() => {
+    const optionsResult = resultFromOptionsSignal();
+    const subscriberResult = resultFromSubscriberSignal();
+    return subscriberResult && subscriberResult[1] > optionsResult[1] ? subscriberResult[0] : optionsResult[0];
+  });
+  const unsubscribe = ngZone.runOutsideAngular(
+    () => mutationCache.subscribe(
+      notifyManager5.batchCalls(() => {
+        const [lastResult] = effectiveResultSignal();
+        const nextResult = replaceEqualDeep(
+          lastResult,
+          getResult(mutationCache, injectMutationStateFn())
+        );
+        if (lastResult !== nextResult) {
+          ngZone.run(() => {
+            resultFromSubscriberSignal.set([nextResult, performance.now()]);
+          });
+        }
+      })
+    )
+  );
+  destroyRef.onDestroy(unsubscribe);
+  return effectiveResultSignal;
 }
 
 // src/inject-queries.ts
@@ -396,17 +411,21 @@ import {
 } from "@tanstack/query-core";
 import {
   DestroyRef as DestroyRef5,
+  Injector as Injector7,
   NgZone as NgZone6,
+  assertInInjectionContext as assertInInjectionContext7,
   computed as computed6,
   effect as effect3,
   inject as inject8,
+  runInInjectionContext as runInInjectionContext2,
   signal as signal6
 } from "@angular/core";
 function injectQueries({
   queries,
   ...options
 }, injector) {
-  return assertInjector(injectQueries, injector, () => {
+  !injector && assertInInjectionContext7(injectQueries);
+  return runInInjectionContext2(injector ?? inject8(Injector7), () => {
     const destroyRef = inject8(DestroyRef5);
     const ngZone = inject8(NgZone6);
     const queryClient = inject8(QueryClient6);
@@ -446,19 +465,25 @@ function injectQueries({
 
 // src/inject-query.ts
 import { QueryObserver } from "@tanstack/query-core";
+import {
+  Injector as Injector8,
+  assertInInjectionContext as assertInInjectionContext8,
+  inject as inject9,
+  runInInjectionContext as runInInjectionContext3
+} from "@angular/core";
 function injectQuery(injectQueryFn, options) {
-  return assertInjector(
-    injectQuery,
-    options?.injector,
+  !options?.injector && assertInInjectionContext8(injectQuery);
+  return runInInjectionContext3(
+    options?.injector ?? inject9(Injector8),
     () => createBaseQuery(injectQueryFn, QueryObserver)
   );
 }
 
 // src/inject-query-client.ts
-import { Injector as Injector3, inject as inject9 } from "@angular/core";
+import { Injector as Injector9, inject as inject10 } from "@angular/core";
 import { QueryClient as QueryClient7 } from "@tanstack/query-core";
 function injectQueryClient(injectOptions = {}) {
-  return (injectOptions.injector ?? inject9(Injector3)).get(QueryClient7);
+  return (injectOptions.injector ?? inject10(Injector9)).get(QueryClient7);
 }
 
 // src/providers.ts
@@ -468,7 +493,7 @@ import {
   PLATFORM_ID,
   computed as computed7,
   effect as effect4,
-  inject as inject10,
+  inject as inject11,
   makeEnvironmentProviders
 } from "@angular/core";
 import { QueryClient as QueryClient8, onlineManager } from "@tanstack/query-core";
@@ -490,7 +515,7 @@ function provideTanStackQuery(queryClient, ...features) {
       multi: true,
       useValue: () => {
         queryClient.mount();
-        inject10(DestroyRef6).onDestroy(() => queryClient.unmount());
+        inject11(DestroyRef6).onDestroy(() => queryClient.unmount());
       }
     },
     features.map((feature) => feature.\u0275providers)
@@ -513,11 +538,11 @@ function withDevtools(withDevtoolsFn) {
         provide: ENVIRONMENT_INITIALIZER,
         multi: true,
         useFactory: () => {
-          if (!isPlatformBrowser(inject10(PLATFORM_ID))) return noop;
-          const injectedClient = inject10(QueryClient8, {
+          if (!isPlatformBrowser(inject11(PLATFORM_ID))) return noop;
+          const injectedClient = inject11(QueryClient8, {
             optional: true
           });
-          const destroyRef = inject10(DestroyRef6);
+          const destroyRef = inject11(DestroyRef6);
           const options = computed7(() => withDevtoolsFn?.() ?? {});
           let devtools = null;
           let el = null;