@tanstack/angular-query-experimental 5.62.3 → 5.62.4

package/build/index.mjs

@@ -29,7 +29,7 @@ import {
   inject,
   runInInjectionContext,
   signal,
-  untracked as untracked3
+  untracked as untracked2
 } from "@angular/core";
 import { QueryClient, notifyManager } from "@tanstack/query-core";
 
@@ -72,75 +72,53 @@ function shouldThrowError(throwError, params) {
 function noop() {
 }
 
-// src/util/lazy-init/lazy-init.ts
-import { untracked as untracked2 } from "@angular/core";
-function lazyInit(initializer) {
-  let object = null;
-  const initializeObject = () => {
-    if (!object) {
-      object = untracked2(() => initializer());
-    }
-  };
-  queueMicrotask(() => initializeObject());
-  return new Proxy({}, {
-    get(_, prop, receiver) {
-      initializeObject();
-      return Reflect.get(object, prop, receiver);
-    },
-    has(_, prop) {
-      initializeObject();
-      return Reflect.has(object, prop);
-    },
-    ownKeys() {
-      initializeObject();
-      return Reflect.ownKeys(object);
-    },
-    getOwnPropertyDescriptor() {
-      return {
-        enumerable: true,
-        configurable: true
-      };
-    }
-  });
-}
-
 // src/create-base-query.ts
 function createBaseQuery(optionsFn, Observer) {
   const injector = inject(Injector);
-  return lazyInit(() => {
-    const ngZone = injector.get(NgZone);
-    const destroyRef = injector.get(DestroyRef);
-    const queryClient = injector.get(QueryClient);
-    const defaultedOptionsSignal = computed2(() => {
-      const options = runInInjectionContext(injector, () => optionsFn());
-      const defaultedOptions = queryClient.defaultQueryOptions(options);
-      defaultedOptions._optimisticResults = "optimistic";
-      return defaultedOptions;
+  const ngZone = injector.get(NgZone);
+  const destroyRef = injector.get(DestroyRef);
+  const queryClient = injector.get(QueryClient);
+  const defaultedOptionsSignal = computed2(() => {
+    const options = runInInjectionContext(injector, () => optionsFn());
+    const defaultedOptions = queryClient.defaultQueryOptions(options);
+    defaultedOptions._optimisticResults = "optimistic";
+    return defaultedOptions;
+  });
+  const observerSignal = (() => {
+    let instance = null;
+    return computed2(() => {
+      return instance ||= new Observer(queryClient, defaultedOptionsSignal());
     });
-    const observer = new Observer(queryClient, defaultedOptionsSignal());
-    const resultSignal = signal(
-      observer.getOptimisticResult(defaultedOptionsSignal())
-    );
-    effect(
-      () => {
-        const defaultedOptions = defaultedOptionsSignal();
+  })();
+  const optimisticResultSignal = computed2(
+    () => observerSignal().getOptimisticResult(defaultedOptionsSignal())
+  );
+  const resultFromSubscriberSignal = signal(null);
+  effect(
+    (onCleanup) => {
+      const observer = observerSignal();
+      const defaultedOptions = defaultedOptionsSignal();
+      untracked2(() => {
         observer.setOptions(defaultedOptions, {
           // Do not notify on updates because of changes in the options because
           // these changes should already be reflected in the optimistic result.
           listeners: false
         });
-        untracked3(() => {
-          resultSignal.set(observer.getOptimisticResult(defaultedOptions));
-        });
-      },
-      {
-        injector
-      }
-    );
-    const unsubscribe = ngZone.runOutsideAngular(
-      () => observer.subscribe(
-        notifyManager.batchCalls(
-          (state) => {
+      });
+      onCleanup(() => {
+        resultFromSubscriberSignal.set(null);
+      });
+    },
+    {
+      injector
+    }
+  );
+  effect(() => {
+    const observer = observerSignal();
+    untracked2(() => {
+      const unsubscribe = 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, [
@@ -149,15 +127,21 @@ function createBaseQuery(optionsFn, Observer) {
               ])) {
                 throw state.error;
               }
-              resultSignal.set(state);
+              resultFromSubscriberSignal.set(state);
             });
-          }
+          })
         )
-      )
-    );
-    destroyRef.onDestroy(unsubscribe);
-    return signalProxy(resultSignal);
+      );
+      destroyRef.onDestroy(unsubscribe);
+    });
   });
+  return signalProxy(
+    computed2(() => {
+      const subscriberResult = resultFromSubscriberSignal();
+      const optimisticResult = optimisticResultSignal();
+      return subscriberResult ?? optimisticResult;
+    })
+  );
 }
 
 // src/util/assert-injector/assert-injector.ts
@@ -251,7 +235,8 @@ import {
   effect as effect2,
   inject as inject5,
   runInInjectionContext as runInInjectionContext3,
-  signal as signal4
+  signal as signal4,
+  untracked as untracked3
 } from "@angular/core";
 import {
   MutationObserver,
@@ -264,77 +249,84 @@ function injectMutation(optionsFn, injector) {
     const destroyRef = inject5(DestroyRef4);
     const ngZone = inject5(NgZone4);
     const queryClient = inject5(QueryClient4);
-    return lazyInit(
-      () => runInInjectionContext3(currentInjector, () => {
-        const observer = new MutationObserver(queryClient, optionsFn());
-        const mutate = (variables, mutateOptions) => {
-          observer.mutate(variables, mutateOptions).catch(noop);
-        };
-        effect2(() => {
-          observer.setOptions(
-            runInInjectionContext3(currentInjector, () => optionsFn())
-          );
+    const optionsSignal = computed3(
+      () => runInInjectionContext3(currentInjector, () => optionsFn())
+    );
+    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);
+      };
+    });
+    const resultFromInitialOptionsSignal = computed3(() => {
+      const observer = observerSignal();
+      return observer.getCurrentResult();
+    });
+    const resultFromSubscriberSignal = signal4(null);
+    effect2(
+      () => {
+        const observer = observerSignal();
+        const options = optionsSignal();
+        untracked3(() => {
+          observer.setOptions(options);
         });
-        const result = signal4(observer.getCurrentResult());
-        const unsubscribe = ngZone.runOutsideAngular(
-          () => observer.subscribe(
-            notifyManager4.batchCalls(
-              (state) => {
+      },
+      {
+        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
                   ])) {
                     throw state.error;
                   }
-                  result.set(state);
+                  resultFromSubscriberSignal.set(state);
                 });
-              }
+              })
             )
-          )
-        );
-        destroyRef.onDestroy(unsubscribe);
-        const resultSignal = computed3(() => ({
-          ...result(),
-          mutate,
-          mutateAsync: result().mutate
-        }));
-        return signalProxy(resultSignal);
-      })
+          );
+          destroyRef.onDestroy(unsubscribe);
+        });
+      },
+      {
+        injector
+      }
     );
+    const resultSignal = computed3(() => {
+      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,
-  effect as effect3,
-  inject as inject7,
-  signal as signal5,
-  untracked as untracked5
-} from "@angular/core";
+import { DestroyRef as DestroyRef5, NgZone as NgZone5, computed as computed4, inject as inject6, signal as signal5 } from "@angular/core";
 import {
   QueryClient as QueryClient5,
   notifyManager as notifyManager5,
   replaceEqualDeep
 } from "@tanstack/query-core";
-
-// src/util/lazy-signal-initializer/lazy-signal-initializer.ts
-import { Injector as Injector4, computed as computed4, inject as inject6, untracked as untracked4 } from "@angular/core";
-function lazySignalInitializer(initializerFn) {
-  const injector = inject6(Injector4);
-  let source = null;
-  const unwrapSignal = () => {
-    if (!source) {
-      source = untracked4(() => initializerFn(injector));
-    }
-    return source();
-  };
-  queueMicrotask(() => unwrapSignal());
-  return computed4(unwrapSignal);
-}
-
-// src/inject-mutation-state.ts
 function getResult(mutationCache, options) {
   return mutationCache.findAll(options.filters).map(
     (mutation) => options.select ? options.select(mutation) : mutation.state
@@ -342,41 +334,42 @@ function getResult(mutationCache, options) {
 }
 function injectMutationState(mutationStateOptionsFn = () => ({}), options) {
   return assertInjector(injectMutationState, options?.injector, () => {
-    const destroyRef = inject7(DestroyRef5);
-    const ngZone = inject7(NgZone5);
-    const queryClient = inject7(QueryClient5);
+    const destroyRef = inject6(DestroyRef5);
+    const ngZone = inject6(NgZone5);
+    const queryClient = inject6(QueryClient5);
     const mutationCache = queryClient.getMutationCache();
-    return lazySignalInitializer((injector) => {
-      const result = signal5(
-        getResult(mutationCache, mutationStateOptionsFn())
-      );
-      effect3(
-        () => {
-          const mutationStateOptions = mutationStateOptionsFn();
-          untracked5(() => {
-            result.set(getResult(mutationCache, mutationStateOptions));
-          });
-        },
-        { injector }
-      );
-      const unsubscribe = ngZone.runOutsideAngular(
-        () => mutationCache.subscribe(
-          notifyManager5.batchCalls(() => {
-            const nextResult = replaceEqualDeep(
-              result(),
-              getResult(mutationCache, mutationStateOptionsFn())
-            );
-            if (result() !== nextResult) {
-              ngZone.run(() => {
-                result.set(nextResult);
-              });
-            }
-          })
-        )
-      );
-      destroyRef.onDestroy(unsubscribe);
-      return result;
+    const resultFromOptionsSignal = computed4(() => {
+      return [
+        getResult(mutationCache, mutationStateOptionsFn()),
+        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, mutationStateOptionsFn())
+          );
+          if (lastResult !== nextResult) {
+            ngZone.run(() => {
+              resultFromSubscriberSignal.set([nextResult, performance.now()]);
+            });
+          }
+        })
+      )
+    );
+    destroyRef.onDestroy(unsubscribe);
+    return effectiveResultSignal;
   });
 }
 
@@ -390,8 +383,8 @@ import {
   DestroyRef as DestroyRef6,
   NgZone as NgZone6,
   computed as computed5,
-  effect as effect4,
-  inject as inject8,
+  effect as effect3,
+  inject as inject7,
   signal as signal6
 } from "@angular/core";
 function injectQueries({
@@ -399,9 +392,9 @@ function injectQueries({
   ...options
 }, injector) {
   return assertInjector(injectQueries, injector, () => {
-    const destroyRef = inject8(DestroyRef6);
-    const ngZone = inject8(NgZone6);
-    const queryClient = inject8(QueryClient6);
+    const destroyRef = inject7(DestroyRef6);
+    const ngZone = inject7(NgZone6);
+    const queryClient = inject7(QueryClient6);
     const defaultedQueries = computed5(() => {
       return queries().map((opts) => {
         const defaultedOptions = queryClient.defaultQueryOptions(opts);
@@ -414,7 +407,7 @@ function injectQueries({
       defaultedQueries(),
       options
     );
-    effect4(() => {
+    effect3(() => {
       observer.setQueries(
         defaultedQueries(),
         options,
@@ -445,21 +438,21 @@ function injectQuery(optionsFn, injector) {
 }
 
 // src/inject-query-client.ts
-import { Injector as Injector5, inject as inject9 } from "@angular/core";
+import { Injector as Injector4, inject as inject8 } from "@angular/core";
 import { QueryClient as QueryClient7 } from "@tanstack/query-core";
 function injectQueryClient(injectOptions = {}) {
-  return (injectOptions.injector ?? inject9(Injector5)).get(QueryClient7);
+  return (injectOptions.injector ?? inject8(Injector4)).get(QueryClient7);
 }
 
 // src/providers.ts
 import {
   DestroyRef as DestroyRef7,
   ENVIRONMENT_INITIALIZER,
-  Injector as Injector6,
+  Injector as Injector5,
   PLATFORM_ID,
   computed as computed6,
-  effect as effect5,
-  inject as inject10,
+  effect as effect4,
+  inject as inject9,
   makeEnvironmentProviders,
   runInInjectionContext as runInInjectionContext4
 } from "@angular/core";
@@ -477,11 +470,12 @@ function provideTanStackQuery(queryClient, ...features) {
   return makeEnvironmentProviders([
     provideQueryClient(queryClient),
     {
+      // Do not use provideEnvironmentInitializer to support Angular < v19
       provide: ENVIRONMENT_INITIALIZER,
       multi: true,
       useValue: () => {
         queryClient.mount();
-        inject10(DestroyRef7).onDestroy(() => queryClient.unmount());
+        inject9(DestroyRef7).onDestroy(() => queryClient.unmount());
       }
     },
     features.map((feature) => feature.\u0275providers)
@@ -503,9 +497,9 @@ function withDevtools(optionsFn) {
         provide: ENVIRONMENT_INITIALIZER,
         multi: true,
         useFactory: () => {
-          if (!isPlatformBrowser(inject10(PLATFORM_ID)))
+          if (!isPlatformBrowser(inject9(PLATFORM_ID)))
             return noop;
-          const injector = inject10(Injector6);
+          const injector = inject9(Injector5);
           const options = computed6(
             () => runInInjectionContext4(injector, () => optionsFn?.() ?? {})
           );
@@ -515,7 +509,7 @@ function withDevtools(optionsFn) {
             const { loadDevtools } = options();
             return typeof loadDevtools === "boolean" ? loadDevtools : isDevMode();
           });
-          const destroyRef = inject10(DestroyRef7);
+          const destroyRef = inject9(DestroyRef7);
           const getResolvedQueryClient = () => {
             const injectedClient = injector.get(QueryClient8, null);
             const client = options().client ?? injectedClient;
@@ -529,7 +523,7 @@ function withDevtools(optionsFn) {
             el?.remove();
             devtools = null;
           };
-          return () => effect5(() => {
+          return () => effect4(() => {
             const shouldLoadTools = shouldLoadToolsSignal();
             const {
               client,