@tanstack/angular-query-experimental 5.34.2 → 5.35.1

package/build/util/create-injection-token/create-injection-token.d.ts

@@ -1,52 +0,0 @@
-/**
- * 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
- */
-import { type EnvironmentProviders, type Host, type InjectOptions, InjectionToken, type Injector, type Optional, type Provider, type Self, type SkipSelf, type Type } from '@angular/core';
-type CreateInjectionTokenDep<TTokenType> = Type<TTokenType> | (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>> = (TFactoryDeps[0] extends undefined ? {
-    deps?: never;
-} : {
-    deps: CreateInjectionTokenDeps<TFactory, TFactoryDeps>;
-}) & {
-    isRoot?: boolean;
-    multi?: boolean;
-    token?: InjectionToken<ReturnType<TFactory>>;
-    extraProviders?: Provider | EnvironmentProviders;
-};
-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
-];
-export declare function createNoopInjectionToken<TValue, TMulti extends boolean = false, TOptions = Pick<CreateInjectionTokenOptions<() => void, []>, 'extraProviders'> & (TMulti extends true ? {
-    multi: true;
-} : Record<string, never>)>(description: string, options?: TOptions): CreateInjectionTokenReturn<TMulti extends true ? TValue[] : TValue, true>;
-export {};

package/build/util/index.d.ts

@@ -1,2 +0,0 @@
-export declare function shouldThrowError<T extends (...args: Array<any>) => boolean>(throwError: boolean | T | undefined, params: Parameters<T>): boolean;
-export declare function noop(): void;

package/build/util/lazy-init/lazy-init.d.ts

@@ -1 +0,0 @@
-export declare function lazyInit<T extends object>(initializer: () => T): T;

package/build/util/lazy-signal-initializer/lazy-signal-initializer.d.ts

@@ -1,4 +0,0 @@
-import { Injector, type Signal } from '@angular/core';
-type SignalInitializerFn<T> = (injector: Injector) => Signal<T>;
-export declare function lazySignalInitializer<T>(initializerFn: SignalInitializerFn<T>): Signal<T>;
-export {};

package/src/__tests__/inject-infinite-query.test.ts

@@ -1,64 +0,0 @@
-import { TestBed } from '@angular/core/testing'
-import { QueryClient } from '@tanstack/query-core'
-import { afterEach } from 'vitest'
-import { injectInfiniteQuery } from '../inject-infinite-query'
-import { provideAngularQuery } from '../providers'
-import { expectSignals, infiniteFetcher } from './test-utils'
-
-const QUERY_DURATION = 1000
-
-const resolveQueries = () => vi.advanceTimersByTimeAsync(QUERY_DURATION)
-
-describe('injectInfiniteQuery', () => {
-  let queryClient: QueryClient
-
-  beforeEach(() => {
-    queryClient = new QueryClient()
-    vi.useFakeTimers()
-    TestBed.configureTestingModule({
-      providers: [provideAngularQuery(queryClient)],
-    })
-  })
-
-  afterEach(() => {
-    vi.useRealTimers()
-  })
-
-  test('should properly execute infinite query', async () => {
-    const query = TestBed.runInInjectionContext(() => {
-      return injectInfiniteQuery(() => ({
-        queryKey: ['infiniteQuery'],
-        queryFn: infiniteFetcher,
-        initialPageParam: 0,
-        getNextPageParam: () => 12,
-      }))
-    })
-
-    expectSignals(query, {
-      data: undefined,
-      status: 'pending',
-    })
-
-    await resolveQueries()
-
-    expectSignals(query, {
-      data: {
-        pageParams: [0],
-        pages: ['data on page 0'],
-      },
-      status: 'success',
-    })
-
-    void query.fetchNextPage()
-
-    await resolveQueries()
-
-    expectSignals(query, {
-      data: {
-        pageParams: [0, 12],
-        pages: ['data on page 0', 'data on page 12'],
-      },
-      status: 'success',
-    })
-  })
-})

package/src/__tests__/inject-is-fetching.test.ts

@@ -1,35 +0,0 @@
-import { TestBed, fakeAsync, flush, tick } from '@angular/core/testing'
-import { QueryClient } from '@tanstack/query-core'
-import { beforeEach, describe, expect } from 'vitest'
-import { injectIsFetching } from '../inject-is-fetching'
-import { injectQuery } from '../inject-query'
-import { provideAngularQuery } from '../providers'
-import { delayedFetcher } from './test-utils'
-
-describe('injectIsFetching', () => {
-  let queryClient: QueryClient
-
-  beforeEach(() => {
-    queryClient = new QueryClient()
-
-    TestBed.configureTestingModule({
-      providers: [provideAngularQuery(queryClient)],
-    })
-  })
-
-  test('Returns number of fetching queries', fakeAsync(() => {
-    const isFetching = TestBed.runInInjectionContext(() => {
-      injectQuery(() => ({
-        queryKey: ['isFetching1'],
-        queryFn: delayedFetcher(100),
-      }))
-      return injectIsFetching()
-    })
-
-    tick()
-
-    expect(isFetching()).toStrictEqual(1)
-    flush()
-    expect(isFetching()).toStrictEqual(0)
-  }))
-})

package/src/__tests__/inject-is-mutating.test.ts

@@ -1,39 +0,0 @@
-import { QueryClient } from '@tanstack/query-core'
-import { beforeEach, describe } from 'vitest'
-import { TestBed, fakeAsync, tick } from '@angular/core/testing'
-import { injectIsMutating } from '../inject-is-mutating'
-import { injectMutation } from '../inject-mutation'
-import { provideAngularQuery } from '../providers'
-import { successMutator } from './test-utils'
-
-describe('injectIsMutating', () => {
-  let queryClient: QueryClient
-
-  beforeEach(() => {
-    queryClient = new QueryClient()
-
-    TestBed.configureTestingModule({
-      providers: [provideAngularQuery(queryClient)],
-    })
-  })
-
-  test('should properly return isMutating state', fakeAsync(() => {
-    TestBed.runInInjectionContext(() => {
-      const isMutating = injectIsMutating()
-      const mutation = injectMutation(() => ({
-        mutationKey: ['isMutating1'],
-        mutationFn: successMutator<{ par1: string }>,
-      }))
-
-      expect(isMutating()).toBe(0)
-
-      mutation.mutate({
-        par1: 'par1',
-      })
-
-      tick()
-
-      expect(isMutating()).toBe(1)
-    })
-  }))
-})

package/src/__tests__/inject-mutation-state.test-d.ts

@@ -1,22 +0,0 @@
-import { describe, expectTypeOf } from 'vitest'
-import { injectMutationState } from '../inject-mutation-state'
-import type { MutationState, MutationStatus } from '@tanstack/query-core'
-
-describe('injectMutationState', () => {
-  it('should default to QueryState', () => {
-    const result = injectMutationState(() => ({
-      filters: { status: 'pending' },
-    }))
-
-    expectTypeOf(result()).toEqualTypeOf<Array<MutationState>>()
-  })
-
-  it('should infer with select', () => {
-    const result = injectMutationState(() => ({
-      filters: { status: 'pending' },
-      select: (mutation) => mutation.state.status,
-    }))
-
-    expectTypeOf(result()).toEqualTypeOf<Array<MutationStatus>>()
-  })
-})

package/src/__tests__/inject-mutation-state.test.ts

@@ -1,175 +0,0 @@
-import { Component, input, signal } from '@angular/core'
-import { QueryClient } from '@tanstack/query-core'
-import { TestBed } from '@angular/core/testing'
-import { describe, expect, test, vi } from 'vitest'
-import { By } from '@angular/platform-browser'
-import { injectMutation } from '../inject-mutation'
-import { injectMutationState } from '../inject-mutation-state'
-import { provideAngularQuery } from '../providers'
-import { setFixtureSignalInputs, successMutator } from './test-utils'
-
-const MUTATION_DURATION = 1000
-
-const resolveMutations = () => vi.advanceTimersByTimeAsync(MUTATION_DURATION)
-
-describe('injectMutationState', () => {
-  let queryClient: QueryClient
-
-  beforeEach(() => {
-    queryClient = new QueryClient()
-    vi.useFakeTimers()
-    TestBed.configureTestingModule({
-      providers: [provideAngularQuery(queryClient)],
-    })
-  })
-
-  afterEach(() => {
-    vi.useRealTimers()
-  })
-
-  describe('injectMutationState', () => {
-    test('should return variables after calling mutate', async () => {
-      const mutationKey = ['mutation']
-      const variables = 'foo123'
-
-      const mutation = TestBed.runInInjectionContext(() => {
-        return injectMutation(() => ({
-          mutationKey: mutationKey,
-          mutationFn: (params: string) => successMutator(params),
-        }))
-      })
-
-      mutation.mutate(variables)
-
-      const mutationState = TestBed.runInInjectionContext(() => {
-        return injectMutationState(() => ({
-          filters: { mutationKey, status: 'pending' },
-          select: (m) => m.state.variables,
-        }))
-      })
-
-      expect(mutationState()).toEqual([variables])
-    })
-
-    test('reactive options should update injectMutationState', async () => {
-      const mutationKey1 = ['mutation1']
-      const mutationKey2 = ['mutation2']
-      const variables1 = 'foo123'
-      const variables2 = 'bar234'
-
-      const [mutation1, mutation2] = TestBed.runInInjectionContext(() => {
-        return [
-          injectMutation(() => ({
-            mutationKey: mutationKey1,
-            mutationFn: (params: string) => successMutator(params),
-          })),
-          injectMutation(() => ({
-            mutationKey: mutationKey2,
-            mutationFn: (params: string) => successMutator(params),
-          })),
-        ]
-      })
-
-      mutation1.mutate(variables1)
-      mutation2.mutate(variables2)
-
-      const filterKey = signal(mutationKey1)
-
-      const mutationState = TestBed.runInInjectionContext(() => {
-        return injectMutationState(() => ({
-          filters: { mutationKey: filterKey(), status: 'pending' },
-          select: (m) => m.state.variables,
-        }))
-      })
-
-      expect(mutationState()).toEqual([variables1])
-
-      filterKey.set(mutationKey2)
-      TestBed.flushEffects()
-      expect(mutationState()).toEqual([variables2])
-    })
-
-    test('should return variables after calling mutate', async () => {
-      queryClient.clear()
-      const mutationKey = ['mutation']
-      const variables = 'bar234'
-
-      const mutation = TestBed.runInInjectionContext(() => {
-        return injectMutation(() => ({
-          mutationKey: mutationKey,
-          mutationFn: (params: string) => successMutator(params),
-        }))
-      })
-
-      mutation.mutate(variables)
-
-      const mutationState = TestBed.runInInjectionContext(() => {
-        return injectMutationState()
-      })
-
-      expect(mutationState()[0]?.variables).toEqual(variables)
-    })
-
-    test('should support required signal inputs', async () => {
-      queryClient.clear()
-      const fakeName = 'name1'
-      const mutationKey1 = ['fake', fakeName]
-
-      const mutations = TestBed.runInInjectionContext(() => {
-        return [
-          injectMutation(() => ({
-            mutationKey: mutationKey1,
-            mutationFn: () => Promise.resolve('myValue'),
-          })),
-          injectMutation(() => ({
-            mutationKey: mutationKey1,
-            mutationFn: () => Promise.reject('myValue2'),
-          })),
-        ]
-      })
-
-      mutations.forEach((mutation) => mutation.mutate())
-
-      @Component({
-        selector: 'app-fake',
-        template: `
-          @for (mutation of mutationState(); track mutation) {
-            <span>{{ mutation.status }}</span>
-          }
-        `,
-        standalone: true,
-      })
-      class FakeComponent {
-        name = input.required<string>()
-
-        mutationState = injectMutationState(() => ({
-          filters: {
-            mutationKey: ['fake', this.name()],
-            exact: true,
-          },
-        }))
-      }
-
-      const fixture = TestBed.createComponent(FakeComponent)
-      const { debugElement } = fixture
-      setFixtureSignalInputs(fixture, { name: fakeName })
-
-      fixture.detectChanges()
-
-      let spans = debugElement
-        .queryAll(By.css('span'))
-        .map((span) => span.nativeNode.textContent)
-
-      expect(spans).toEqual(['pending', 'pending'])
-
-      await resolveMutations()
-      fixture.detectChanges()
-
-      spans = debugElement
-        .queryAll(By.css('span'))
-        .map((span) => span.nativeNode.textContent)
-
-      expect(spans).toEqual(['success', 'error'])
-    })
-  })
-})

package/src/__tests__/inject-mutation.test-d.ts

@@ -1,71 +0,0 @@
-import { describe, expectTypeOf } from 'vitest'
-import { injectMutation } from '../inject-mutation'
-import { successMutator } from './test-utils'
-import type { Signal } from '@angular/core'
-
-describe('Discriminated union return type', () => {
-  test('data should be possibly undefined by default', () => {
-    const mutation = injectMutation(() => ({
-      mutationFn: successMutator<string>,
-    }))
-
-    expectTypeOf(mutation.data).toEqualTypeOf<Signal<string | undefined>>()
-  })
-
-  test('data should be defined when mutation is success', () => {
-    const mutation = injectMutation(() => ({
-      mutationFn: successMutator<string>,
-    }))
-
-    if (mutation.isSuccess()) {
-      expectTypeOf(mutation.data).toEqualTypeOf<Signal<string>>()
-    }
-  })
-
-  test('error should be null when mutation is success', () => {
-    const mutation = injectMutation(() => ({
-      mutationFn: successMutator<string>,
-    }))
-
-    if (mutation.isSuccess()) {
-      expectTypeOf(mutation.error).toEqualTypeOf<Signal<null>>()
-    }
-  })
-
-  test('data should be undefined when mutation is pending', () => {
-    const mutation = injectMutation(() => ({
-      mutationFn: successMutator<string>,
-    }))
-
-    if (mutation.isPending()) {
-      expectTypeOf(mutation.data).toEqualTypeOf<Signal<undefined>>()
-    }
-  })
-
-  test('error should be defined when mutation is error', () => {
-    const mutation = injectMutation(() => ({
-      mutationFn: successMutator<string>,
-    }))
-
-    if (mutation.isError()) {
-      expectTypeOf(mutation.error).toEqualTypeOf<Signal<Error>>()
-    }
-  })
-
-  test('should narrow variables', () => {
-    const mutation = injectMutation(() => ({
-      mutationFn: successMutator<string>,
-    }))
-
-    if (mutation.isIdle()) {
-      expectTypeOf(mutation.variables).toEqualTypeOf<Signal<undefined>>()
-    }
-    if (mutation.isPending()) {
-      expectTypeOf(mutation.variables).toEqualTypeOf<Signal<string>>()
-    }
-    if (mutation.isSuccess()) {
-      expectTypeOf(mutation.variables).toEqualTypeOf<Signal<string>>()
-    }
-    expectTypeOf(mutation.variables).toEqualTypeOf<Signal<string | undefined>>()
-  })
-})