@tanstack/angular-query-experimental 5.84.0 → 5.84.1

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
-  >
-}

package/src/inject-queries.ts

@@ -1,271 +0,0 @@
-import {
-  QueriesObserver,
-  QueryClient,
-  notifyManager,
-} from '@tanstack/query-core'
-import {
-  DestroyRef,
-  Injector,
-  NgZone,
-  assertInInjectionContext,
-  computed,
-  effect,
-  inject,
-  runInInjectionContext,
-  signal,
-} from '@angular/core'
-import { injectIsRestoring } from './inject-is-restoring'
-import type { Signal } from '@angular/core'
-import type {
-  DefaultError,
-  OmitKeyof,
-  QueriesObserverOptions,
-  QueriesPlaceholderDataFunction,
-  QueryFunction,
-  QueryKey,
-  QueryObserverOptions,
-  QueryObserverResult,
-  ThrowOnError,
-} from '@tanstack/query-core'
-
-// This defines the `CreateQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.
-// `placeholderData` function does not have a parameter
-type QueryObserverOptionsForCreateQueries<
-  TQueryFnData = unknown,
-  TError = DefaultError,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
-> = OmitKeyof<
-  QueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>,
-  'placeholderData'
-> & {
-  placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>
-}
-
-// Avoid TS depth-limit error in case of large array literal
-type MAXIMUM_DEPTH = 20
-
-// Widen the type of the symbol to enable type inference even if skipToken is not immutable.
-type SkipTokenForUseQueries = symbol
-
-type GetOptions<T> =
-  // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }
-  T extends {
-    queryFnData: infer TQueryFnData
-    error?: infer TError
-    data: infer TData
-  }
-    ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData>
-    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }
-      ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError>
-      : T extends { data: infer TData; error?: infer TError }
-        ? QueryObserverOptionsForCreateQueries<unknown, TError, TData>
-        : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]
-          T extends [infer TQueryFnData, infer TError, infer TData]
-          ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData>
-          : T extends [infer TQueryFnData, infer TError]
-            ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError>
-            : T extends [infer TQueryFnData]
-              ? QueryObserverOptionsForCreateQueries<TQueryFnData>
-              : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided
-                T extends {
-                    queryFn?:
-                      | QueryFunction<infer TQueryFnData, infer TQueryKey>
-                      | SkipTokenForUseQueries
-                    select: (data: any) => infer TData
-                    throwOnError?: ThrowOnError<any, infer TError, any, any>
-                  }
-                ? QueryObserverOptionsForCreateQueries<
-                    TQueryFnData,
-                    unknown extends TError ? DefaultError : TError,
-                    unknown extends TData ? TQueryFnData : TData,
-                    TQueryKey
-                  >
-                : // Fallback
-                  QueryObserverOptionsForCreateQueries
-
-type GetResults<T> =
-  // Part 1: responsible for mapping explicit type parameter to function result, if object
-  T extends { queryFnData: any; error?: infer TError; data: infer TData }
-    ? QueryObserverResult<TData, TError>
-    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }
-      ? QueryObserverResult<TQueryFnData, TError>
-      : T extends { data: infer TData; error?: infer TError }
-        ? QueryObserverResult<TData, TError>
-        : // Part 2: responsible for mapping explicit type parameter to function result, if tuple
-          T extends [any, infer TError, infer TData]
-          ? QueryObserverResult<TData, TError>
-          : T extends [infer TQueryFnData, infer TError]
-            ? QueryObserverResult<TQueryFnData, TError>
-            : T extends [infer TQueryFnData]
-              ? QueryObserverResult<TQueryFnData>
-              : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided
-                T extends {
-                    queryFn?:
-                      | QueryFunction<infer TQueryFnData, any>
-                      | SkipTokenForUseQueries
-                    select: (data: any) => infer TData
-                    throwOnError?: ThrowOnError<any, infer TError, any, any>
-                  }
-                ? QueryObserverResult<
-                    unknown extends TData ? TQueryFnData : TData,
-                    unknown extends TError ? DefaultError : TError
-                  >
-                : // Fallback
-                  QueryObserverResult
-
-/**
- * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
- * @public
- */
-export type QueriesOptions<
-  T extends Array<any>,
-  TResult extends Array<any> = [],
-  TDepth extends ReadonlyArray<number> = [],
-> = TDepth['length'] extends MAXIMUM_DEPTH
-  ? Array<QueryObserverOptionsForCreateQueries>
-  : T extends []
-    ? []
-    : T extends [infer Head]
-      ? [...TResult, GetOptions<Head>]
-      : T extends [infer Head, ...infer Tail]
-        ? QueriesOptions<
-            [...Tail],
-            [...TResult, GetOptions<Head>],
-            [...TDepth, 1]
-          >
-        : ReadonlyArray<unknown> extends T
-          ? T
-          : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogenous type!
-            // use this to infer the param types in the case of Array.map() argument
-            T extends Array<
-                QueryObserverOptionsForCreateQueries<
-                  infer TQueryFnData,
-                  infer TError,
-                  infer TData,
-                  infer TQueryKey
-                >
-              >
-            ? Array<
-                QueryObserverOptionsForCreateQueries<
-                  TQueryFnData,
-                  TError,
-                  TData,
-                  TQueryKey
-                >
-              >
-            : // Fallback
-              Array<QueryObserverOptionsForCreateQueries>
-
-/**
- * QueriesResults reducer recursively maps type param to results
- * @public
- */
-export type QueriesResults<
-  T extends Array<any>,
-  TResult extends Array<any> = [],
-  TDepth extends ReadonlyArray<number> = [],
-> = TDepth['length'] extends MAXIMUM_DEPTH
-  ? Array<QueryObserverResult>
-  : T extends []
-    ? []
-    : T extends [infer Head]
-      ? [...TResult, GetResults<Head>]
-      : T extends [infer Head, ...infer Tail]
-        ? QueriesResults<
-            [...Tail],
-            [...TResult, GetResults<Head>],
-            [...TDepth, 1]
-          >
-        : T extends Array<
-              QueryObserverOptionsForCreateQueries<
-                infer TQueryFnData,
-                infer TError,
-                infer TData,
-                any
-              >
-            >
-          ? // Dynamic-size (homogenous) CreateQueryOptions array: map directly to array of results
-            Array<
-              QueryObserverResult<
-                unknown extends TData ? TQueryFnData : TData,
-                unknown extends TError ? DefaultError : TError
-              >
-            >
-          : // Fallback
-            Array<QueryObserverResult>
-
-/**
- * @param root0
- * @param root0.queries
- * @param root0.combine
- * @param injector
- * @param injector
- * @public
- */
-export function injectQueries<
-  T extends Array<any>,
-  TCombinedResult = QueriesResults<T>,
->(
-  {
-    queries,
-    ...options
-  }: {
-    queries: Signal<[...QueriesOptions<T>]>
-    combine?: (result: QueriesResults<T>) => TCombinedResult
-  },
-  injector?: Injector,
-): Signal<TCombinedResult> {
-  !injector && assertInInjectionContext(injectQueries)
-  return runInInjectionContext(injector ?? inject(Injector), () => {
-    const destroyRef = inject(DestroyRef)
-    const ngZone = inject(NgZone)
-    const queryClient = inject(QueryClient)
-    const isRestoring = injectIsRestoring()
-
-    const defaultedQueries = computed(() => {
-      return queries().map((opts) => {
-        const defaultedOptions = queryClient.defaultQueryOptions(opts)
-        // Make sure the results are already in fetching state before subscribing or updating options
-        defaultedOptions._optimisticResults = isRestoring()
-          ? 'isRestoring'
-          : 'optimistic'
-
-        return defaultedOptions as QueryObserverOptions
-      })
-    })
-
-    const observer = new QueriesObserver<TCombinedResult>(
-      queryClient,
-      defaultedQueries(),
-      options as QueriesObserverOptions<TCombinedResult>,
-    )
-
-    // Do not notify on updates because of changes in the options because
-    // these changes should already be reflected in the optimistic result.
-    effect(() => {
-      observer.setQueries(
-        defaultedQueries(),
-        options as QueriesObserverOptions<TCombinedResult>,
-      )
-    })
-
-    const [, getCombinedResult] = observer.getOptimisticResult(
-      defaultedQueries(),
-      (options as QueriesObserverOptions<TCombinedResult>).combine,
-    )
-
-    const result = signal(getCombinedResult() as any)
-
-    effect(() => {
-      const unsubscribe = isRestoring()
-        ? () => undefined
-        : ngZone.runOutsideAngular(() =>
-            observer.subscribe(notifyManager.batchCalls(result.set)),
-          )
-      destroyRef.onDestroy(unsubscribe)
-    })
-
-    return result
-  })
-}

package/src/inject-query-client.ts

@@ -1,23 +0,0 @@
-import { Injector, inject } from '@angular/core'
-import { QueryClient } from '@tanstack/query-core'
-import type { InjectOptions } from '@angular/core'
-
-/**
- * Injects a `QueryClient` instance and allows passing a custom injector.
- * @param injectOptions - Type of the options argument to inject and optionally a custom injector.
- * @returns The `QueryClient` instance.
- * @public
- * @deprecated Use `inject(QueryClient)` instead.
- * If you need to get a `QueryClient` from a custom injector, use `injector.get(QueryClient)`.
- *
- *
- * **Example**
- * ```ts
- * const queryClient = injectQueryClient();
- * ```
- */
-export function injectQueryClient(
-  injectOptions: InjectOptions & { injector?: Injector } = {},
-) {
-  return (injectOptions.injector ?? inject(Injector)).get(QueryClient)
-}