@tanstack/angular-query-experimental/inject-queries.mjs

Signals for managing, caching and syncing asynchronous and remote data in Angular

import { QueryClient, QueriesObserver, notifyManager } from "@tanstack/query-core";
import { assertInInjectionContext, runInInjectionContext, inject, Injector, DestroyRef, NgZone, computed, effect, signal, untracked } from "@angular/core";
import { signalProxy } from "./signal-proxy.mjs";
import { injectIsRestoring } from "./inject-is-restoring.mjs";
function injectQueries(optionsFn, injector) {
  !injector && assertInInjectionContext(injectQueries);
  return runInInjectionContext(injector ?? inject(Injector), () => {
    const destroyRef = inject(DestroyRef);
    const ngZone = inject(NgZone);
    const queryClient = inject(QueryClient);
    const isRestoring = injectIsRestoring();
    const optionsSignal = computed(() => {
      return optionsFn();
    });
    const defaultedQueries = computed(() => {
      return optionsSignal().queries.map((opts) => {
        const defaultedOptions = queryClient.defaultQueryOptions(
          opts
        );
        defaultedOptions._optimisticResults = isRestoring() ? "isRestoring" : "optimistic";
        return defaultedOptions;
      });
    });
    const observerSignal = (() => {
      let instance = null;
      return computed(() => {
        return instance || (instance = new QueriesObserver(
          queryClient,
          defaultedQueries(),
          optionsSignal()
        ));
      });
    })();
    const optimisticResultSignal = computed(
      () => observerSignal().getOptimisticResult(
        defaultedQueries(),
        optionsSignal().combine
      )
    );
    effect(() => {
      observerSignal().setQueries(
        defaultedQueries(),
        optionsSignal()
      );
    });
    const optimisticCombinedResultSignal = computed(() => {
      const [_optimisticResult, getCombinedResult, trackResult] = optimisticResultSignal();
      return getCombinedResult(trackResult());
    });
    const resultFromSubscriberSignal = signal(null);
    effect(() => {
      const observer = observerSignal();
      const [_optimisticResult, getCombinedResult] = optimisticResultSignal();
      untracked(() => {
        const unsubscribe = isRestoring() ? () => void 0 : ngZone.runOutsideAngular(
          () => observer.subscribe(
            notifyManager.batchCalls((state) => {
              resultFromSubscriberSignal.set(getCombinedResult(state));
            })
          )
        );
        destroyRef.onDestroy(unsubscribe);
      });
    });
    const resultSignal = computed(() => {
      const subscriberResult = resultFromSubscriberSignal();
      const optimisticResult = optimisticCombinedResultSignal();
      return subscriberResult ?? optimisticResult;
    });
    return computed(() => {
      const result = resultSignal();
      const { combine } = optionsSignal();
      return combine ? result : result.map(
        (query) => signalProxy(signal(query))
      );
    });
  });
}
export {
  injectQueries
};
//# sourceMappingURL=inject-queries.mjs.map