@tanstack/angular-query-experimental 5.80.6 → 5.80.8

package/build/index.mjs

@@ -1,622 +0,0 @@
-// src/index.ts
-export * from "@tanstack/query-core";
-
-// src/query-options.ts
-function queryOptions(options) {
-  return options;
-}
-
-// src/mutation-options.ts
-function mutationOptions(options) {
-  return options;
-}
-
-// src/infinite-query-options.ts
-function infiniteQueryOptions(options) {
-  return 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 {
-  NgZone,
-  VERSION,
-  computed as computed2,
-  effect,
-  inject as inject2,
-  signal as signal2,
-  untracked as untracked2
-} from "@angular/core";
-import {
-  QueryClient,
-  notifyManager,
-  shouldThrowError
-} from "@tanstack/query-core";
-
-// src/signal-proxy.ts
-import { computed, untracked } from "@angular/core";
-function signalProxy(inputSignal) {
-  const internalState = {};
-  return new Proxy(internalState, {
-    get(target, prop) {
-      const computedField = target[prop];
-      if (computedField) return computedField;
-      const targetField = untracked(inputSignal)[prop];
-      if (typeof targetField === "function") return targetField;
-      return target[prop] = computed(() => inputSignal()[prop]);
-    },
-    has(_, prop) {
-      return !!untracked(inputSignal)[prop];
-    },
-    ownKeys() {
-      return Reflect.ownKeys(untracked(inputSignal));
-    },
-    getOwnPropertyDescriptor() {
-      return {
-        enumerable: true,
-        configurable: true
-      };
-    }
-  });
-}
-
-// src/inject-is-restoring.ts
-import {
-  InjectionToken,
-  Injector,
-  assertInInjectionContext,
-  inject,
-  signal
-} from "@angular/core";
-var IS_RESTORING = new InjectionToken(
-  typeof ngDevMode === "undefined" || ngDevMode ? "TANSTACK_QUERY_IS_RESTORING" : "",
-  {
-    // Default value when not provided
-    factory: () => signal(false).asReadonly()
-  }
-);
-function injectIsRestoring(options) {
-  !options?.injector && assertInInjectionContext(injectIsRestoring);
-  const injector = options?.injector ?? inject(Injector);
-  return injector.get(IS_RESTORING);
-}
-function provideIsRestoring(isRestoring) {
-  return {
-    provide: IS_RESTORING,
-    useValue: isRestoring
-  };
-}
-
-// src/create-base-query.ts
-function createBaseQuery(optionsFn, Observer) {
-  const ngZone = inject2(NgZone);
-  const queryClient = inject2(QueryClient);
-  const isRestoring = injectIsRestoring();
-  const defaultedOptionsSignal = computed2(() => {
-    const defaultedOptions = queryClient.defaultQueryOptions(optionsFn());
-    defaultedOptions._optimisticResults = isRestoring() ? "isRestoring" : "optimistic";
-    return defaultedOptions;
-  });
-  const observerSignal = (() => {
-    let instance = null;
-    return computed2(() => {
-      return instance ||= new Observer(queryClient, defaultedOptionsSignal());
-    });
-  })();
-  const optimisticResultSignal = computed2(
-    () => observerSignal().getOptimisticResult(defaultedOptionsSignal())
-  );
-  const resultFromSubscriberSignal = signal2(null);
-  effect(
-    (onCleanup) => {
-      const observer = observerSignal();
-      const defaultedOptions = defaultedOptionsSignal();
-      untracked2(() => {
-        observer.setOptions(defaultedOptions);
-      });
-      onCleanup(() => {
-        ngZone.run(() => resultFromSubscriberSignal.set(null));
-      });
-    },
-    {
-      // Set allowSignalWrites to support Angular < v19
-      // Set to undefined to avoid warning on newer versions
-      allowSignalWrites: VERSION.major < "19" || void 0
-    }
-  );
-  effect((onCleanup) => {
-    const observer = observerSignal();
-    const unsubscribe = isRestoring() ? () => void 0 : untracked2(
-      () => ngZone.runOutsideAngular(
-        () => observer.subscribe(
-          notifyManager.batchCalls((state) => {
-            ngZone.run(() => {
-              if (state.isError && !state.isFetching && shouldThrowError(observer.options.throwOnError, [
-                state.error,
-                observer.getCurrentQuery()
-              ])) {
-                ngZone.onError.emit(state.error);
-                throw state.error;
-              }
-              resultFromSubscriberSignal.set(state);
-            });
-          })
-        )
-      )
-    );
-    onCleanup(unsubscribe);
-  });
-  return signalProxy(
-    computed2(() => {
-      const subscriberResult = resultFromSubscriberSignal();
-      const optimisticResult = optimisticResultSignal();
-      return subscriberResult ?? optimisticResult;
-    })
-  );
-}
-
-// src/inject-infinite-query.ts
-function injectInfiniteQuery(injectInfiniteQueryFn, options) {
-  !options?.injector && assertInInjectionContext2(injectInfiniteQuery);
-  const injector = options?.injector ?? inject3(Injector2);
-  return runInInjectionContext(
-    injector,
-    () => createBaseQuery(
-      injectInfiniteQueryFn,
-      InfiniteQueryObserver
-    )
-  );
-}
-
-// src/inject-is-fetching.ts
-import {
-  DestroyRef,
-  Injector as Injector3,
-  NgZone as NgZone2,
-  assertInInjectionContext as assertInInjectionContext3,
-  inject as inject4,
-  signal as signal3
-} from "@angular/core";
-import { QueryClient as QueryClient2, notifyManager as notifyManager2 } from "@tanstack/query-core";
-function injectIsFetching(filters, options) {
-  !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 = signal3(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,
-  Injector as Injector4,
-  NgZone as NgZone3,
-  assertInInjectionContext as assertInInjectionContext4,
-  inject as inject5,
-  signal as signal4
-} from "@angular/core";
-import { QueryClient as QueryClient3, notifyManager as notifyManager3 } from "@tanstack/query-core";
-function injectIsMutating(filters, options) {
-  !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 = signal4(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 computed3,
-  effect as effect2,
-  inject as inject6,
-  signal as signal5,
-  untracked as untracked3
-} from "@angular/core";
-import {
-  MutationObserver,
-  QueryClient as QueryClient4,
-  noop,
-  notifyManager as notifyManager4,
-  shouldThrowError as shouldThrowError2
-} from "@tanstack/query-core";
-function injectMutation(injectMutationFn, options) {
-  !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 = 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);
-    };
-  });
-  const resultFromInitialOptionsSignal = computed3(() => {
-    const observer = observerSignal();
-    return observer.getCurrentResult();
-  });
-  const resultFromSubscriberSignal = signal5(null);
-  effect2(
-    () => {
-      const observer = observerSignal();
-      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 && shouldThrowError2(observer.options.throwOnError, [state.error])) {
-                  ngZone.onError.emit(state.error);
-                  throw state.error;
-                }
-                resultFromSubscriberSignal.set(state);
-              });
-            })
-          )
-        );
-        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 DestroyRef4,
-  Injector as Injector6,
-  NgZone as NgZone5,
-  assertInInjectionContext as assertInInjectionContext6,
-  computed as computed4,
-  inject as inject7,
-  signal as signal6
-} from "@angular/core";
-import {
-  QueryClient as QueryClient5,
-  notifyManager as notifyManager5,
-  replaceEqualDeep
-} from "@tanstack/query-core";
-function getResult(mutationCache, options) {
-  return mutationCache.findAll(options.filters).map(
-    (mutation) => options.select ? options.select(mutation) : mutation.state
-  );
-}
-function injectMutationState(injectMutationStateFn = () => ({}), options) {
-  !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 = computed4(() => {
-    return [
-      getResult(mutationCache, injectMutationStateFn()),
-      performance.now()
-    ];
-  });
-  const resultFromSubscriberSignal = signal6(
-    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;
-}
-
-// src/inject-queries.ts
-import {
-  QueriesObserver,
-  QueryClient as QueryClient6,
-  notifyManager as notifyManager6
-} from "@tanstack/query-core";
-import {
-  DestroyRef as DestroyRef5,
-  Injector as Injector7,
-  NgZone as NgZone6,
-  assertInInjectionContext as assertInInjectionContext7,
-  computed as computed5,
-  effect as effect3,
-  inject as inject8,
-  runInInjectionContext as runInInjectionContext2,
-  signal as signal7
-} from "@angular/core";
-function injectQueries({
-  queries,
-  ...options
-}, injector) {
-  !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 = computed5(() => {
-      return queries().map((opts) => {
-        const defaultedOptions = queryClient.defaultQueryOptions(opts);
-        defaultedOptions._optimisticResults = isRestoring() ? "isRestoring" : "optimistic";
-        return defaultedOptions;
-      });
-    });
-    const observer = new QueriesObserver(
-      queryClient,
-      defaultedQueries(),
-      options
-    );
-    effect3(() => {
-      observer.setQueries(
-        defaultedQueries(),
-        options
-      );
-    });
-    const [, getCombinedResult] = observer.getOptimisticResult(
-      defaultedQueries(),
-      options.combine
-    );
-    const result = signal7(getCombinedResult());
-    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) {
-  !options?.injector && assertInInjectionContext8(injectQuery);
-  return runInInjectionContext3(
-    options?.injector ?? inject9(Injector8),
-    () => createBaseQuery(injectQueryFn, QueryObserver)
-  );
-}
-
-// src/inject-query-client.ts
-import { Injector as Injector9, inject as inject10 } from "@angular/core";
-import { QueryClient as QueryClient7 } from "@tanstack/query-core";
-function injectQueryClient(injectOptions = {}) {
-  return (injectOptions.injector ?? inject10(Injector9)).get(QueryClient7);
-}
-
-// src/providers.ts
-import {
-  DestroyRef as DestroyRef6,
-  ENVIRONMENT_INITIALIZER,
-  InjectionToken as InjectionToken2,
-  PLATFORM_ID,
-  computed as computed6,
-  effect as effect4,
-  inject as inject11
-} from "@angular/core";
-import { QueryClient as QueryClient8, noop as noop2, onlineManager } from "@tanstack/query-core";
-import { isPlatformBrowser } from "@angular/common";
-
-// src/util/is-dev-mode/is-dev-mode.ts
-import { isDevMode } from "@angular/core";
-
-// src/providers.ts
-function provideQueryClient(queryClient) {
-  return {
-    provide: QueryClient8,
-    useFactory: () => {
-      const client = queryClient instanceof InjectionToken2 ? inject11(queryClient) : queryClient;
-      inject11(DestroyRef6).onDestroy(() => client.unmount());
-      client.mount();
-      return client;
-    }
-  };
-}
-function provideTanStackQuery(queryClient, ...features) {
-  return [
-    provideQueryClient(queryClient),
-    features.map((feature) => feature.\u0275providers)
-  ];
-}
-function queryFeature(kind, providers) {
-  return { \u0275kind: kind, \u0275providers: providers };
-}
-function withDevtools(withDevtoolsFn) {
-  let providers = [];
-  if (!isDevMode() && !withDevtoolsFn) {
-    providers = [];
-  } else {
-    providers = [
-      {
-        // Do not use provideEnvironmentInitializer while Angular < v19 is supported
-        provide: ENVIRONMENT_INITIALIZER,
-        multi: true,
-        useFactory: () => {
-          if (!isPlatformBrowser(inject11(PLATFORM_ID))) return noop2;
-          const injectedClient = inject11(QueryClient8, {
-            optional: true
-          });
-          const destroyRef = inject11(DestroyRef6);
-          const options = computed6(() => withDevtoolsFn?.() ?? {});
-          let devtools = null;
-          let el = null;
-          const shouldLoadToolsSignal = computed6(() => {
-            const { loadDevtools } = options();
-            return typeof loadDevtools === "boolean" ? loadDevtools : isDevMode();
-          });
-          const getResolvedQueryClient = () => {
-            const client = options().client ?? injectedClient;
-            if (!client) {
-              throw new Error("No QueryClient found");
-            }
-            return client;
-          };
-          const destroyDevtools = () => {
-            devtools?.unmount();
-            el?.remove();
-            devtools = null;
-          };
-          return () => effect4(() => {
-            const shouldLoadTools = shouldLoadToolsSignal();
-            const {
-              client,
-              position,
-              errorTypes,
-              buttonPosition,
-              initialIsOpen
-            } = options();
-            if (devtools && !shouldLoadTools) {
-              destroyDevtools();
-              return;
-            } else if (devtools && shouldLoadTools) {
-              client && devtools.setClient(client);
-              position && devtools.setPosition(position);
-              errorTypes && devtools.setErrorTypes(errorTypes);
-              buttonPosition && devtools.setButtonPosition(buttonPosition);
-              initialIsOpen && devtools.setInitialIsOpen(initialIsOpen);
-              return;
-            } else if (!shouldLoadTools) {
-              return;
-            }
-            el = document.body.appendChild(document.createElement("div"));
-            el.classList.add("tsqd-parent-container");
-            import("@tanstack/query-devtools").then((queryDevtools) => {
-              devtools = new queryDevtools.TanstackQueryDevtools({
-                ...options(),
-                client: getResolvedQueryClient(),
-                queryFlavor: "Angular Query",
-                version: "5",
-                onlineManager
-              });
-              el && devtools.mount(el);
-              destroyRef.onDestroy(destroyDevtools);
-            });
-          });
-        }
-      }
-    ];
-  }
-  return queryFeature("DeveloperTools", providers);
-}
-var queryFeatures = ["DeveloperTools", "PersistQueryClient"];
-export {
-  infiniteQueryOptions,
-  injectInfiniteQuery,
-  injectIsFetching,
-  injectIsMutating,
-  injectIsRestoring,
-  injectMutation,
-  injectMutationState,
-  injectQueries,
-  injectQuery,
-  injectQueryClient,
-  mutationOptions,
-  provideIsRestoring,
-  provideQueryClient,
-  provideTanStackQuery,
-  queryFeature,
-  queryFeatures,
-  queryOptions,
-  withDevtools
-};
-//# sourceMappingURL=index.mjs.map