@tanstack/angular-query-experimental 5.84.0 → 5.84.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/angular-query-experimental",
-  "version": "5.84.0",
+  "version": "5.84.1",
   "description": "Signals for managing, caching and syncing asynchronous and remote data in Angular",
   "author": "Arnoud de Vries",
   "license": "MIT",
@@ -27,59 +27,23 @@
     "tanstack"
   ],
   "type": "module",
-  "types": "dist/index.d.ts",
-  "module": "dist/index.mjs",
+  "types": "./index.d.ts",
+  "module": "./index.mjs",
   "exports": {
     ".": {
       "@tanstack/custom-condition": "./src/index.ts",
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.mjs"
+      "types": "./index.d.ts",
+      "default": "./index.mjs"
     },
     "./package.json": "./package.json"
   },
   "sideEffects": false,
-  "files": [
-    "dist",
-    "src",
-    "!src/__tests__"
-  ],
   "dependencies": {
-    "@tanstack/query-core": "5.83.1",
-    "@tanstack/query-devtools": "5.84.0"
-  },
-  "devDependencies": {
-    "@angular/common": "^20.0.0",
-    "@angular/compiler": "^20.0.0",
-    "@angular/core": "^20.0.0",
-    "@angular/platform-browser": "^20.0.0",
-    "eslint-plugin-jsdoc": "^50.5.0",
-    "npm-run-all2": "^5.0.0",
-    "vite-plugin-dts": "4.2.3",
-    "vite-plugin-externalize-deps": "^0.9.0",
-    "vite-tsconfig-paths": "^5.1.4",
-    "@tanstack/query-test-utils": "0.0.0"
+    "@tanstack/query-devtools": "5.84.0",
+    "@tanstack/query-core": "5.83.1"
   },
   "peerDependencies": {
     "@angular/common": ">=16.0.0",
     "@angular/core": ">=16.0.0"
-  },
-  "scripts": {
-    "clean": "premove ./build ./dist ./coverage ./dist-ts",
-    "compile": "tsc --build",
-    "test:eslint": "eslint ./src",
-    "test:types": "npm-run-all --serial test:types:*",
-    "test:types:ts50": "node ../../node_modules/typescript50/lib/tsc.js --build",
-    "test:types:ts51": "node ../../node_modules/typescript51/lib/tsc.js --build",
-    "test:types:ts52": "node ../../node_modules/typescript52/lib/tsc.js --build",
-    "test:types:ts53": "node ../../node_modules/typescript53/lib/tsc.js --build",
-    "test:types:ts54": "node ../../node_modules/typescript54/lib/tsc.js --build",
-    "test:types:ts55": "node ../../node_modules/typescript55/lib/tsc.js --build",
-    "test:types:ts56": "node ../../node_modules/typescript56/lib/tsc.js --build",
-    "test:types:ts57": "node ../../node_modules/typescript57/lib/tsc.js --build",
-    "test:types:tscurrent": "tsc --build",
-    "test:lib": "vitest",
-    "test:lib:dev": "pnpm run test:lib --watch",
-    "test:build": "pnpm pack && publint ./dist/*.tgz --strict && attw ./dist/*.tgz; premove ./dist/*.tgz",
-    "build": "vite build"
   }
 }

package/src/create-base-query.ts

@@ -1,142 +0,0 @@
-import {
-  NgZone,
-  VERSION,
-  computed,
-  effect,
-  inject,
-  signal,
-  untracked,
-} from '@angular/core'
-import {
-  QueryClient,
-  notifyManager,
-  shouldThrowError,
-} from '@tanstack/query-core'
-import { signalProxy } from './signal-proxy'
-import { injectIsRestoring } from './inject-is-restoring'
-import type {
-  QueryKey,
-  QueryObserver,
-  QueryObserverResult,
-} from '@tanstack/query-core'
-import type { CreateBaseQueryOptions } from './types'
-
-/**
- * Base implementation for `injectQuery` and `injectInfiniteQuery`.
- * @param optionsFn
- * @param Observer
- */
-export function createBaseQuery<
-  TQueryFnData,
-  TError,
-  TData,
-  TQueryData,
-  TQueryKey extends QueryKey,
->(
-  optionsFn: () => CreateBaseQueryOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryData,
-    TQueryKey
-  >,
-  Observer: typeof QueryObserver,
-) {
-  const ngZone = inject(NgZone)
-  const queryClient = inject(QueryClient)
-  const isRestoring = injectIsRestoring()
-
-  /**
-   * Signal that has the default options from query client applied
-   * 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 defaultedOptionsSignal = computed(() => {
-    const defaultedOptions = queryClient.defaultQueryOptions(optionsFn())
-    defaultedOptions._optimisticResults = isRestoring()
-      ? 'isRestoring'
-      : 'optimistic'
-    return defaultedOptions
-  })
-
-  const observerSignal = (() => {
-    let instance: QueryObserver<
-      TQueryFnData,
-      TError,
-      TData,
-      TQueryData,
-      TQueryKey
-    > | null = null
-
-    return computed(() => {
-      return (instance ||= new Observer(queryClient, defaultedOptionsSignal()))
-    })
-  })()
-
-  const optimisticResultSignal = computed(() =>
-    observerSignal().getOptimisticResult(defaultedOptionsSignal()),
-  )
-
-  const resultFromSubscriberSignal = signal<QueryObserverResult<
-    TData,
-    TError
-  > | null>(null)
-
-  effect(
-    (onCleanup) => {
-      const observer = observerSignal()
-      const defaultedOptions = defaultedOptionsSignal()
-
-      untracked(() => {
-        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' || undefined,
-    },
-  )
-
-  effect((onCleanup) => {
-    // observer.trackResult is not used as this optimization is not needed for Angular
-    const observer = observerSignal()
-    const unsubscribe = isRestoring()
-      ? () => undefined
-      : untracked(() =>
-          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(
-    computed(() => {
-      const subscriberResult = resultFromSubscriberSignal()
-      const optimisticResult = optimisticResultSignal()
-      return subscriberResult ?? optimisticResult
-    }),
-  )
-}

package/src/index.ts

@@ -1,64 +0,0 @@
-/* istanbul ignore file */
-
-// Re-export core
-export * from '@tanstack/query-core'
-
-export * from './types'
-
-export type {
-  DefinedInitialDataOptions,
-  UndefinedInitialDataOptions,
-  UnusedSkipTokenOptions,
-} from './query-options'
-export { queryOptions } from './query-options'
-
-export type { CreateMutationOptions } from './mutation-options'
-export { mutationOptions } from './mutation-options'
-
-export type {
-  DefinedInitialDataInfiniteOptions,
-  UndefinedInitialDataInfiniteOptions,
-  UnusedSkipTokenInfiniteOptions,
-} from './infinite-query-options'
-export { infiniteQueryOptions } from './infinite-query-options'
-
-export type { InjectInfiniteQueryOptions } from './inject-infinite-query'
-export { injectInfiniteQuery } from './inject-infinite-query'
-
-export type { InjectIsFetchingOptions } from './inject-is-fetching'
-export { injectIsFetching } from './inject-is-fetching'
-
-export type { InjectIsMutatingOptions } from './inject-is-mutating'
-export { injectIsMutating } from './inject-is-mutating'
-
-export { injectIsRestoring, provideIsRestoring } from './inject-is-restoring'
-
-export type { InjectMutationOptions } from './inject-mutation'
-export { injectMutation } from './inject-mutation'
-
-export type { InjectMutationStateOptions } from './inject-mutation-state'
-export { injectMutationState } from './inject-mutation-state'
-
-export type { QueriesOptions, QueriesResults } from './inject-queries'
-export { injectQueries } from './inject-queries'
-
-export type { InjectQueryOptions } from './inject-query'
-export { injectQuery } from './inject-query'
-
-export { injectQueryClient } from './inject-query-client'
-
-export type {
-  DeveloperToolsFeature,
-  DevtoolsOptions,
-  PersistQueryClientFeature,
-  QueryFeature,
-  QueryFeatureKind,
-  QueryFeatures,
-} from './providers'
-export {
-  provideQueryClient,
-  provideTanStackQuery,
-  queryFeature,
-  queryFeatures,
-  withDevtools,
-} from './providers'

package/src/infinite-query-options.ts

@@ -1,187 +0,0 @@
-import type {
-  DataTag,
-  DefaultError,
-  InfiniteData,
-  InitialDataFunction,
-  NonUndefinedGuard,
-  OmitKeyof,
-  QueryKey,
-  SkipToken,
-} from '@tanstack/query-core'
-import type { CreateInfiniteQueryOptions } from './types'
-
-export type UndefinedInitialDataInfiniteOptions<
-  TQueryFnData,
-  TError = DefaultError,
-  TData = InfiniteData<TQueryFnData>,
-  TQueryKey extends QueryKey = QueryKey,
-  TPageParam = unknown,
-> = CreateInfiniteQueryOptions<
-  TQueryFnData,
-  TError,
-  TData,
-  TQueryKey,
-  TPageParam
-> & {
-  initialData?:
-    | undefined
-    | NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>
-    | InitialDataFunction<
-        NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>
-      >
-}
-
-export type UnusedSkipTokenInfiniteOptions<
-  TQueryFnData,
-  TError = DefaultError,
-  TData = InfiniteData<TQueryFnData>,
-  TQueryKey extends QueryKey = QueryKey,
-  TPageParam = unknown,
-> = OmitKeyof<
-  CreateInfiniteQueryOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryKey,
-    TPageParam
-  >,
-  'queryFn'
-> & {
-  queryFn?: Exclude<
-    CreateInfiniteQueryOptions<
-      TQueryFnData,
-      TError,
-      TData,
-      TQueryKey,
-      TPageParam
-    >['queryFn'],
-    SkipToken | undefined
-  >
-}
-
-export type DefinedInitialDataInfiniteOptions<
-  TQueryFnData,
-  TError = DefaultError,
-  TData = InfiniteData<TQueryFnData>,
-  TQueryKey extends QueryKey = QueryKey,
-  TPageParam = unknown,
-> = CreateInfiniteQueryOptions<
-  TQueryFnData,
-  TError,
-  TData,
-  TQueryKey,
-  TPageParam
-> & {
-  initialData:
-    | NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>
-    | (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>)
-    | undefined
-}
-
-/**
- * Allows to share and re-use infinite query options in a type-safe way.
- *
- * The `queryKey` will be tagged with the type from `queryFn`.
- * @param options - The infinite query options to tag with the type from `queryFn`.
- * @returns The tagged infinite query options.
- * @public
- */
-export function infiniteQueryOptions<
-  TQueryFnData,
-  TError = DefaultError,
-  TData = InfiniteData<TQueryFnData>,
-  TQueryKey extends QueryKey = QueryKey,
-  TPageParam = unknown,
->(
-  options: DefinedInitialDataInfiniteOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryKey,
-    TPageParam
-  >,
-): DefinedInitialDataInfiniteOptions<
-  TQueryFnData,
-  TError,
-  TData,
-  TQueryKey,
-  TPageParam
-> & {
-  queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>
-}
-
-/**
- * Allows to share and re-use infinite query options in a type-safe way.
- *
- * The `queryKey` will be tagged with the type from `queryFn`.
- * @param options - The infinite query options to tag with the type from `queryFn`.
- * @returns The tagged infinite query options.
- * @public
- */
-export function infiniteQueryOptions<
-  TQueryFnData,
-  TError = DefaultError,
-  TData = InfiniteData<TQueryFnData>,
-  TQueryKey extends QueryKey = QueryKey,
-  TPageParam = unknown,
->(
-  options: UnusedSkipTokenInfiniteOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryKey,
-    TPageParam
-  >,
-): UnusedSkipTokenInfiniteOptions<
-  TQueryFnData,
-  TError,
-  TData,
-  TQueryKey,
-  TPageParam
-> & {
-  queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>
-}
-
-/**
- * Allows to share and re-use infinite query options in a type-safe way.
- *
- * The `queryKey` will be tagged with the type from `queryFn`.
- * @param options - The infinite query options to tag with the type from `queryFn`.
- * @returns The tagged infinite query options.
- * @public
- */
-export function infiniteQueryOptions<
-  TQueryFnData,
-  TError = DefaultError,
-  TData = InfiniteData<TQueryFnData>,
-  TQueryKey extends QueryKey = QueryKey,
-  TPageParam = unknown,
->(
-  options: UndefinedInitialDataInfiniteOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryKey,
-    TPageParam
-  >,
-): UndefinedInitialDataInfiniteOptions<
-  TQueryFnData,
-  TError,
-  TData,
-  TQueryKey,
-  TPageParam
-> & {
-  queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>
-}
-
-/**
- * Allows to share and re-use infinite query options in a type-safe way.
- *
- * The `queryKey` will be tagged with the type from `queryFn`.
- * @param options - The infinite query options to tag with the type from `queryFn`.
- * @returns The tagged infinite query options.
- * @public
- */
-export function infiniteQueryOptions(options: unknown) {
-  return options
-}

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