@tanstack/angular-query-experimental 5.84.0 → 5.84.2

package/src/inject-infinite-query.ts

@@ -1,129 +0,0 @@
-import { InfiniteQueryObserver } from '@tanstack/query-core'
-import {
-  Injector,
-  assertInInjectionContext,
-  inject,
-  runInInjectionContext,
-} from '@angular/core'
-import { createBaseQuery } from './create-base-query'
-import type {
-  DefaultError,
-  InfiniteData,
-  QueryKey,
-  QueryObserver,
-} from '@tanstack/query-core'
-import type {
-  CreateInfiniteQueryOptions,
-  CreateInfiniteQueryResult,
-  DefinedCreateInfiniteQueryResult,
-} from './types'
-import type {
-  DefinedInitialDataInfiniteOptions,
-  UndefinedInitialDataInfiniteOptions,
-} from './infinite-query-options'
-
-export 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"
- * @param injectInfiniteQueryFn - A function that returns infinite query options.
- * @param options - Additional configuration.
- * @returns The infinite query result.
- * @public
- */
-export function injectInfiniteQuery<
-  TQueryFnData,
-  TError = DefaultError,
-  TData = InfiniteData<TQueryFnData>,
-  TQueryKey extends QueryKey = QueryKey,
-  TPageParam = unknown,
->(
-  injectInfiniteQueryFn: () => DefinedInitialDataInfiniteOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryKey,
-    TPageParam
-  >,
-  options?: InjectInfiniteQueryOptions,
-): DefinedCreateInfiniteQueryResult<TData, TError>
-
-/**
- * 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"
- * @param injectInfiniteQueryFn - A function that returns infinite query options.
- * @param options - Additional configuration.
- * @returns The infinite query result.
- * @public
- */
-export function injectInfiniteQuery<
-  TQueryFnData,
-  TError = DefaultError,
-  TData = InfiniteData<TQueryFnData>,
-  TQueryKey extends QueryKey = QueryKey,
-  TPageParam = unknown,
->(
-  injectInfiniteQueryFn: () => UndefinedInitialDataInfiniteOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryKey,
-    TPageParam
-  >,
-  options?: InjectInfiniteQueryOptions,
-): CreateInfiniteQueryResult<TData, TError>
-
-/**
- * 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"
- * @param injectInfiniteQueryFn - A function that returns infinite query options.
- * @param options - Additional configuration.
- * @returns The infinite query result.
- * @public
- */
-export function injectInfiniteQuery<
-  TQueryFnData,
-  TError = DefaultError,
-  TData = InfiniteData<TQueryFnData>,
-  TQueryKey extends QueryKey = QueryKey,
-  TPageParam = unknown,
->(
-  injectInfiniteQueryFn: () => CreateInfiniteQueryOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryKey,
-    TPageParam
-  >,
-  options?: InjectInfiniteQueryOptions,
-): CreateInfiniteQueryResult<TData, TError>
-
-/**
- * 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"
- * @param injectInfiniteQueryFn - A function that returns infinite query options.
- * @param options - Additional configuration.
- * @returns The infinite query result.
- * @public
- */
-export function injectInfiniteQuery(
-  injectInfiniteQueryFn: () => CreateInfiniteQueryOptions,
-  options?: InjectInfiniteQueryOptions,
-) {
-  !options?.injector && assertInInjectionContext(injectInfiniteQuery)
-  const injector = options?.injector ?? inject(Injector)
-  return runInInjectionContext(injector, () =>
-    createBaseQuery(
-      injectInfiniteQueryFn,
-      InfiniteQueryObserver as typeof QueryObserver,
-    ),
-  )
-}

package/src/inject-is-fetching.ts

@@ -1,66 +0,0 @@
-import {
-  DestroyRef,
-  Injector,
-  NgZone,
-  assertInInjectionContext,
-  inject,
-  signal,
-} from '@angular/core'
-import { QueryClient, notifyManager } from '@tanstack/query-core'
-import type { QueryFilters } from '@tanstack/query-core'
-import type { Signal } from '@angular/core'
-
-export interface InjectIsFetchingOptions {
-  /**
-   * The `Injector` in which to create the isFetching signal.
-   *
-   * If this is not provided, the current injection context will be used instead (via `inject`).
-   */
-  injector?: Injector
-}
-
-/**
- * Injects a signal that tracks the number of queries that your application is loading or
- * fetching in the background.
- *
- * Can be used for app-wide loading indicators
- * @param filters - The filters to apply to the query.
- * @param options - Additional configuration
- * @returns signal with number of loading or fetching queries.
- * @public
- */
-export function injectIsFetching(
-  filters?: QueryFilters,
-  options?: InjectIsFetchingOptions,
-): Signal<number> {
-  !options?.injector && assertInInjectionContext(injectIsFetching)
-  const injector = options?.injector ?? inject(Injector)
-  const destroyRef = injector.get(DestroyRef)
-  const ngZone = injector.get(NgZone)
-  const queryClient = injector.get(QueryClient)
-
-  const cache = queryClient.getQueryCache()
-  // isFetching is the prev value initialized on mount *
-  let isFetching = queryClient.isFetching(filters)
-
-  const result = signal(isFetching)
-
-  const unsubscribe = ngZone.runOutsideAngular(() =>
-    cache.subscribe(
-      notifyManager.batchCalls(() => {
-        const newIsFetching = queryClient.isFetching(filters)
-        if (isFetching !== newIsFetching) {
-          // * and update with each change
-          isFetching = newIsFetching
-          ngZone.run(() => {
-            result.set(isFetching)
-          })
-        }
-      }),
-    ),
-  )
-
-  destroyRef.onDestroy(unsubscribe)
-
-  return result
-}

package/src/inject-is-mutating.ts

@@ -1,65 +0,0 @@
-import {
-  DestroyRef,
-  Injector,
-  NgZone,
-  assertInInjectionContext,
-  inject,
-  signal,
-} from '@angular/core'
-import { QueryClient, notifyManager } from '@tanstack/query-core'
-import type { MutationFilters } from '@tanstack/query-core'
-import type { Signal } from '@angular/core'
-
-export interface InjectIsMutatingOptions {
-  /**
-   * The `Injector` in which to create the isMutating signal.
-   *
-   * If this is not provided, the current injection context will be used instead (via `inject`).
-   */
-  injector?: Injector
-}
-
-/**
- * Injects a signal that tracks the number of mutations that your application is fetching.
- *
- * Can be used for app-wide loading indicators
- * @param filters - The filters to apply to the query.
- * @param options - Additional configuration
- * @returns signal with number of fetching mutations.
- * @public
- */
-export function injectIsMutating(
-  filters?: MutationFilters,
-  options?: InjectIsMutatingOptions,
-): Signal<number> {
-  !options?.injector && assertInInjectionContext(injectIsMutating)
-  const injector = options?.injector ?? inject(Injector)
-  const destroyRef = injector.get(DestroyRef)
-  const ngZone = injector.get(NgZone)
-  const queryClient = injector.get(QueryClient)
-
-  const cache = queryClient.getMutationCache()
-  // isMutating is the prev value initialized on mount *
-  let isMutating = queryClient.isMutating(filters)
-
-  const result = signal(isMutating)
-
-  const unsubscribe = ngZone.runOutsideAngular(() =>
-    cache.subscribe(
-      notifyManager.batchCalls(() => {
-        const newIsMutating = queryClient.isMutating(filters)
-        if (isMutating !== newIsMutating) {
-          // * and update with each change
-          isMutating = newIsMutating
-          ngZone.run(() => {
-            result.set(isMutating)
-          })
-        }
-      }),
-    ),
-  )
-
-  destroyRef.onDestroy(unsubscribe)
-
-  return result
-}

package/src/inject-is-restoring.ts

@@ -1,52 +0,0 @@
-import {
-  InjectionToken,
-  Injector,
-  assertInInjectionContext,
-  inject,
-  signal,
-} from '@angular/core'
-import type { Provider, Signal } from '@angular/core'
-
-const IS_RESTORING = new InjectionToken(
-  typeof ngDevMode === 'undefined' || ngDevMode
-    ? 'TANSTACK_QUERY_IS_RESTORING'
-    : '',
-  {
-    // Default value when not provided
-    factory: () => signal(false).asReadonly(),
-  },
-)
-
-/**
- * The `Injector` in which to create the isRestoring signal.
- *
- * If this is not provided, the current injection context will be used instead (via `inject`).
- */
-interface InjectIsRestoringOptions {
-  injector?: Injector
-}
-
-/**
- * Injects a signal that tracks whether a restore is currently in progress. {@link injectQuery} and friends also check this internally to avoid race conditions between the restore and initializing queries.
- * @param options - Options for injectIsRestoring.
- * @returns signal with boolean that indicates whether a restore is in progress.
- * @public
- */
-export function injectIsRestoring(options?: InjectIsRestoringOptions) {
-  !options?.injector && assertInInjectionContext(injectIsRestoring)
-  const injector = options?.injector ?? inject(Injector)
-  return injector.get(IS_RESTORING)
-}
-
-/**
- * Used by TanStack Query Angular persist client plugin to provide the signal that tracks the restore state
- * @param isRestoring - a readonly signal that returns a boolean
- * @returns Provider for the `isRestoring` signal
- * @public
- */
-export function provideIsRestoring(isRestoring: Signal<boolean>): Provider {
-  return {
-    provide: IS_RESTORING,
-    useValue: isRestoring,
-  }
-}

package/src/inject-mutation-state.ts

@@ -1,125 +0,0 @@
-import {
-  DestroyRef,
-  Injector,
-  NgZone,
-  assertInInjectionContext,
-  computed,
-  inject,
-  signal,
-} from '@angular/core'
-import {
-  QueryClient,
-  notifyManager,
-  replaceEqualDeep,
-} from '@tanstack/query-core'
-import type { Signal } from '@angular/core'
-import type {
-  Mutation,
-  MutationCache,
-  MutationFilters,
-  MutationState,
-} from '@tanstack/query-core'
-
-type MutationStateOptions<TResult = MutationState> = {
-  filters?: MutationFilters
-  select?: (mutation: Mutation) => TResult
-}
-
-/**
- *
- * @param mutationCache
- * @param options
- */
-function getResult<TResult = MutationState>(
-  mutationCache: MutationCache,
-  options: MutationStateOptions<TResult>,
-): Array<TResult> {
-  return mutationCache
-    .findAll(options.filters)
-    .map(
-      (mutation): TResult =>
-        (options.select ? options.select(mutation) : mutation.state) as TResult,
-    )
-}
-
-/**
- * @public
- */
-export interface InjectMutationStateOptions {
-  /**
-   * The `Injector` in which to create the mutation state signal.
-   *
-   * If this is not provided, the current injection context will be used instead (via `inject`).
-   */
-  injector?: Injector
-}
-
-/**
- * Injects a signal that tracks the state of all mutations.
- * @param injectMutationStateFn - A function that returns mutation state options.
- * @param options - The Angular injector to use.
- * @returns The signal that tracks the state of all mutations.
- * @public
- */
-export function injectMutationState<TResult = MutationState>(
-  injectMutationStateFn: () => MutationStateOptions<TResult> = () => ({}),
-  options?: InjectMutationStateOptions,
-): Signal<Array<TResult>> {
-  !options?.injector && assertInInjectionContext(injectMutationState)
-  const injector = options?.injector ?? inject(Injector)
-  const destroyRef = injector.get(DestroyRef)
-  const ngZone = injector.get(NgZone)
-  const queryClient = injector.get(QueryClient)
-  const mutationCache = queryClient.getMutationCache()
-
-  /**
-   * Computed signal that gets result from mutation cache based on passed options
-   * First element is the result, second element is the time when the result was set
-   */
-  const resultFromOptionsSignal = computed(() => {
-    return [
-      getResult(mutationCache, injectMutationStateFn()),
-      performance.now(),
-    ] as const
-  })
-
-  /**
-   * Signal that contains result set by subscriber
-   * First element is the result, second element is the time when the result was set
-   */
-  const resultFromSubscriberSignal = signal<[Array<TResult>, number] | null>(
-    null,
-  )
-
-  /**
-   * Returns the last result by either subscriber or options
-   */
-  const effectiveResultSignal = computed(() => {
-    const optionsResult = resultFromOptionsSignal()
-    const subscriberResult = resultFromSubscriberSignal()
-    return subscriberResult && subscriberResult[1] > optionsResult[1]
-      ? subscriberResult[0]
-      : optionsResult[0]
-  })
-
-  const unsubscribe = ngZone.runOutsideAngular(() =>
-    mutationCache.subscribe(
-      notifyManager.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
-}

package/src/inject-mutation.ts

@@ -1,169 +0,0 @@
-import {
-  DestroyRef,
-  Injector,
-  NgZone,
-  assertInInjectionContext,
-  computed,
-  effect,
-  inject,
-  signal,
-  untracked,
-} from '@angular/core'
-import {
-  MutationObserver,
-  QueryClient,
-  noop,
-  notifyManager,
-  shouldThrowError,
-} from '@tanstack/query-core'
-import { signalProxy } from './signal-proxy'
-import type { DefaultError, MutationObserverResult } from '@tanstack/query-core'
-import type { CreateMutateFunction, CreateMutationResult } from './types'
-import type { CreateMutationOptions } from './mutation-options'
-
-export interface InjectMutationOptions {
-  /**
-   * The `Injector` in which to create the mutation.
-   *
-   * If this is not provided, the current injection context will be used instead (via `inject`).
-   */
-  injector?: Injector
-}
-
-/**
- * Injects a mutation: an imperative function that can be invoked which typically performs server side effects.
- *
- * Unlike queries, mutations are not run automatically.
- * @param injectMutationFn - A function that returns mutation options.
- * @param options - Additional configuration
- * @returns The mutation.
- * @public
- */
-export function injectMutation<
-  TData = unknown,
-  TError = DefaultError,
-  TVariables = void,
-  TContext = unknown,
->(
-  injectMutationFn: () => CreateMutationOptions<
-    TData,
-    TError,
-    TVariables,
-    TContext
-  >,
-  options?: InjectMutationOptions,
-): CreateMutationResult<TData, TError, TVariables, TContext> {
-  !options?.injector && assertInInjectionContext(injectMutation)
-  const injector = options?.injector ?? inject(Injector)
-  const destroyRef = injector.get(DestroyRef)
-  const ngZone = injector.get(NgZone)
-  const queryClient = injector.get(QueryClient)
-
-  /**
-   * computed() is used so signals can be inserted into the options
-   * making it reactive. Wrapping options in a function ensures embedded expressions
-   * are preserved and can keep being applied after signal changes
-   */
-  const optionsSignal = computed(injectMutationFn)
-
-  const observerSignal = (() => {
-    let instance: MutationObserver<TData, TError, TVariables, TContext> | null =
-      null
-
-    return computed(() => {
-      return (instance ||= new MutationObserver(queryClient, optionsSignal()))
-    })
-  })()
-
-  const mutateFnSignal = computed<
-    CreateMutateFunction<TData, TError, TVariables, TContext>
-  >(() => {
-    const observer = observerSignal()
-    return (variables, mutateOptions) => {
-      observer.mutate(variables, mutateOptions).catch(noop)
-    }
-  })
-
-  /**
-   * Computed signal that gets result from mutation cache based on passed options
-   */
-  const resultFromInitialOptionsSignal = computed(() => {
-    const observer = observerSignal()
-    return observer.getCurrentResult()
-  })
-
-  /**
-   * Signal that contains result set by subscriber
-   */
-  const resultFromSubscriberSignal = signal<MutationObserverResult<
-    TData,
-    TError,
-    TVariables,
-    TContext
-  > | null>(null)
-
-  effect(
-    () => {
-      const observer = observerSignal()
-      const observerOptions = optionsSignal()
-
-      untracked(() => {
-        observer.setOptions(observerOptions)
-      })
-    },
-    {
-      injector,
-    },
-  )
-
-  effect(
-    () => {
-      // observer.trackResult is not used as this optimization is not needed for Angular
-      const observer = observerSignal()
-
-      untracked(() => {
-        const unsubscribe = ngZone.runOutsideAngular(() =>
-          observer.subscribe(
-            notifyManager.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 = computed(() => {
-    const resultFromSubscriber = resultFromSubscriberSignal()
-    const resultFromInitialOptions = resultFromInitialOptionsSignal()
-
-    const result = resultFromSubscriber ?? resultFromInitialOptions
-
-    return {
-      ...result,
-      mutate: mutateFnSignal(),
-      mutateAsync: result.mutate,
-    }
-  })
-
-  return signalProxy(resultSignal) as CreateMutationResult<
-    TData,
-    TError,
-    TVariables,
-    TContext
-  >
-}