@tanstack/angular-query-experimental 5.34.1 → 5.35.0

package/src/types.ts

@@ -1,260 +0,0 @@
-/* istanbul ignore file */
-
-import type {
-  DefaultError,
-  DefinedInfiniteQueryObserverResult,
-  DefinedQueryObserverResult,
-  InfiniteQueryObserverOptions,
-  InfiniteQueryObserverResult,
-  MutateFunction,
-  MutationObserverOptions,
-  MutationObserverResult,
-  OmitKeyof,
-  QueryKey,
-  QueryObserverOptions,
-  QueryObserverResult,
-} from '@tanstack/query-core'
-import type { MapToSignals } from './signal-proxy'
-
-export interface CreateBaseQueryOptions<
-  TQueryFnData = unknown,
-  TError = DefaultError,
-  TData = TQueryFnData,
-  TQueryData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
-> extends QueryObserverOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryData,
-    TQueryKey
-  > {}
-
-export interface CreateQueryOptions<
-  TQueryFnData = unknown,
-  TError = DefaultError,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
-> extends OmitKeyof<
-    CreateBaseQueryOptions<
-      TQueryFnData,
-      TError,
-      TData,
-      TQueryFnData,
-      TQueryKey
-    >,
-    'suspense'
-  > {}
-
-type CreateStatusBasedQueryResult<
-  TStatus extends QueryObserverResult['status'],
-  TData = unknown,
-  TError = DefaultError,
-> = Extract<QueryObserverResult<TData, TError>, { status: TStatus }>
-
-export interface BaseQueryNarrowing<TData = unknown, TError = DefaultError> {
-  isSuccess: (
-    this: CreateBaseQueryResult<TData, TError>,
-  ) => this is CreateBaseQueryResult<
-    TData,
-    TError,
-    CreateStatusBasedQueryResult<'success', TData, TError>
-  >
-  isError: (
-    this: CreateBaseQueryResult<TData, TError>,
-  ) => this is CreateBaseQueryResult<
-    TData,
-    TError,
-    CreateStatusBasedQueryResult<'error', TData, TError>
-  >
-  isPending: (
-    this: CreateBaseQueryResult<TData, TError>,
-  ) => this is CreateBaseQueryResult<
-    TData,
-    TError,
-    CreateStatusBasedQueryResult<'pending', TData, TError>
-  >
-}
-
-export interface CreateInfiniteQueryOptions<
-  TQueryFnData = unknown,
-  TError = DefaultError,
-  TData = TQueryFnData,
-  TQueryData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
-  TPageParam = unknown,
-> extends OmitKeyof<
-    InfiniteQueryObserverOptions<
-      TQueryFnData,
-      TError,
-      TData,
-      TQueryData,
-      TQueryKey,
-      TPageParam
-    >,
-    'suspense'
-  > {}
-
-export type CreateBaseQueryResult<
-  TData = unknown,
-  TError = DefaultError,
-  TState = QueryObserverResult<TData, TError>,
-> = BaseQueryNarrowing<TData, TError> &
-  MapToSignals<OmitKeyof<TState, keyof BaseQueryNarrowing, 'safely'>>
-
-export type CreateQueryResult<
-  TData = unknown,
-  TError = DefaultError,
-> = CreateBaseQueryResult<TData, TError>
-
-export type DefinedCreateQueryResult<
-  TData = unknown,
-  TError = DefaultError,
-  TDefinedQueryObserver = DefinedQueryObserverResult<TData, TError>,
-> = MapToSignals<TDefinedQueryObserver>
-
-export type CreateInfiniteQueryResult<
-  TData = unknown,
-  TError = DefaultError,
-> = MapToSignals<InfiniteQueryObserverResult<TData, TError>>
-
-export type DefinedCreateInfiniteQueryResult<
-  TData = unknown,
-  TError = DefaultError,
-  TDefinedInfiniteQueryObserver = DefinedInfiniteQueryObserverResult<
-    TData,
-    TError
-  >,
-> = MapToSignals<TDefinedInfiniteQueryObserver>
-
-export interface CreateMutationOptions<
-  TData = unknown,
-  TError = DefaultError,
-  TVariables = void,
-  TContext = unknown,
-> extends OmitKeyof<
-    MutationObserverOptions<TData, TError, TVariables, TContext>,
-    '_defaulted'
-  > {}
-
-export type CreateMutateFunction<
-  TData = unknown,
-  TError = DefaultError,
-  TVariables = void,
-  TContext = unknown,
-> = (
-  ...args: Parameters<MutateFunction<TData, TError, TVariables, TContext>>
-) => void
-
-export type CreateMutateAsyncFunction<
-  TData = unknown,
-  TError = DefaultError,
-  TVariables = void,
-  TContext = unknown,
-> = MutateFunction<TData, TError, TVariables, TContext>
-
-export type CreateBaseMutationResult<
-  TData = unknown,
-  TError = DefaultError,
-  TVariables = unknown,
-  TContext = unknown,
-> = Override<
-  MutationObserverResult<TData, TError, TVariables, TContext>,
-  { mutate: CreateMutateFunction<TData, TError, TVariables, TContext> }
-> & {
-  mutateAsync: CreateMutateAsyncFunction<TData, TError, TVariables, TContext>
-}
-
-type CreateStatusBasedMutationResult<
-  TStatus extends CreateBaseMutationResult['status'],
-  TData = unknown,
-  TError = DefaultError,
-  TVariables = unknown,
-  TContext = unknown,
-> = Extract<
-  CreateBaseMutationResult<TData, TError, TVariables, TContext>,
-  { status: TStatus }
->
-
-export interface BaseMutationNarrowing<
-  TData = unknown,
-  TError = DefaultError,
-  TVariables = unknown,
-  TContext = unknown,
-> {
-  isSuccess: (
-    this: CreateMutationResult<TData, TError, TVariables, TContext>,
-  ) => this is CreateMutationResult<
-    TData,
-    TError,
-    TVariables,
-    TContext,
-    CreateStatusBasedMutationResult<
-      'success',
-      TData,
-      TError,
-      TVariables,
-      TContext
-    >
-  >
-  isError: (
-    this: CreateMutationResult<TData, TError, TVariables, TContext>,
-  ) => this is CreateMutationResult<
-    TData,
-    TError,
-    TVariables,
-    TContext,
-    CreateStatusBasedMutationResult<
-      'error',
-      TData,
-      TError,
-      TVariables,
-      TContext
-    >
-  >
-  isPending: (
-    this: CreateMutationResult<TData, TError, TVariables, TContext>,
-  ) => this is CreateMutationResult<
-    TData,
-    TError,
-    TVariables,
-    TContext,
-    CreateStatusBasedMutationResult<
-      'pending',
-      TData,
-      TError,
-      TVariables,
-      TContext
-    >
-  >
-  isIdle: (
-    this: CreateMutationResult<TData, TError, TVariables, TContext>,
-  ) => this is CreateMutationResult<
-    TData,
-    TError,
-    TVariables,
-    TContext,
-    CreateStatusBasedMutationResult<'idle', TData, TError, TVariables, TContext>
-  >
-}
-
-export type CreateMutationResult<
-  TData = unknown,
-  TError = DefaultError,
-  TVariables = unknown,
-  TContext = unknown,
-  TState = CreateStatusBasedMutationResult<
-    CreateBaseMutationResult['status'],
-    TData,
-    TError,
-    TVariables,
-    TContext
-  >,
-> = BaseMutationNarrowing<TData, TError, TVariables, TContext> &
-  MapToSignals<OmitKeyof<TState, keyof BaseMutationNarrowing, 'safely'>>
-
-type Override<TTargetA, TTargetB> = {
-  [AKey in keyof TTargetA]: AKey extends keyof TTargetB
-    ? TTargetB[AKey]
-    : TTargetA[AKey]
-}

package/src/util/assert-injector/assert-injector.test.ts

@@ -1,74 +0,0 @@
-/* eslint-disable @cspell/spellchecker */
-/**
- * The code in this file is adapted from NG Extension Platform at https://ngxtension.netlify.app.
- *
- * Original Author: Chau Tran
- *
- * NG Extension Platform is an open-source project licensed under the MIT license.
- *
- * For more information about the original code, see
- * https://github.com/nartc/ngxtension-platform
- */
-/* eslint-enable */
-
-import {
-  InjectionToken,
-  Injector,
-  inject,
-  runInInjectionContext,
-} from '@angular/core'
-import { TestBed } from '@angular/core/testing'
-import { assertInjector } from './assert-injector'
-
-describe(assertInjector.name, () => {
-  const token = new InjectionToken('token', {
-    factory: () => 1,
-  })
-
-  function injectDummy(injector?: Injector) {
-    injector = assertInjector(injectDummy, injector)
-    return runInInjectionContext(injector, () => inject(token))
-  }
-
-  function injectDummyTwo(injector?: Injector) {
-    return assertInjector(injectDummyTwo, injector, () => inject(token) + 1)
-  }
-
-  it('given no custom injector, when run in injection context, then return value', () => {
-    TestBed.runInInjectionContext(() => {
-      const value = injectDummy()
-      const valueTwo = injectDummyTwo()
-      expect(value).toEqual(1)
-      expect(valueTwo).toEqual(2)
-    })
-  })
-
-  it('given no custom injector, when run outside injection context, then throw', () => {
-    expect(() => injectDummy()).toThrowError(
-      /injectDummy\(\) can only be used within an injection context/i,
-    )
-    expect(() => injectDummyTwo()).toThrowError(
-      /injectDummyTwo\(\) can only be used within an injection context/i,
-    )
-  })
-
-  it('given a custom injector, when run in that injector context without providing number, then throw', () => {
-    expect(() => injectDummy(Injector.create({ providers: [] }))).toThrowError(
-      /No provider for InjectionToken/i,
-    )
-    expect(() =>
-      injectDummyTwo(Injector.create({ providers: [] })),
-    ).toThrowError(/No provider for InjectionToken/i)
-  })
-
-  it('given a custom injector, when run in that injector context and providing number, then return value', () => {
-    const value = injectDummy(
-      Injector.create({ providers: [{ provide: token, useValue: 2 }] }),
-    )
-    const valueTwo = injectDummyTwo(
-      Injector.create({ providers: [{ provide: token, useValue: 2 }] }),
-    )
-    expect(value).toEqual(2)
-    expect(valueTwo).toEqual(3)
-  })
-})

package/src/util/assert-injector/assert-injector.ts

@@ -1,81 +0,0 @@
-/* eslint-disable @cspell/spellchecker */
-/**
- * The code in this file is adapted from NG Extension Platform at https://ngxtension.netlify.app.
- *
- * Original Author: Chau Tran
- *
- * NG Extension Platform is an open-source project licensed under the MIT license.
- *
- * For more information about the original code, see
- * https://github.com/nartc/ngxtension-platform
- */
-/* eslint-enable */
-
-import {
-  Injector,
-  assertInInjectionContext,
-  inject,
-  runInInjectionContext,
-} from '@angular/core'
-
-/**
- * `assertInjector` extends `assertInInjectionContext` with an optional `Injector`
- * After assertion, `assertInjector` runs the `runner` function with the guaranteed `Injector`
- * whether it is the default `Injector` within the current **Injection Context**
- * or the custom `Injector` that was passed in.
- *
- * @template {() => any} Runner - Runner is a function that can return anything
- * @param {Function} fn - the Function to pass in `assertInInjectionContext`
- * @param {Injector | undefined | null} injector - the optional "custom" Injector
- * @param {Runner} runner - the runner fn
- * @returns {ReturnType<Runner>} result - returns the result of the Runner
- *
- * @example
- * ```ts
- * function injectValue(injector?: Injector) {
- *  return assertInjector(injectValue, injector, () => 'value');
- * }
- *
- * injectValue(); // string
- * ```
- */
-export function assertInjector<TRunner extends () => any>(
-  fn: Function,
-  injector: Injector | undefined | null,
-  runner: TRunner,
-): ReturnType<TRunner>
-/**
- * `assertInjector` extends `assertInInjectionContext` with an optional `Injector`
- * After assertion, `assertInjector` returns a guaranteed `Injector` whether it is the default `Injector`
- * within the current **Injection Context** or the custom `Injector` that was passed in.
- *
- * @param {Function} fn - the Function to pass in `assertInInjectionContext`
- * @param {Injector | undefined | null} injector - the optional "custom" Injector
- * @returns Injector
- *
- * @example
- * ```ts
- * function injectDestroy(injector?: Injector) {
- *  injector = assertInjector(injectDestroy, injector);
- *
- *  return runInInjectionContext(injector, () => {
- *    // code
- *  })
- * }
- * ```
- */
-export function assertInjector(
-  fn: Function,
-  injector: Injector | undefined | null,
-): Injector
-export function assertInjector(
-  fn: Function,
-  injector: Injector | undefined | null,
-  runner?: () => any,
-) {
-  !injector && assertInInjectionContext(fn)
-  const assertedInjector = injector ?? inject(Injector)
-
-  if (!runner) return assertedInjector
-  return runInInjectionContext(assertedInjector, runner)
-}

package/src/util/create-injection-token/create-injection-token.test.ts

@@ -1,32 +0,0 @@
-/* eslint-disable @cspell/spellchecker */
-/**
- * The code in this file is adapted from NG Extension Platform at https://ngxtension.netlify.app.
- *
- * Original Author: Chau Tran
- *
- * NG Extension Platform is an open-source project licensed under the MIT license.
- *
- * For more information about the original code, see
- * https://github.com/nartc/ngxtension-platform
- */
-/* eslint-enable */
-
-import { TestBed } from '@angular/core/testing'
-import { createNoopInjectionToken } from './create-injection-token'
-
-describe(createNoopInjectionToken.name, () => {
-  describe('given an injection token', () => {
-    const [injectFn, provideFn] = createNoopInjectionToken<number, true>(
-      'noop',
-      { multi: true },
-    )
-    it('then work properly', () => {
-      TestBed.configureTestingModule({
-        providers: [provideFn(1), provideFn(() => 2)],
-      }).runInInjectionContext(() => {
-        const values = injectFn()
-        expect(values).toEqual([1, 2])
-      })
-    })
-  })
-})

package/src/util/create-injection-token/create-injection-token.ts

@@ -1,185 +0,0 @@
-/* eslint-disable @cspell/spellchecker */
-/**
- * The code in this file is adapted from NG Extension Platform at https://ngxtension.netlify.app.
- *
- * Original Author: Chau Tran
- *
- * NG Extension Platform is an open-source project licensed under the MIT license.
- *
- * For more information about the original code, see
- * https://github.com/nartc/ngxtension-platform
- */
-/* eslint-enable */
-
-import {
-  type EnvironmentProviders,
-  type FactoryProvider,
-  type Host,
-  type InjectOptions,
-  InjectionToken,
-  type Injector,
-  type Optional,
-  type Provider,
-  type Self,
-  type SkipSelf,
-  type Type,
-  inject,
-  runInInjectionContext,
-} from '@angular/core'
-import { assertInjector } from '../assert-injector/assert-injector'
-
-type CreateInjectionTokenDep<TTokenType> =
-  | Type<TTokenType>
-  // NOTE: we don't have an AbstractType
-  | (abstract new (...args: Array<any>) => TTokenType)
-  | InjectionToken<TTokenType>
-
-type CreateInjectionTokenDeps<
-  TFactory extends (...args: Array<any>) => any,
-  TFactoryDeps extends Parameters<TFactory> = Parameters<TFactory>,
-> = {
-  [Index in keyof TFactoryDeps]:
-    | CreateInjectionTokenDep<TFactoryDeps[Index]>
-    | [
-        ...modifiers: Array<Optional | Self | SkipSelf | Host>,
-        token: CreateInjectionTokenDep<TFactoryDeps[Index]>,
-      ]
-} & { length: TFactoryDeps['length'] }
-
-type CreateInjectionTokenOptions<
-  TFactory extends (...args: Array<any>) => any,
-  TFactoryDeps extends Parameters<TFactory> = Parameters<TFactory>,
-> =
-  // this means TFunction has no parameters
-  (TFactoryDeps[0] extends undefined
-    ? { deps?: never }
-    : { deps: CreateInjectionTokenDeps<TFactory, TFactoryDeps> }) & {
-    isRoot?: boolean
-    multi?: boolean
-    token?: InjectionToken<ReturnType<TFactory>>
-    extraProviders?: Provider | EnvironmentProviders
-  }
-
-type CreateProvideFnOptions<
-  TFactory extends (...args: Array<any>) => any,
-  TFactoryDeps extends Parameters<TFactory> = Parameters<TFactory>,
-> = Pick<
-  CreateInjectionTokenOptions<TFactory, TFactoryDeps>,
-  'deps' | 'extraProviders' | 'multi'
->
-
-type InjectFn<TFactoryReturn> = {
-  (): TFactoryReturn
-  (
-    injectOptions: InjectOptions & { optional?: false } & {
-      injector?: Injector
-    },
-  ): TFactoryReturn
-  (
-    injectOptions: InjectOptions & { injector?: Injector },
-  ): TFactoryReturn | null
-}
-
-type ProvideFn<
-  TNoop extends boolean,
-  TFactoryReturn,
-  TReturn = TFactoryReturn extends Array<infer Item> ? Item : TFactoryReturn,
-> = (TNoop extends true
-  ? (value: TReturn | (() => TReturn)) => Provider
-  : () => Provider) &
-  (TReturn extends Function
-    ? (value: TReturn | (() => TReturn), isFunctionValue: boolean) => Provider
-    : (value: TReturn | (() => TReturn)) => Provider)
-
-type CreateInjectionTokenReturn<
-  TFactoryReturn,
-  TNoop extends boolean = false,
-> = [
-  InjectFn<TFactoryReturn>,
-  ProvideFn<TNoop, TFactoryReturn>,
-  InjectionToken<TFactoryReturn>,
-  () => Provider,
-]
-
-function createInjectFn<TValue>(token: InjectionToken<TValue>) {
-  return function (
-    this: Function,
-    {
-      injector,
-      ...injectOptions
-    }: InjectOptions & { injector?: Injector } = {},
-  ) {
-    injector = assertInjector(this, injector)
-    return runInInjectionContext(injector, () =>
-      inject(token, injectOptions as InjectOptions),
-    )
-  }
-}
-
-function createProvideFn<
-  TValue,
-  TFactory extends (...args: Array<any>) => any = (
-    ...args: Array<any>
-  ) => TValue,
-  TFactoryDeps extends Parameters<TFactory> = Parameters<TFactory>,
->(
-  token: InjectionToken<TValue>,
-  factory: (...args: Array<any>) => TValue,
-  opts: CreateProvideFnOptions<TFactory, TFactoryDeps> = {},
-) {
-  const { deps = [], multi = false, extraProviders = [] } = opts
-  return (value?: TValue | (() => TValue), isFunctionValue = false) => {
-    let provider: Provider
-    if (value !== undefined) {
-      // eslint-disable-next-line no-shadow
-      const factory =
-        typeof value === 'function'
-          ? isFunctionValue
-            ? () => value
-            : value
-          : () => value
-
-      provider = {
-        provide: token,
-        useFactory: factory,
-        multi,
-      }
-    } else {
-      provider = {
-        provide: token,
-        useFactory: factory,
-        deps: deps as FactoryProvider['deps'],
-        multi,
-      }
-    }
-
-    return [extraProviders, provider]
-  }
-}
-
-export function createNoopInjectionToken<
-  TValue,
-  TMulti extends boolean = false,
-  TOptions = Pick<
-    CreateInjectionTokenOptions<() => void, []>,
-    'extraProviders'
-  > &
-    (TMulti extends true ? { multi: true } : Record<string, never>),
->(description: string, options?: TOptions) {
-  type TReturn = TMulti extends true ? Array<TValue> : TValue
-
-  const token =
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    (options as CreateInjectionTokenOptions<() => void, []>)?.token ||
-    new InjectionToken<TReturn>(description)
-  return [
-    createInjectFn(token) as CreateInjectionTokenReturn<TReturn, true>[0],
-    createProvideFn(
-      token,
-      () => null!,
-      (options || {}) as CreateProvideFnOptions<() => void, []>,
-    ) as CreateInjectionTokenReturn<TReturn, true>[1],
-    token,
-    () => {},
-  ] as CreateInjectionTokenReturn<TReturn, true>
-}

package/src/util/index.ts

@@ -1,13 +0,0 @@
-export function shouldThrowError<T extends (...args: Array<any>) => boolean>(
-  throwError: boolean | T | undefined,
-  params: Parameters<T>,
-): boolean {
-  // Allow throwError function to override throwing behavior on a per-error basis
-  if (typeof throwError === 'function') {
-    return throwError(...params)
-  }
-
-  return !!throwError
-}
-
-export function noop() {}

package/src/util/lazy-init/lazy-init.ts

@@ -1,34 +0,0 @@
-import { untracked } from '@angular/core'
-
-export function lazyInit<T extends object>(initializer: () => T): T {
-  let object: T | null = null
-
-  const initializeObject = () => {
-    if (!object) {
-      object = untracked(() => initializer())
-    }
-  }
-
-  queueMicrotask(() => initializeObject())
-
-  return new Proxy<T>({} as T, {
-    get(_, prop, receiver) {
-      initializeObject()
-      return Reflect.get(object as T, prop, receiver)
-    },
-    has(_, prop) {
-      initializeObject()
-      return Reflect.has(object as T, prop)
-    },
-    ownKeys() {
-      initializeObject()
-      return Reflect.ownKeys(object as T)
-    },
-    getOwnPropertyDescriptor() {
-      return {
-        enumerable: true,
-        configurable: true,
-      }
-    },
-  })
-}

package/src/util/lazy-signal-initializer/lazy-signal-initializer.ts

@@ -1,28 +0,0 @@
-import {
-  Injector,
-  type Signal,
-  computed,
-  inject,
-  untracked,
-} from '@angular/core'
-
-type SignalInitializerFn<T> = (injector: Injector) => Signal<T>
-
-export function lazySignalInitializer<T>(
-  initializerFn: SignalInitializerFn<T>,
-) {
-  const injector = inject(Injector)
-
-  let source: Signal<T> | null = null
-
-  const unwrapSignal = () => {
-    if (!source) {
-      source = untracked(() => initializerFn(injector))
-    }
-    return source()
-  }
-
-  queueMicrotask(() => unwrapSignal())
-
-  return computed(unwrapSignal)
-}