@tanstack/angular-query-experimental 5.80.6 → 5.80.8

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/providers.ts

@@ -1,368 +0,0 @@
-import {
-  DestroyRef,
-  ENVIRONMENT_INITIALIZER,
-  InjectionToken,
-  PLATFORM_ID,
-  computed,
-  effect,
-  inject,
-} from '@angular/core'
-import { QueryClient, noop, onlineManager } from '@tanstack/query-core'
-import { isPlatformBrowser } from '@angular/common'
-import { isDevMode } from './util/is-dev-mode/is-dev-mode'
-import type { Provider } from '@angular/core'
-import type {
-  DevtoolsButtonPosition,
-  DevtoolsErrorType,
-  DevtoolsPosition,
-  TanstackQueryDevtools,
-} from '@tanstack/query-devtools'
-
-/**
- * Usually {@link provideTanStackQuery} is used once to set up TanStack Query and the
- * {@link https://tanstack.com/query/latest/docs/reference/QueryClient|QueryClient}
- * for the entire application. Internally it calls `provideQueryClient`.
- * You can use `provideQueryClient` to provide a different `QueryClient` instance for a part
- * of the application or for unit testing purposes.
- * @param queryClient - A `QueryClient` instance, or an `InjectionToken` which provides a `QueryClient`.
- * @returns a provider object that can be used to provide the `QueryClient` instance.
- */
-export function provideQueryClient(
-  queryClient: QueryClient | InjectionToken<QueryClient>,
-): Provider {
-  return {
-    provide: QueryClient,
-    useFactory: () => {
-      const client =
-        queryClient instanceof InjectionToken
-          ? inject(queryClient)
-          : queryClient
-      // Unmount the query client on injector destroy
-      inject(DestroyRef).onDestroy(() => client.unmount())
-      client.mount()
-      return client
-    },
-  }
-}
-
-/**
- * Sets up providers necessary to enable TanStack Query functionality for Angular applications.
- *
- * Allows to configure a `QueryClient` and optional features such as developer tools.
- *
- * **Example - standalone**
- *
- * ```ts
- * import {
- *   provideTanStackQuery,
- *   QueryClient,
- * } from '@tanstack/angular-query-experimental'
- *
- * bootstrapApplication(AppComponent, {
- *   providers: [provideTanStackQuery(new QueryClient())],
- * })
- * ```
- *
- * **Example - NgModule-based**
- *
- * ```ts
- * import {
- *   provideTanStackQuery,
- *   QueryClient,
- * } from '@tanstack/angular-query-experimental'
- *
- * @NgModule({
- *   declarations: [AppComponent],
- *   imports: [BrowserModule],
- *   providers: [provideTanStackQuery(new QueryClient())],
- *   bootstrap: [AppComponent],
- * })
- * export class AppModule {}
- * ```
- *
- * You can also enable optional developer tools by adding `withDevtools`. By
- * default the tools will then be loaded when your app is in development mode.
- * ```ts
- * import {
- *   provideTanStackQuery,
- *   withDevtools
- *   QueryClient,
- * } from '@tanstack/angular-query-experimental'
- *
- * bootstrapApplication(AppComponent,
- *   {
- *     providers: [
- *       provideTanStackQuery(new QueryClient(), withDevtools())
- *     ]
- *   }
- * )
- * ```
- *
- * **Example: using an InjectionToken**
- *
- * ```ts
- * export const MY_QUERY_CLIENT = new InjectionToken('', {
- *   factory: () => new QueryClient(),
- * })
- *
- * // In a lazy loaded route or lazy loaded component's providers array:
- * providers: [provideTanStackQuery(MY_QUERY_CLIENT)]
- * ```
- * @param queryClient - A `QueryClient` instance, or an `InjectionToken` which provides a `QueryClient`.
- * @param features - Optional features to configure additional Query functionality.
- * @returns A set of providers to set up TanStack Query.
- * @see https://tanstack.com/query/v5/docs/framework/angular/quick-start
- * @see withDevtools
- */
-export function provideTanStackQuery(
-  queryClient: QueryClient | InjectionToken<QueryClient>,
-  ...features: Array<QueryFeatures>
-): Array<Provider> {
-  return [
-    provideQueryClient(queryClient),
-    features.map((feature) => feature.ɵproviders),
-  ]
-}
-
-/**
- * Sets up providers necessary to enable TanStack Query functionality for Angular applications.
- *
- * Allows to configure a `QueryClient`.
- * @param queryClient - A `QueryClient` instance.
- * @returns A set of providers to set up TanStack Query.
- * @public
- * @see https://tanstack.com/query/v5/docs/framework/angular/quick-start
- * @deprecated Use `provideTanStackQuery` instead.
- */
-export function provideAngularQuery(queryClient: QueryClient): Array<Provider> {
-  return provideTanStackQuery(queryClient)
-}
-
-/**
- * Helper type to represent a Query feature.
- */
-export interface QueryFeature<TFeatureKind extends QueryFeatureKind> {
-  ɵkind: TFeatureKind
-  ɵproviders: Array<Provider>
-}
-
-/**
- * Helper function to create an object that represents a Query feature.
- * @param kind -
- * @param providers -
- * @returns A Query feature.
- */
-export function queryFeature<TFeatureKind extends QueryFeatureKind>(
-  kind: TFeatureKind,
-  providers: Array<Provider>,
-): QueryFeature<TFeatureKind> {
-  return { ɵkind: kind, ɵproviders: providers }
-}
-
-/**
- * A type alias that represents a feature which enables developer tools.
- * The type is used to describe the return value of the `withDevtools` function.
- * @public
- * @see {@link withDevtools}
- */
-export type DeveloperToolsFeature = QueryFeature<'DeveloperTools'>
-
-/**
- * A type alias that represents a feature which enables persistence.
- * The type is used to describe the return value of the `withPersistQueryClient` function.
- * @public
- */
-export type PersistQueryClientFeature = QueryFeature<'PersistQueryClient'>
-
-/**
- * Options for configuring the TanStack Query devtools.
- * @public
- */
-export interface DevtoolsOptions {
-  /**
-   * Set this true if you want the devtools to default to being open
-   */
-  initialIsOpen?: boolean
-  /**
-   * The position of the TanStack logo to open and close the devtools panel.
-   * `top-left` | `top-right` | `bottom-left` | `bottom-right` | `relative`
-   * Defaults to `bottom-right`.
-   */
-  buttonPosition?: DevtoolsButtonPosition
-  /**
-   * The position of the TanStack Query devtools panel.
-   * `top` | `bottom` | `left` | `right`
-   * Defaults to `bottom`.
-   */
-  position?: DevtoolsPosition
-  /**
-   * Custom instance of QueryClient
-   */
-  client?: QueryClient
-  /**
-   * Use this so you can define custom errors that can be shown in the devtools.
-   */
-  errorTypes?: Array<DevtoolsErrorType>
-  /**
-   * Use this to pass a nonce to the style tag that is added to the document head. This is useful if you are using a Content Security Policy (CSP) nonce to allow inline styles.
-   */
-  styleNonce?: string
-  /**
-   * Use this so you can attach the devtool's styles to a specific element in the DOM.
-   */
-  shadowDOMTarget?: ShadowRoot
-
-  /**
-   * Whether the developer tools should load.
-   * - `auto`- (Default) Lazily loads devtools when in development mode. Skips loading in production mode.
-   * - `true`- Always load the devtools, regardless of the environment.
-   * - `false`- Never load the devtools, regardless of the environment.
-   *
-   * You can use `true` and `false` to override loading developer tools from an environment file.
-   * For example, a test environment might run in production mode but you may want to load developer tools.
-   *
-   * Additionally, you can use a signal in the callback to dynamically load the devtools based on a condition. For example,
-   * a signal created from a RxJS observable that listens for a keyboard shortcut.
-   *
-   * **Example**
-   * ```ts
-   *    withDevtools(() => ({
-   *      initialIsOpen: true,
-   *      loadDevtools: inject(ExampleService).loadDevtools()
-   *    }))
-   *  ```
-   */
-  loadDevtools?: 'auto' | boolean
-}
-
-/**
- * Enables developer tools.
- *
- * **Example**
- *
- * ```ts
- * export const appConfig: ApplicationConfig = {
- *   providers: [
- *     provideTanStackQuery(new QueryClient(), withDevtools())
- *   ]
- * }
- * ```
- * By default the devtools will be loaded when Angular runs in development mode and rendered in `<body>`.
- *
- * If you need more control over when devtools are loaded, you can use the `loadDevtools` option. This is particularly useful if you want to load devtools based on environment configurations. For instance, you might have a test environment running in production mode but still require devtools to be available.
- *
- * If you need more control over where devtools are rendered, consider `injectDevtoolsPanel`. This allows rendering devtools inside your own devtools for example.
- * @param withDevtoolsFn - A function that returns `DevtoolsOptions`.
- * @returns A set of providers for use with `provideTanStackQuery`.
- * @public
- * @see {@link provideTanStackQuery}
- * @see {@link DevtoolsOptions}
- */
-export function withDevtools(
-  withDevtoolsFn?: () => DevtoolsOptions,
-): DeveloperToolsFeature {
-  let providers: Array<Provider> = []
-  if (!isDevMode() && !withDevtoolsFn) {
-    providers = []
-  } else {
-    providers = [
-      {
-        // Do not use provideEnvironmentInitializer while Angular < v19 is supported
-        provide: ENVIRONMENT_INITIALIZER,
-        multi: true,
-        useFactory: () => {
-          if (!isPlatformBrowser(inject(PLATFORM_ID))) return noop
-          const injectedClient = inject(QueryClient, {
-            optional: true,
-          })
-          const destroyRef = inject(DestroyRef)
-
-          const options = computed(() => withDevtoolsFn?.() ?? {})
-
-          let devtools: TanstackQueryDevtools | null = null
-          let el: HTMLElement | null = null
-
-          const shouldLoadToolsSignal = computed(() => {
-            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 () =>
-            effect(() => {
-              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)
-
-                // Unmount the devtools on application destroy
-                destroyRef.onDestroy(destroyDevtools)
-              })
-            })
-        },
-      },
-    ]
-  }
-  return queryFeature('DeveloperTools', providers)
-}
-
-/**
- * A type alias that represents all Query features available for use with `provideTanStackQuery`.
- * Features can be enabled by adding special functions to the `provideTanStackQuery` call.
- * See documentation for each symbol to find corresponding function name. See also `provideTanStackQuery`
- * documentation on how to use those functions.
- * @public
- * @see {@link provideTanStackQuery}
- */
-export type QueryFeatures = DeveloperToolsFeature | PersistQueryClientFeature
-
-export const queryFeatures = ['DeveloperTools', 'PersistQueryClient'] as const
-
-export type QueryFeatureKind = (typeof queryFeatures)[number]