From 49211a6a9de0ce1f92a69683c694f5c9df6f524e Mon Sep 17 00:00:00 2001 From: Zelys Date: Wed, 1 Apr 2026 12:07:01 -0500 Subject: [PATCH 1/3] fix(types): propagate generic type params to useMutationState select callback When TResult is a typed MutationState, the select callback parameter now receives the correctly typed Mutation instead of the base Mutation type. Adds a second type param TMutation (defaulting to MutationTypeFromResult) to MutationStateOptions across all five framework adapters. Uses a non-distributive conditional type to avoid union expansion when TResult is unresolved. Fixes #9825 --- .changeset/fix-mutation-state-generics.md | 9 +++++ .../src/__tests__/useMutationState.test-d.tsx | 17 ++++++++- packages/preact-query/src/useMutationState.ts | 33 +++++++++++++---- .../src/__tests__/useMutationState.test-d.tsx | 17 ++++++++- packages/react-query/src/useMutationState.ts | 33 +++++++++++++---- .../src/__tests__/useMutationState.test-d.tsx | 23 +++++++++++- packages/solid-query/src/useMutationState.ts | 33 +++++++++++++---- packages/svelte-query/src/types.ts | 15 +++++--- .../src/useMutationState.svelte.ts | 27 +++++++++++--- .../useMutationState/SelectExample.svelte | 2 +- packages/vue-query/src/useMutationState.ts | 35 ++++++++++++++----- 11 files changed, 202 insertions(+), 42 deletions(-) create mode 100644 .changeset/fix-mutation-state-generics.md diff --git a/.changeset/fix-mutation-state-generics.md b/.changeset/fix-mutation-state-generics.md new file mode 100644 index 00000000000..30ad7552586 --- /dev/null +++ b/.changeset/fix-mutation-state-generics.md @@ -0,0 +1,9 @@ +--- +'@tanstack/react-query': patch +'@tanstack/preact-query': patch +'@tanstack/solid-query': patch +'@tanstack/vue-query': patch +'@tanstack/svelte-query': patch +--- + +fix(types): propagate generic type parameters to `useMutationState` select callback diff --git a/packages/preact-query/src/__tests__/useMutationState.test-d.tsx b/packages/preact-query/src/__tests__/useMutationState.test-d.tsx index 6c8a544ebdb..271ebe7b0df 100644 --- a/packages/preact-query/src/__tests__/useMutationState.test-d.tsx +++ b/packages/preact-query/src/__tests__/useMutationState.test-d.tsx @@ -1,4 +1,4 @@ -import type { MutationState, MutationStatus } from '@tanstack/query-core' +import type { Mutation, MutationState, MutationStatus } from '@tanstack/query-core' import { describe, expectTypeOf, it } from 'vitest' import { useMutationState } from '../useMutationState' @@ -21,4 +21,19 @@ describe('useMutationState', () => { expectTypeOf(result).toEqualTypeOf>() }) + it('should propagate generics to select callback when TResult is typed MutationState', () => { + type MyData = { data: Array } + type MyError = { code: number; message: string } + type MyVars = { id: number } + + useMutationState>({ + filters: { mutationKey: ['key'] }, + select: (mutation) => { + expectTypeOf(mutation).toEqualTypeOf< + Mutation + >() + return mutation.state + }, + }) + }) }) diff --git a/packages/preact-query/src/useMutationState.ts b/packages/preact-query/src/useMutationState.ts index 61fcd1b1c9a..919ed80be96 100644 --- a/packages/preact-query/src/useMutationState.ts +++ b/packages/preact-query/src/useMutationState.ts @@ -22,25 +22,44 @@ export function useIsMutating( ).length } -type MutationStateOptions = { +type MutationTypeFromResult = [TResult] extends [ + MutationState +] + ? Mutation + : Mutation + +type MutationStateOptions< + TResult = MutationState, + TMutation extends Mutation = MutationTypeFromResult, +> = { filters?: MutationFilters - select?: (mutation: Mutation) => TResult + select?: (mutation: TMutation) => TResult } -function getResult( +function getResult< + TResult = MutationState, + TMutation extends Mutation = MutationTypeFromResult, +>( mutationCache: MutationCache, - options: MutationStateOptions, + options: MutationStateOptions, ): Array { return mutationCache .findAll(options.filters) .map( (mutation): TResult => - (options.select ? options.select(mutation) : mutation.state) as TResult, + (options.select + ? (options.select as unknown as (mutation: Mutation) => TResult)( + mutation, + ) + : mutation.state) as TResult, ) } -export function useMutationState( - options: MutationStateOptions = {}, +export function useMutationState< + TResult = MutationState, + TMutation extends Mutation = MutationTypeFromResult, +>( + options: MutationStateOptions = {}, queryClient?: QueryClient, ): Array { const mutationCache = useQueryClient(queryClient).getMutationCache() diff --git a/packages/react-query/src/__tests__/useMutationState.test-d.tsx b/packages/react-query/src/__tests__/useMutationState.test-d.tsx index 795995aa440..834ac000eb3 100644 --- a/packages/react-query/src/__tests__/useMutationState.test-d.tsx +++ b/packages/react-query/src/__tests__/useMutationState.test-d.tsx @@ -1,6 +1,6 @@ import { describe, expectTypeOf, it } from 'vitest' import { useMutationState } from '../useMutationState' -import type { MutationState, MutationStatus } from '@tanstack/query-core' +import type { Mutation, MutationState, MutationStatus } from '@tanstack/query-core' describe('useMutationState', () => { it('should default to QueryState', () => { @@ -20,4 +20,19 @@ describe('useMutationState', () => { expectTypeOf(result).toEqualTypeOf>() }) + it('should propagate generics to select callback when TResult is typed MutationState', () => { + type MyData = { data: Array } + type MyError = { code: number; message: string } + type MyVars = { id: number } + + useMutationState>({ + filters: { mutationKey: ['key'] }, + select: (mutation) => { + expectTypeOf(mutation).toEqualTypeOf< + Mutation + >() + return mutation.state + }, + }) + }) }) diff --git a/packages/react-query/src/useMutationState.ts b/packages/react-query/src/useMutationState.ts index dfd0c41da3a..1947d658efb 100644 --- a/packages/react-query/src/useMutationState.ts +++ b/packages/react-query/src/useMutationState.ts @@ -22,25 +22,44 @@ export function useIsMutating( ).length } -type MutationStateOptions = { +type MutationTypeFromResult = [TResult] extends [ + MutationState +] + ? Mutation + : Mutation + +type MutationStateOptions< + TResult = MutationState, + TMutation extends Mutation = MutationTypeFromResult, +> = { filters?: MutationFilters - select?: (mutation: Mutation) => TResult + select?: (mutation: TMutation) => TResult } -function getResult( +function getResult< + TResult = MutationState, + TMutation extends Mutation = MutationTypeFromResult, +>( mutationCache: MutationCache, - options: MutationStateOptions, + options: MutationStateOptions, ): Array { return mutationCache .findAll(options.filters) .map( (mutation): TResult => - (options.select ? options.select(mutation) : mutation.state) as TResult, + (options.select + ? (options.select as unknown as (mutation: Mutation) => TResult)( + mutation, + ) + : mutation.state) as TResult, ) } -export function useMutationState( - options: MutationStateOptions = {}, +export function useMutationState< + TResult = MutationState, + TMutation extends Mutation = MutationTypeFromResult, +>( + options: MutationStateOptions = {}, queryClient?: QueryClient, ): Array { const mutationCache = useQueryClient(queryClient).getMutationCache() diff --git a/packages/solid-query/src/__tests__/useMutationState.test-d.tsx b/packages/solid-query/src/__tests__/useMutationState.test-d.tsx index dc8cca1e700..457b13a9a39 100644 --- a/packages/solid-query/src/__tests__/useMutationState.test-d.tsx +++ b/packages/solid-query/src/__tests__/useMutationState.test-d.tsx @@ -1,6 +1,6 @@ import { describe, expectTypeOf, it } from 'vitest' import { useMutationState } from '../useMutationState' -import type { MutationState, MutationStatus } from '@tanstack/query-core' +import type { Mutation, MutationState, MutationStatus } from '@tanstack/query-core' describe('useMutationState', () => { it('should default to QueryState', () => { @@ -18,4 +18,25 @@ describe('useMutationState', () => { expectTypeOf(result()).toEqualTypeOf>() }) + it('should propagate generics to select callback when TResult is typed MutationState', () => { + type MyData = { data: Array } + type MyError = { code: number; message: string } + type MyVars = { id: number } + + const result = useMutationState>( + () => ({ + filters: { mutationKey: ['key'] }, + select: (mutation) => { + expectTypeOf(mutation).toEqualTypeOf< + Mutation + >() + return mutation.state + }, + }), + ) + + expectTypeOf(result()).toEqualTypeOf< + Array> + >() + }) }) diff --git a/packages/solid-query/src/useMutationState.ts b/packages/solid-query/src/useMutationState.ts index 2a405a1ae4b..eb989e48c34 100644 --- a/packages/solid-query/src/useMutationState.ts +++ b/packages/solid-query/src/useMutationState.ts @@ -10,25 +10,44 @@ import type { import type { Accessor } from 'solid-js' import type { QueryClient } from './QueryClient' -type MutationStateOptions = { +type MutationTypeFromResult = [TResult] extends [ + MutationState +] + ? Mutation + : Mutation + +type MutationStateOptions< + TResult = MutationState, + TMutation extends Mutation = MutationTypeFromResult, +> = { filters?: MutationFilters - select?: (mutation: Mutation) => TResult + select?: (mutation: TMutation) => TResult } -function getResult( +function getResult< + TResult = MutationState, + TMutation extends Mutation = MutationTypeFromResult, +>( mutationCache: MutationCache, - options: MutationStateOptions, + options: MutationStateOptions, ): Array { return mutationCache .findAll(options.filters) .map( (mutation): TResult => - (options.select ? options.select(mutation) : mutation.state) as TResult, + (options.select + ? (options.select as unknown as (mutation: Mutation) => TResult)( + mutation, + ) + : mutation.state) as TResult, ) } -export function useMutationState( - options: Accessor> = () => ({}), +export function useMutationState< + TResult = MutationState, + TMutation extends Mutation = MutationTypeFromResult, +>( + options: Accessor> = () => ({}), queryClient?: Accessor, ): Accessor> { const client = createMemo(() => useQueryClient(queryClient?.())) diff --git a/packages/svelte-query/src/types.ts b/packages/svelte-query/src/types.ts index 9a64d10dc3f..8daca6b3d58 100644 --- a/packages/svelte-query/src/types.ts +++ b/packages/svelte-query/src/types.ts @@ -136,12 +136,19 @@ export type CreateMutationResult< TOnMutateResult = unknown, > = CreateBaseMutationResult +type MutationTypeFromResult = [TResult] extends [ + MutationState +] + ? Mutation + : Mutation + /** Options for useMutationState */ -export type MutationStateOptions = { +export type MutationStateOptions< + TResult = MutationState, + TMutation extends Mutation = MutationTypeFromResult, +> = { filters?: MutationFilters - select?: ( - mutation: Mutation, - ) => TResult + select?: (mutation: TMutation) => TResult } export type QueryClientProviderProps = { diff --git a/packages/svelte-query/src/useMutationState.svelte.ts b/packages/svelte-query/src/useMutationState.svelte.ts index c517e64b480..b1e4a739019 100644 --- a/packages/svelte-query/src/useMutationState.svelte.ts +++ b/packages/svelte-query/src/useMutationState.svelte.ts @@ -1,26 +1,43 @@ import { replaceEqualDeep } from '@tanstack/query-core' import { useQueryClient } from './useQueryClient.js' import type { + Mutation, MutationCache, MutationState, QueryClient, } from '@tanstack/query-core' import type { MutationStateOptions } from './types.js' -function getResult( +type MutationTypeFromResult = [TResult] extends [ + MutationState +] + ? Mutation + : Mutation + +function getResult< + TResult = MutationState, + TMutation extends Mutation = MutationTypeFromResult, +>( mutationCache: MutationCache, - options: MutationStateOptions, + options: MutationStateOptions, ): Array { return mutationCache .findAll(options.filters) .map( (mutation): TResult => - (options.select ? options.select(mutation) : mutation.state) as TResult, + (options.select + ? (options.select as unknown as (mutation: Mutation) => TResult)( + mutation, + ) + : mutation.state) as TResult, ) } -export function useMutationState( - options: MutationStateOptions = {}, +export function useMutationState< + TResult = MutationState, + TMutation extends Mutation = MutationTypeFromResult, +>( + options: MutationStateOptions = {}, queryClient?: QueryClient, ): Array { const mutationCache = useQueryClient(queryClient).getMutationCache() diff --git a/packages/svelte-query/tests/useMutationState/SelectExample.svelte b/packages/svelte-query/tests/useMutationState/SelectExample.svelte index 683f68043eb..3c0389a7808 100644 --- a/packages/svelte-query/tests/useMutationState/SelectExample.svelte +++ b/packages/svelte-query/tests/useMutationState/SelectExample.svelte @@ -16,7 +16,7 @@ mutationStateOpts, }: { mutationOpts: Accessor - mutationStateOpts: MutationStateOptions + mutationStateOpts: MutationStateOptions } = $props() const queryClient = new QueryClient() diff --git a/packages/vue-query/src/useMutationState.ts b/packages/vue-query/src/useMutationState.ts index 3395b5fb743..3efca509d57 100644 --- a/packages/vue-query/src/useMutationState.ts +++ b/packages/vue-query/src/useMutationState.ts @@ -48,27 +48,46 @@ export function useIsMutating( return length } -export type MutationStateOptions = { +type MutationTypeFromResult = [TResult] extends [ + MutationState +] + ? Mutation + : Mutation + +export type MutationStateOptions< + TResult = MutationState, + TMutation extends Mutation = MutationTypeFromResult, +> = { filters?: MutationFilters - select?: (mutation: Mutation) => TResult + select?: (mutation: TMutation) => TResult } -function getResult( +function getResult< + TResult = MutationState, + TMutation extends Mutation = MutationTypeFromResult, +>( mutationCache: MutationCache, - options: MutationStateOptions, + options: MutationStateOptions, ): Array { return mutationCache .findAll(options.filters) .map( (mutation): TResult => - (options.select ? options.select(mutation) : mutation.state) as TResult, + (options.select + ? (options.select as unknown as (mutation: Mutation) => TResult)( + mutation, + ) + : mutation.state) as TResult, ) } -export function useMutationState( +export function useMutationState< + TResult = MutationState, + TMutation extends Mutation = MutationTypeFromResult, +>( options: - | MutationStateOptions - | (() => MutationStateOptions) = {}, + | MutationStateOptions + | (() => MutationStateOptions) = {}, queryClient?: QueryClient, ): Readonly>> { const resolvedOptions = computed(() => { From b73c36acb714a52c6596e22f3d2a6cad9c58ad9d Mon Sep 17 00:00:00 2001 From: "autofix-ci[bot]" <114827586+autofix-ci[bot]@users.noreply.github.com> Date: Wed, 1 Apr 2026 17:08:57 +0000 Subject: [PATCH 2/3] ci: apply automated fixes --- .../src/__tests__/useMutationState.test-d.tsx | 6 +++++- packages/preact-query/src/useMutationState.ts | 16 ++++++++++++---- .../src/__tests__/useMutationState.test-d.tsx | 6 +++++- packages/react-query/src/useMutationState.ts | 16 ++++++++++++---- .../src/__tests__/useMutationState.test-d.tsx | 6 +++++- packages/solid-query/src/useMutationState.ts | 16 ++++++++++++---- packages/svelte-query/src/types.ts | 10 ++++++++-- .../svelte-query/src/useMutationState.svelte.ts | 13 ++++++++++--- packages/vue-query/src/useMutationState.ts | 16 ++++++++++++---- 9 files changed, 81 insertions(+), 24 deletions(-) diff --git a/packages/preact-query/src/__tests__/useMutationState.test-d.tsx b/packages/preact-query/src/__tests__/useMutationState.test-d.tsx index 271ebe7b0df..679444258fe 100644 --- a/packages/preact-query/src/__tests__/useMutationState.test-d.tsx +++ b/packages/preact-query/src/__tests__/useMutationState.test-d.tsx @@ -1,4 +1,8 @@ -import type { Mutation, MutationState, MutationStatus } from '@tanstack/query-core' +import type { + Mutation, + MutationState, + MutationStatus, +} from '@tanstack/query-core' import { describe, expectTypeOf, it } from 'vitest' import { useMutationState } from '../useMutationState' diff --git a/packages/preact-query/src/useMutationState.ts b/packages/preact-query/src/useMutationState.ts index 919ed80be96..0c4dbdbbc98 100644 --- a/packages/preact-query/src/useMutationState.ts +++ b/packages/preact-query/src/useMutationState.ts @@ -23,14 +23,20 @@ export function useIsMutating( } type MutationTypeFromResult = [TResult] extends [ - MutationState + MutationState< + infer TData, + infer TError, + infer TVariables, + infer TOnMutateResult + >, ] ? Mutation : Mutation type MutationStateOptions< TResult = MutationState, - TMutation extends Mutation = MutationTypeFromResult, + TMutation extends Mutation = + MutationTypeFromResult, > = { filters?: MutationFilters select?: (mutation: TMutation) => TResult @@ -38,7 +44,8 @@ type MutationStateOptions< function getResult< TResult = MutationState, - TMutation extends Mutation = MutationTypeFromResult, + TMutation extends Mutation = + MutationTypeFromResult, >( mutationCache: MutationCache, options: MutationStateOptions, @@ -57,7 +64,8 @@ function getResult< export function useMutationState< TResult = MutationState, - TMutation extends Mutation = MutationTypeFromResult, + TMutation extends Mutation = + MutationTypeFromResult, >( options: MutationStateOptions = {}, queryClient?: QueryClient, diff --git a/packages/react-query/src/__tests__/useMutationState.test-d.tsx b/packages/react-query/src/__tests__/useMutationState.test-d.tsx index 834ac000eb3..a24b8763a6b 100644 --- a/packages/react-query/src/__tests__/useMutationState.test-d.tsx +++ b/packages/react-query/src/__tests__/useMutationState.test-d.tsx @@ -1,6 +1,10 @@ import { describe, expectTypeOf, it } from 'vitest' import { useMutationState } from '../useMutationState' -import type { Mutation, MutationState, MutationStatus } from '@tanstack/query-core' +import type { + Mutation, + MutationState, + MutationStatus, +} from '@tanstack/query-core' describe('useMutationState', () => { it('should default to QueryState', () => { diff --git a/packages/react-query/src/useMutationState.ts b/packages/react-query/src/useMutationState.ts index 1947d658efb..8fdc52acde0 100644 --- a/packages/react-query/src/useMutationState.ts +++ b/packages/react-query/src/useMutationState.ts @@ -23,14 +23,20 @@ export function useIsMutating( } type MutationTypeFromResult = [TResult] extends [ - MutationState + MutationState< + infer TData, + infer TError, + infer TVariables, + infer TOnMutateResult + >, ] ? Mutation : Mutation type MutationStateOptions< TResult = MutationState, - TMutation extends Mutation = MutationTypeFromResult, + TMutation extends Mutation = + MutationTypeFromResult, > = { filters?: MutationFilters select?: (mutation: TMutation) => TResult @@ -38,7 +44,8 @@ type MutationStateOptions< function getResult< TResult = MutationState, - TMutation extends Mutation = MutationTypeFromResult, + TMutation extends Mutation = + MutationTypeFromResult, >( mutationCache: MutationCache, options: MutationStateOptions, @@ -57,7 +64,8 @@ function getResult< export function useMutationState< TResult = MutationState, - TMutation extends Mutation = MutationTypeFromResult, + TMutation extends Mutation = + MutationTypeFromResult, >( options: MutationStateOptions = {}, queryClient?: QueryClient, diff --git a/packages/solid-query/src/__tests__/useMutationState.test-d.tsx b/packages/solid-query/src/__tests__/useMutationState.test-d.tsx index 457b13a9a39..819bed9db70 100644 --- a/packages/solid-query/src/__tests__/useMutationState.test-d.tsx +++ b/packages/solid-query/src/__tests__/useMutationState.test-d.tsx @@ -1,6 +1,10 @@ import { describe, expectTypeOf, it } from 'vitest' import { useMutationState } from '../useMutationState' -import type { Mutation, MutationState, MutationStatus } from '@tanstack/query-core' +import type { + Mutation, + MutationState, + MutationStatus, +} from '@tanstack/query-core' describe('useMutationState', () => { it('should default to QueryState', () => { diff --git a/packages/solid-query/src/useMutationState.ts b/packages/solid-query/src/useMutationState.ts index eb989e48c34..333840e8c45 100644 --- a/packages/solid-query/src/useMutationState.ts +++ b/packages/solid-query/src/useMutationState.ts @@ -11,14 +11,20 @@ import type { Accessor } from 'solid-js' import type { QueryClient } from './QueryClient' type MutationTypeFromResult = [TResult] extends [ - MutationState + MutationState< + infer TData, + infer TError, + infer TVariables, + infer TOnMutateResult + >, ] ? Mutation : Mutation type MutationStateOptions< TResult = MutationState, - TMutation extends Mutation = MutationTypeFromResult, + TMutation extends Mutation = + MutationTypeFromResult, > = { filters?: MutationFilters select?: (mutation: TMutation) => TResult @@ -26,7 +32,8 @@ type MutationStateOptions< function getResult< TResult = MutationState, - TMutation extends Mutation = MutationTypeFromResult, + TMutation extends Mutation = + MutationTypeFromResult, >( mutationCache: MutationCache, options: MutationStateOptions, @@ -45,7 +52,8 @@ function getResult< export function useMutationState< TResult = MutationState, - TMutation extends Mutation = MutationTypeFromResult, + TMutation extends Mutation = + MutationTypeFromResult, >( options: Accessor> = () => ({}), queryClient?: Accessor, diff --git a/packages/svelte-query/src/types.ts b/packages/svelte-query/src/types.ts index 8daca6b3d58..39cc83c805a 100644 --- a/packages/svelte-query/src/types.ts +++ b/packages/svelte-query/src/types.ts @@ -137,7 +137,12 @@ export type CreateMutationResult< > = CreateBaseMutationResult type MutationTypeFromResult = [TResult] extends [ - MutationState + MutationState< + infer TData, + infer TError, + infer TVariables, + infer TOnMutateResult + >, ] ? Mutation : Mutation @@ -145,7 +150,8 @@ type MutationTypeFromResult = [TResult] extends [ /** Options for useMutationState */ export type MutationStateOptions< TResult = MutationState, - TMutation extends Mutation = MutationTypeFromResult, + TMutation extends Mutation = + MutationTypeFromResult, > = { filters?: MutationFilters select?: (mutation: TMutation) => TResult diff --git a/packages/svelte-query/src/useMutationState.svelte.ts b/packages/svelte-query/src/useMutationState.svelte.ts index b1e4a739019..44efac2ecfd 100644 --- a/packages/svelte-query/src/useMutationState.svelte.ts +++ b/packages/svelte-query/src/useMutationState.svelte.ts @@ -9,14 +9,20 @@ import type { import type { MutationStateOptions } from './types.js' type MutationTypeFromResult = [TResult] extends [ - MutationState + MutationState< + infer TData, + infer TError, + infer TVariables, + infer TOnMutateResult + >, ] ? Mutation : Mutation function getResult< TResult = MutationState, - TMutation extends Mutation = MutationTypeFromResult, + TMutation extends Mutation = + MutationTypeFromResult, >( mutationCache: MutationCache, options: MutationStateOptions, @@ -35,7 +41,8 @@ function getResult< export function useMutationState< TResult = MutationState, - TMutation extends Mutation = MutationTypeFromResult, + TMutation extends Mutation = + MutationTypeFromResult, >( options: MutationStateOptions = {}, queryClient?: QueryClient, diff --git a/packages/vue-query/src/useMutationState.ts b/packages/vue-query/src/useMutationState.ts index 3efca509d57..748adebd413 100644 --- a/packages/vue-query/src/useMutationState.ts +++ b/packages/vue-query/src/useMutationState.ts @@ -49,14 +49,20 @@ export function useIsMutating( } type MutationTypeFromResult = [TResult] extends [ - MutationState + MutationState< + infer TData, + infer TError, + infer TVariables, + infer TOnMutateResult + >, ] ? Mutation : Mutation export type MutationStateOptions< TResult = MutationState, - TMutation extends Mutation = MutationTypeFromResult, + TMutation extends Mutation = + MutationTypeFromResult, > = { filters?: MutationFilters select?: (mutation: TMutation) => TResult @@ -64,7 +70,8 @@ export type MutationStateOptions< function getResult< TResult = MutationState, - TMutation extends Mutation = MutationTypeFromResult, + TMutation extends Mutation = + MutationTypeFromResult, >( mutationCache: MutationCache, options: MutationStateOptions, @@ -83,7 +90,8 @@ function getResult< export function useMutationState< TResult = MutationState, - TMutation extends Mutation = MutationTypeFromResult, + TMutation extends Mutation = + MutationTypeFromResult, >( options: | MutationStateOptions From 57bb423c7f4c9c3e3ee7d7ae4c15718afa718ab2 Mon Sep 17 00:00:00 2001 From: Zelys Date: Wed, 1 Apr 2026 12:44:00 -0500 Subject: [PATCH 3/3] refactor(types): simplify useMutationState cast to mutation as TMutation MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Replace the double-cast `(fn as unknown as (m: Mutation) => TResult)(m)` with the direct `fn(m as TMutation)` across all five framework packages. The constraint `TMutation extends Mutation` creates sufficient overlap for the single cast to compile cleanly on TS 5.4–6.0. --- packages/preact-query/src/useMutationState.ts | 4 +--- packages/react-query/src/useMutationState.ts | 4 +--- packages/solid-query/src/useMutationState.ts | 4 +--- packages/svelte-query/src/useMutationState.svelte.ts | 4 +--- packages/vue-query/src/useMutationState.ts | 4 +--- 5 files changed, 5 insertions(+), 15 deletions(-) diff --git a/packages/preact-query/src/useMutationState.ts b/packages/preact-query/src/useMutationState.ts index 0c4dbdbbc98..b998467925f 100644 --- a/packages/preact-query/src/useMutationState.ts +++ b/packages/preact-query/src/useMutationState.ts @@ -55,9 +55,7 @@ function getResult< .map( (mutation): TResult => (options.select - ? (options.select as unknown as (mutation: Mutation) => TResult)( - mutation, - ) + ? options.select(mutation as TMutation) : mutation.state) as TResult, ) } diff --git a/packages/react-query/src/useMutationState.ts b/packages/react-query/src/useMutationState.ts index 8fdc52acde0..ce21870527b 100644 --- a/packages/react-query/src/useMutationState.ts +++ b/packages/react-query/src/useMutationState.ts @@ -55,9 +55,7 @@ function getResult< .map( (mutation): TResult => (options.select - ? (options.select as unknown as (mutation: Mutation) => TResult)( - mutation, - ) + ? options.select(mutation as TMutation) : mutation.state) as TResult, ) } diff --git a/packages/solid-query/src/useMutationState.ts b/packages/solid-query/src/useMutationState.ts index 333840e8c45..bc778ebb3e5 100644 --- a/packages/solid-query/src/useMutationState.ts +++ b/packages/solid-query/src/useMutationState.ts @@ -43,9 +43,7 @@ function getResult< .map( (mutation): TResult => (options.select - ? (options.select as unknown as (mutation: Mutation) => TResult)( - mutation, - ) + ? options.select(mutation as TMutation) : mutation.state) as TResult, ) } diff --git a/packages/svelte-query/src/useMutationState.svelte.ts b/packages/svelte-query/src/useMutationState.svelte.ts index 44efac2ecfd..2932336bf0b 100644 --- a/packages/svelte-query/src/useMutationState.svelte.ts +++ b/packages/svelte-query/src/useMutationState.svelte.ts @@ -32,9 +32,7 @@ function getResult< .map( (mutation): TResult => (options.select - ? (options.select as unknown as (mutation: Mutation) => TResult)( - mutation, - ) + ? options.select(mutation as TMutation) : mutation.state) as TResult, ) } diff --git a/packages/vue-query/src/useMutationState.ts b/packages/vue-query/src/useMutationState.ts index 748adebd413..5f55252cdca 100644 --- a/packages/vue-query/src/useMutationState.ts +++ b/packages/vue-query/src/useMutationState.ts @@ -81,9 +81,7 @@ function getResult< .map( (mutation): TResult => (options.select - ? (options.select as unknown as (mutation: Mutation) => TResult)( - mutation, - ) + ? options.select(mutation as TMutation) : mutation.state) as TResult, ) }