@tanstack/angular-query-experimental 5.73.3 → 5.74.1

package/build/index.mjs

@@ -18,15 +18,20 @@ 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 {
-  DestroyRef,
   NgZone,
   VERSION,
-  computed as computed2,
+  computed as computed3,
   effect,
-  inject,
+  inject as inject2,
   signal,
   untracked as untracked2
 } from "@angular/core";
@@ -69,23 +74,48 @@ function shouldThrowError(throwError, params) {
 function noop() {
 }
 
+// src/inject-is-restoring.ts
+import {
+  InjectionToken,
+  Injector,
+  assertInInjectionContext,
+  computed as computed2,
+  inject
+} from "@angular/core";
+var IS_RESTORING = new InjectionToken("");
+function injectIsRestoring(options) {
+  !options?.injector && assertInInjectionContext(injectIsRestoring);
+  const injector = options?.injector ?? inject(Injector);
+  return injector.get(
+    IS_RESTORING,
+    computed2(() => false),
+    { optional: true }
+  );
+}
+function provideIsRestoring(isRestoring) {
+  return {
+    provide: IS_RESTORING,
+    useValue: isRestoring
+  };
+}
+
 // src/create-base-query.ts
 function createBaseQuery(optionsFn, Observer) {
-  const ngZone = inject(NgZone);
-  const destroyRef = inject(DestroyRef);
-  const queryClient = inject(QueryClient);
-  const defaultedOptionsSignal = computed2(() => {
+  const ngZone = inject2(NgZone);
+  const queryClient = inject2(QueryClient);
+  const isRestoring = injectIsRestoring();
+  const defaultedOptionsSignal = computed3(() => {
     const defaultedOptions = queryClient.defaultQueryOptions(optionsFn());
-    defaultedOptions._optimisticResults = "optimistic";
+    defaultedOptions._optimisticResults = isRestoring() ? "isRestoring" : "optimistic";
     return defaultedOptions;
   });
   const observerSignal = (() => {
     let instance = null;
-    return computed2(() => {
+    return computed3(() => {
       return instance ||= new Observer(queryClient, defaultedOptionsSignal());
     });
   })();
-  const optimisticResultSignal = computed2(
+  const optimisticResultSignal = computed3(
     () => observerSignal().getOptimisticResult(defaultedOptionsSignal())
   );
   const resultFromSubscriberSignal = signal(null);
@@ -106,15 +136,14 @@ function createBaseQuery(optionsFn, Observer) {
       allowSignalWrites: VERSION.major < "19" || void 0
     }
   );
-  effect(() => {
+  effect((onCleanup) => {
     const observer = observerSignal();
-    untracked2(() => {
-      const unsubscribe = ngZone.runOutsideAngular(
+    const unsubscribe = isRestoring() ? () => void 0 : untracked2(
+      () => ngZone.runOutsideAngular(
         () => observer.subscribe(
           notifyManager.batchCalls((state) => {
             ngZone.run(() => {
-              if (state.isError && !state.isFetching && // !isRestoring() && // todo: enable when client persistence is implemented
-              shouldThrowError(observer.options.throwOnError, [
+              if (state.isError && !state.isFetching && shouldThrowError(observer.options.throwOnError, [
                 state.error,
                 observer.getCurrentQuery()
               ])) {
@@ -125,12 +154,12 @@ function createBaseQuery(optionsFn, Observer) {
             });
           })
         )
-      );
-      destroyRef.onDestroy(unsubscribe);
-    });
+      )
+    );
+    onCleanup(unsubscribe);
   });
   return signalProxy(
-    computed2(() => {
+    computed3(() => {
       const subscriberResult = resultFromSubscriberSignal();
       const optimisticResult = optimisticResultSignal();
       return subscriberResult ?? optimisticResult;
@@ -138,25 +167,12 @@ function createBaseQuery(optionsFn, Observer) {
   );
 }
 
-// src/util/assert-injector/assert-injector.ts
-import {
-  Injector,
-  assertInInjectionContext,
-  inject as inject2,
-  runInInjectionContext
-} from "@angular/core";
-function assertInjector(fn, injector, runner) {
-  !injector && assertInInjectionContext(fn);
-  const assertedInjector = injector ?? inject2(Injector);
-  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
@@ -165,70 +181,86 @@ function injectInfiniteQuery(injectInfiniteQueryFn, options) {
 }
 
 // src/inject-is-fetching.ts
-import { DestroyRef as DestroyRef2, NgZone as NgZone2, inject as inject3, 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 = inject3(DestroyRef2);
-    const ngZone = inject3(NgZone2);
-    const queryClient = inject3(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 DestroyRef3, NgZone as NgZone3, inject as inject4, 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 = inject4(DestroyRef3);
-    const ngZone = inject4(NgZone3);
-    const queryClient = inject4(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 DestroyRef4,
+  DestroyRef as DestroyRef3,
+  Injector as Injector5,
   NgZone as NgZone4,
-  computed as computed3,
+  assertInInjectionContext as assertInInjectionContext5,
+  computed as computed4,
   effect as effect2,
-  inject as inject5,
+  inject as inject6,
   signal as signal4,
   untracked as untracked3
 } from "@angular/core";
@@ -238,82 +270,88 @@ import {
   notifyManager as notifyManager4
 } from "@tanstack/query-core";
 function injectMutation(injectMutationFn, options) {
-  return assertInjector(injectMutation, options?.injector, () => {
-    const destroyRef = inject5(DestroyRef4);
-    const ngZone = inject5(NgZone4);
-    const queryClient = inject5(QueryClient4);
-    const optionsSignal = computed3(injectMutationFn);
-    const observerSignal = (() => {
-      let instance = null;
-      return computed3(() => {
-        return instance ||= new MutationObserver(queryClient, optionsSignal());
-      });
-    })();
-    const mutateFnSignal = computed3(() => {
-      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 = computed3(() => {
+  })();
+  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 = computed3(() => {
-      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 DestroyRef5, NgZone as NgZone5, computed as computed4, inject as inject6, 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,
@@ -325,44 +363,44 @@ function getResult(mutationCache, options) {
   );
 }
 function injectMutationState(injectMutationStateFn = () => ({}), options) {
-  return assertInjector(injectMutationState, options?.injector, () => {
-    const destroyRef = inject6(DestroyRef5);
-    const ngZone = inject6(NgZone5);
-    const queryClient = inject6(QueryClient5);
-    const mutationCache = queryClient.getMutationCache();
-    const resultFromOptionsSignal = computed4(() => {
-      return [
-        getResult(mutationCache, injectMutationStateFn()),
-        performance.now()
-      ];
-    });
-    const resultFromSubscriberSignal = signal5(
-      null
-    );
-    const effectiveResultSignal = computed4(() => {
-      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
@@ -372,25 +410,30 @@ import {
   notifyManager as notifyManager6
 } from "@tanstack/query-core";
 import {
-  DestroyRef as DestroyRef6,
+  DestroyRef as DestroyRef5,
+  Injector as Injector7,
   NgZone as NgZone6,
-  computed as computed5,
+  assertInInjectionContext as assertInInjectionContext7,
+  computed as computed6,
   effect as effect3,
-  inject as inject7,
+  inject as inject8,
+  runInInjectionContext as runInInjectionContext2,
   signal as signal6
 } from "@angular/core";
 function injectQueries({
   queries,
   ...options
 }, injector) {
-  return assertInjector(injectQueries, injector, () => {
-    const destroyRef = inject7(DestroyRef6);
-    const ngZone = inject7(NgZone6);
-    const queryClient = inject7(QueryClient6);
-    const defaultedQueries = computed5(() => {
+  !injector && assertInInjectionContext7(injectQueries);
+  return runInInjectionContext2(injector ?? inject8(Injector7), () => {
+    const destroyRef = inject8(DestroyRef5);
+    const ngZone = inject8(NgZone6);
+    const queryClient = inject8(QueryClient6);
+    const isRestoring = injectIsRestoring();
+    const defaultedQueries = computed6(() => {
       return queries().map((opts) => {
         const defaultedOptions = queryClient.defaultQueryOptions(opts);
-        defaultedOptions._optimisticResults = "optimistic";
+        defaultedOptions._optimisticResults = isRestoring() ? "isRestoring" : "optimistic";
         return defaultedOptions;
       });
     });
@@ -410,39 +453,47 @@ function injectQueries({
       options.combine
     );
     const result = signal6(getCombinedResult());
-    const unsubscribe = ngZone.runOutsideAngular(
-      () => observer.subscribe(notifyManager6.batchCalls(result.set))
-    );
-    destroyRef.onDestroy(unsubscribe);
+    effect3(() => {
+      const unsubscribe = isRestoring() ? () => void 0 : ngZone.runOutsideAngular(
+        () => observer.subscribe(notifyManager6.batchCalls(result.set))
+      );
+      destroyRef.onDestroy(unsubscribe);
+    });
     return result;
   });
 }
 
 // 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 Injector2, inject as inject8 } 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 ?? inject8(Injector2)).get(QueryClient7);
+  return (injectOptions.injector ?? inject10(Injector9)).get(QueryClient7);
 }
 
 // src/providers.ts
 import {
-  DestroyRef as DestroyRef7,
+  DestroyRef as DestroyRef6,
   ENVIRONMENT_INITIALIZER,
   PLATFORM_ID,
-  computed as computed6,
+  computed as computed7,
   effect as effect4,
-  inject as inject9,
+  inject as inject11,
   makeEnvironmentProviders
 } from "@angular/core";
 import { QueryClient as QueryClient8, onlineManager } from "@tanstack/query-core";
@@ -464,7 +515,7 @@ function provideTanStackQuery(queryClient, ...features) {
       multi: true,
       useValue: () => {
         queryClient.mount();
-        inject9(DestroyRef7).onDestroy(() => queryClient.unmount());
+        inject11(DestroyRef6).onDestroy(() => queryClient.unmount());
       }
     },
     features.map((feature) => feature.\u0275providers)
@@ -487,15 +538,15 @@ function withDevtools(withDevtoolsFn) {
         provide: ENVIRONMENT_INITIALIZER,
         multi: true,
         useFactory: () => {
-          if (!isPlatformBrowser(inject9(PLATFORM_ID))) return noop;
-          const injectedClient = inject9(QueryClient8, {
+          if (!isPlatformBrowser(inject11(PLATFORM_ID))) return noop;
+          const injectedClient = inject11(QueryClient8, {
             optional: true
           });
-          const destroyRef = inject9(DestroyRef7);
-          const options = computed6(() => withDevtoolsFn?.() ?? {});
+          const destroyRef = inject11(DestroyRef6);
+          const options = computed7(() => withDevtoolsFn?.() ?? {});
           let devtools = null;
           let el = null;
-          const shouldLoadToolsSignal = computed6(() => {
+          const shouldLoadToolsSignal = computed7(() => {
             const { loadDevtools } = options();
             return typeof loadDevtools === "boolean" ? loadDevtools : isDevMode();
           });
@@ -553,12 +604,13 @@ function withDevtools(withDevtoolsFn) {
   }
   return queryFeature("DeveloperTools", providers);
 }
-var queryFeatures = ["DeveloperTools"];
+var queryFeatures = ["DeveloperTools", "PersistQueryClient"];
 export {
   infiniteQueryOptions,
   injectInfiniteQuery,
   injectIsFetching,
   injectIsMutating,
+  injectIsRestoring,
   injectMutation,
   injectMutationState,
   injectQueries,
@@ -566,8 +618,10 @@ export {
   injectQueryClient,
   mutationOptions,
   provideAngularQuery,
+  provideIsRestoring,
   provideQueryClient,
   provideTanStackQuery,
+  queryFeature,
   queryFeatures,
   queryOptions,
   withDevtools