@tanstack/solid-query 5.25.0 → 5.26.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/solid-query",
-  "version": "5.25.0",
+  "version": "5.26.3",
   "description": "Primitives for managing, caching and syncing asynchronous and remote data in Solid",
   "author": "tannerlinsley",
   "license": "MIT",
@@ -48,7 +48,7 @@
   ],
   "dependencies": {
     "solid-js": "^1.8.14",
-    "@tanstack/query-core": "5.25.0"
+    "@tanstack/query-core": "5.26.3"
   },
   "devDependencies": {
     "tsup-preset-solid": "^2.2.0",

package/src/__tests__/createQueries.test.tsx

@@ -1,7 +1,6 @@
 import { describe, expect, expectTypeOf, it, vi } from 'vitest'
 import { fireEvent, render, waitFor } from '@solidjs/testing-library'
 import * as QueryCore from '@tanstack/query-core'
-
 import { createRenderEffect, createSignal } from 'solid-js'
 import {
   QueriesObserver,
@@ -9,18 +8,9 @@ import {
   QueryClientProvider,
   createQueries,
 } from '..'
-import { createQueryClient, expectTypeNotAny, queryKey, sleep } from './utils'
-import type {
-  QueryFunctionContext,
-  QueryKey,
-  SkipToken,
-} from '@tanstack/query-core'
-import type {
-  CreateQueryResult,
-  QueryFunction,
-  QueryObserverResult,
-  SolidQueryOptions,
-} from '..'
+import { createQueryClient, queryKey, sleep } from './utils'
+import type { QueryFunctionContext, QueryKey } from '@tanstack/query-core'
+import type { CreateQueryResult, QueryFunction, SolidQueryOptions } from '..'
 
 describe('useQueries', () => {
   const queryCache = new QueryCache()
@@ -104,13 +94,15 @@ describe('useQueries', () => {
           },
         ],
       }))
-      expectTypeOf<QueryObserverResult<number, unknown>>(result1[0])
-      expectTypeOf<QueryObserverResult<string, unknown>>(result1[1])
-      expectTypeOf<QueryObserverResult<Array<string>, boolean>>(result1[2])
-      expectTypeOf<number | undefined>(result1[0].data)
-      expectTypeOf<string | undefined>(result1[1].data)
-      expectTypeOf<Array<string> | undefined>(result1[2].data)
-      expectTypeOf<boolean | null>(result1[2].error)
+      expectTypeOf(result1[0]).toEqualTypeOf<CreateQueryResult<number>>()
+      expectTypeOf(result1[1]).toEqualTypeOf<CreateQueryResult<string>>()
+      expectTypeOf(result1[2]).toEqualTypeOf<
+        CreateQueryResult<Array<string>, boolean>
+      >()
+      expectTypeOf(result1[0].data).toEqualTypeOf<number | undefined>()
+      expectTypeOf(result1[1].data).toEqualTypeOf<string | undefined>()
+      expectTypeOf(result1[2].data).toEqualTypeOf<Array<string> | undefined>()
+      expectTypeOf(result1[2].error).toEqualTypeOf<boolean | null>()
 
       // TData (3rd element) takes precedence over TQueryFnData (1st element)
       const result2 = createQueries<
@@ -121,8 +113,7 @@ describe('useQueries', () => {
             queryKey: key1,
             queryFn: () => 'string',
             select: (a) => {
-              expectTypeOf<string>(a)
-              expectTypeNotAny(a)
+              expectTypeOf(a).toEqualTypeOf<string>()
               return a.toLowerCase()
             },
           },
@@ -130,17 +121,20 @@ describe('useQueries', () => {
             queryKey: key2,
             queryFn: () => 'string',
             select: (a) => {
-              expectTypeOf<string>(a)
-              expectTypeNotAny(a)
+              expectTypeOf(a).toEqualTypeOf<string>()
               return parseInt(a)
             },
           },
         ],
       }))
-      expectTypeOf<QueryObserverResult<string, unknown>>(result2[0])
-      expectTypeOf<QueryObserverResult<number, unknown>>(result2[1])
-      expectTypeOf<string | undefined>(result2[0].data)
-      expectTypeOf<number | undefined>(result2[1].data)
+      expectTypeOf(result2[0]).toEqualTypeOf<
+        CreateQueryResult<string, unknown>
+      >()
+      expectTypeOf(result2[1]).toEqualTypeOf<
+        CreateQueryResult<number, unknown>
+      >()
+      expectTypeOf(result2[0].data).toEqualTypeOf<string | undefined>()
+      expectTypeOf(result2[1].data).toEqualTypeOf<number | undefined>()
 
       // types should be enforced
       createQueries<[[string, unknown, string], [string, boolean, number]]>(
@@ -150,8 +144,7 @@ describe('useQueries', () => {
               queryKey: key1,
               queryFn: () => 'string',
               select: (a) => {
-                expectTypeOf<string>(a)
-                expectTypeNotAny(a)
+                expectTypeOf(a).toEqualTypeOf<string>()
                 return a.toLowerCase()
               },
               placeholderData: 'string',
@@ -162,8 +155,7 @@ describe('useQueries', () => {
               queryKey: key2,
               queryFn: () => 'string',
               select: (a) => {
-                expectTypeOf<string>(a)
-                expectTypeNotAny(a)
+                expectTypeOf(a).toEqualTypeOf<string>()
                 return parseInt(a)
               },
               placeholderData: 'string',
@@ -215,13 +207,19 @@ describe('useQueries', () => {
           },
         ],
       }))
-      expectTypeOf<QueryObserverResult<number, unknown>>(result1[0])
-      expectTypeOf<QueryObserverResult<string, unknown>>(result1[1])
-      expectTypeOf<QueryObserverResult<Array<string>, boolean>>(result1[2])
-      expectTypeOf<number | undefined>(result1[0].data)
-      expectTypeOf<string | undefined>(result1[1].data)
-      expectTypeOf<Array<string> | undefined>(result1[2].data)
-      expectTypeOf<boolean | null>(result1[2].error)
+      expectTypeOf(result1[0]).toEqualTypeOf<
+        CreateQueryResult<number, unknown>
+      >()
+      expectTypeOf(result1[1]).toEqualTypeOf<
+        CreateQueryResult<string, unknown>
+      >()
+      expectTypeOf(result1[2]).toEqualTypeOf<
+        CreateQueryResult<Array<string>, boolean>
+      >()
+      expectTypeOf(result1[0].data).toEqualTypeOf<number | undefined>()
+      expectTypeOf(result1[1].data).toEqualTypeOf<string | undefined>()
+      expectTypeOf(result1[2].data).toEqualTypeOf<Array<string> | undefined>()
+      expectTypeOf(result1[2].error).toEqualTypeOf<boolean | null>()
 
       // TData (data prop) takes precedence over TQueryFnData (queryFnData prop)
       const result2 = createQueries<
@@ -235,8 +233,7 @@ describe('useQueries', () => {
             queryKey: key1,
             queryFn: () => 'string',
             select: (a) => {
-              expectTypeOf<string>(a)
-              expectTypeNotAny(a)
+              expectTypeOf(a).toEqualTypeOf<string>()
               return a.toLowerCase()
             },
           },
@@ -244,17 +241,20 @@ describe('useQueries', () => {
             queryKey: key2,
             queryFn: () => 'string',
             select: (a) => {
-              expectTypeOf<string>(a)
-              expectTypeNotAny(a)
+              expectTypeOf(a).toEqualTypeOf<string>()
               return parseInt(a)
             },
           },
         ],
       }))
-      expectTypeOf<QueryObserverResult<string, unknown>>(result2[0])
-      expectTypeOf<QueryObserverResult<number, unknown>>(result2[1])
-      expectTypeOf<string | undefined>(result2[0].data)
-      expectTypeOf<number | undefined>(result2[1].data)
+      expectTypeOf(result2[0]).toEqualTypeOf<
+        CreateQueryResult<string, unknown>
+      >()
+      expectTypeOf(result2[1]).toEqualTypeOf<
+        CreateQueryResult<number, unknown>
+      >()
+      expectTypeOf(result2[0].data).toEqualTypeOf<string | undefined>()
+      expectTypeOf(result2[1].data).toEqualTypeOf<number | undefined>()
 
       // can pass only TData (data prop) although TQueryFnData will be left unknown
       const result3 = createQueries<[{ data: string }, { data: number }]>(
@@ -264,8 +264,7 @@ describe('useQueries', () => {
               queryKey: key1,
               queryFn: () => 'string',
               select: (a) => {
-                expectTypeOf<unknown>(a)
-                expectTypeNotAny(a)
+                expectTypeOf(a).toEqualTypeOf<unknown>()
                 return a as string
               },
             },
@@ -273,18 +272,21 @@ describe('useQueries', () => {
               queryKey: key2,
               queryFn: () => 'string',
               select: (a) => {
-                expectTypeOf<unknown>(a)
-                expectTypeNotAny(a)
+                expectTypeOf(a).toEqualTypeOf<unknown>()
                 return a as number
               },
             },
           ],
         }),
       )
-      expectTypeOf<QueryObserverResult<string, unknown>>(result3[0])
-      expectTypeOf<QueryObserverResult<number, unknown>>(result3[1])
-      expectTypeOf<string | undefined>(result3[0].data)
-      expectTypeOf<number | undefined>(result3[1].data)
+      expectTypeOf(result3[0]).toEqualTypeOf<
+        CreateQueryResult<string, unknown>
+      >()
+      expectTypeOf(result3[1]).toEqualTypeOf<
+        CreateQueryResult<number, unknown>
+      >()
+      expectTypeOf(result3[0].data).toEqualTypeOf<string | undefined>()
+      expectTypeOf(result3[1].data).toEqualTypeOf<number | undefined>()
 
       // types should be enforced
       createQueries<
@@ -298,8 +300,7 @@ describe('useQueries', () => {
             queryKey: key1,
             queryFn: () => 'string',
             select: (a) => {
-              expectTypeOf<string>(a)
-              expectTypeNotAny(a)
+              expectTypeOf(a).toEqualTypeOf<string>()
               return a.toLowerCase()
             },
             placeholderData: 'string',
@@ -310,8 +311,7 @@ describe('useQueries', () => {
             queryKey: key2,
             queryFn: () => 'string',
             select: (a) => {
-              expectTypeOf<string>(a)
-              expectTypeNotAny(a)
+              expectTypeOf(a).toEqualTypeOf<string>()
               return parseInt(a)
             },
             placeholderData: 'string',
@@ -348,8 +348,12 @@ describe('useQueries', () => {
           queryFn: () => i + 10,
         })),
       }))
-      expectTypeOf<Array<QueryObserverResult<number, unknown>>>(result1)
-      expectTypeOf<number | undefined>(result1[0]?.data)
+      expectTypeOf(result1).toEqualTypeOf<
+        Array<CreateQueryResult<number, Error>>
+      >()
+      if (result1[0]) {
+        expectTypeOf(result1[0].data).toEqualTypeOf<number | undefined>()
+      }
 
       // Array.map preserves TData
       const result2 = createQueries(() => ({
@@ -359,7 +363,9 @@ describe('useQueries', () => {
           select: (data: number) => data.toString(),
         })),
       }))
-      expectTypeOf<Array<QueryObserverResult<string, unknown>>>(result2)
+      expectTypeOf(result2).toEqualTypeOf<
+        Array<CreateQueryResult<string, Error>>
+      >()
 
       const result3 = createQueries(() => ({
         queries: [
@@ -378,13 +384,13 @@ describe('useQueries', () => {
           },
         ],
       }))
-      expectTypeOf<QueryObserverResult<number, unknown>>(result3[0])
-      expectTypeOf<QueryObserverResult<string, unknown>>(result3[1])
-      expectTypeOf<QueryObserverResult<number, unknown>>(result3[2])
-      expectTypeOf<number | undefined>(result3[0].data)
-      expectTypeOf<string | undefined>(result3[1].data)
+      expectTypeOf(result3[0]).toEqualTypeOf<CreateQueryResult<number, Error>>()
+      expectTypeOf(result3[1]).toEqualTypeOf<CreateQueryResult<string, Error>>()
+      expectTypeOf(result3[2]).toEqualTypeOf<CreateQueryResult<number, Error>>()
+      expectTypeOf(result3[0].data).toEqualTypeOf<number | undefined>()
+      expectTypeOf(result3[1].data).toEqualTypeOf<string | undefined>()
       // select takes precedence over queryFn
-      expectTypeOf<number | undefined>(result3[2].data)
+      expectTypeOf(result3[2].data).toEqualTypeOf<number | undefined>()
 
       // initialData/placeholderData are enforced
       createQueries(() => ({
@@ -467,9 +473,9 @@ describe('useQueries', () => {
           },
         ],
       }))
-      expectTypeOf<QueryObserverResult<string, unknown>>(result4[0])
-      expectTypeOf<QueryObserverResult<string, unknown>>(result4[1])
-      expectTypeOf<QueryObserverResult<number, unknown>>(result4[2])
+      expectTypeOf(result4[0]).toEqualTypeOf<CreateQueryResult<string, Error>>()
+      expectTypeOf(result4[1]).toEqualTypeOf<CreateQueryResult<string, Error>>()
+      expectTypeOf(result4[2]).toEqualTypeOf<CreateQueryResult<number, Error>>()
 
       // handles when queryFn returns a Promise
       const result5 = createQueries(() => ({
@@ -480,7 +486,7 @@ describe('useQueries', () => {
           },
         ],
       }))
-      expectTypeOf<QueryObserverResult<string, unknown>>(result5[0])
+      expectTypeOf(result5[0]).toEqualTypeOf<CreateQueryResult<string, Error>>()
 
       // Array as const does not throw error
       const result6 = createQueries(
@@ -498,8 +504,8 @@ describe('useQueries', () => {
             ],
           }) as const,
       )
-      expectTypeOf<QueryObserverResult<string, unknown>>(result6[0])
-      expectTypeOf<QueryObserverResult<number, unknown>>(result6[1])
+      expectTypeOf(result6[0]).toEqualTypeOf<CreateQueryResult<string, Error>>()
+      expectTypeOf(result6[1]).toEqualTypeOf<CreateQueryResult<number, Error>>()
 
       // field names should be enforced - array literal
       createQueries(() => ({
@@ -585,9 +591,11 @@ describe('useQueries', () => {
           // no need to type the mapped query
           (query) => {
             const { queryFn: fn, queryKey: key } = query
-            expectTypeOf<
-              QueryFunction<TQueryFnData, TQueryKey> | SkipToken | undefined
-            >(fn)
+            expectTypeOf(fn).toEqualTypeOf<
+              | typeof QueryCore.skipToken
+              | QueryCore.QueryFunction<TQueryFnData, TQueryKey, never>
+              | undefined
+            >()
             return {
               queryKey: key,
               queryFn: fn
@@ -619,8 +627,8 @@ describe('useQueries', () => {
           },
         ],
       }))
-      expectTypeOf<QueryObserverResult<number, unknown>>(result[0])
-      expectTypeOf<QueryObserverResult<string, unknown>>(result[1])
+      expectTypeOf(result[0]).toEqualTypeOf<CreateQueryResult<number, Error>>()
+      expectTypeOf(result[1]).toEqualTypeOf<CreateQueryResult<string, Error>>()
 
       const withSelector = createQueries(() => ({
         queries: [
@@ -636,12 +644,12 @@ describe('useQueries', () => {
           },
         ],
       }))
-      expectTypeOf<QueryObserverResult<[number, string], unknown>>(
-        withSelector[0],
-      )
-      expectTypeOf<QueryObserverResult<[string, number], unknown>>(
-        withSelector[1],
-      )
+      expectTypeOf(withSelector[0]).toEqualTypeOf<
+        CreateQueryResult<[number, string], Error>
+      >()
+      expectTypeOf(withSelector[1]).toEqualTypeOf<
+        CreateQueryResult<[string, number], Error>
+      >()
 
       const withWrappedQueries = useWrappedQueries(
         Array(10).map(() => ({
@@ -651,9 +659,9 @@ describe('useQueries', () => {
         })),
       )
 
-      expectTypeOf<Array<QueryObserverResult<number | undefined, unknown>>>(
-        withWrappedQueries,
-      )
+      expectTypeOf(withWrappedQueries).toEqualTypeOf<
+        Array<CreateQueryResult<number, Error>>
+      >()
     }
   })
 

package/src/__tests__/createQuery.test.tsx

@@ -46,32 +46,32 @@ describe('createQuery', () => {
     function Page() {
       // unspecified query function should default to unknown
       const noQueryFn = createQuery(() => ({ queryKey: key }))
-      expectTypeOf<unknown>(noQueryFn.data)
-      expectTypeOf<unknown>(noQueryFn.error)
+      expectTypeOf(noQueryFn.data).toEqualTypeOf<unknown>()
+      expectTypeOf(noQueryFn.error).toEqualTypeOf<Error | null>()
 
       // it should infer the result type from the query function
       const fromQueryFn = createQuery(() => ({
         queryKey: key,
         queryFn: () => 'test',
       }))
-      expectTypeOf<string | undefined>(fromQueryFn.data)
-      expectTypeOf<unknown>(fromQueryFn.error)
+      expectTypeOf(fromQueryFn.data).toEqualTypeOf<string | undefined>()
+      expectTypeOf(fromQueryFn.error).toEqualTypeOf<Error | null>()
 
       // it should be possible to specify the result type
       const withResult = createQuery<string>(() => ({
         queryKey: key,
         queryFn: () => 'test',
       }))
-      expectTypeOf<string | undefined>(withResult.data)
-      expectTypeOf<unknown | null>(withResult.error)
+      expectTypeOf(withResult.data).toEqualTypeOf<string | undefined>()
+      expectTypeOf(withResult.error).toEqualTypeOf<Error | null>()
 
       // it should be possible to specify the error type
       const withError = createQuery<string, Error>(() => ({
         queryKey: key,
         queryFn: () => 'test',
       }))
-      expectTypeOf<string | undefined>(withError.data)
-      expectTypeOf<Error | null>(withError.error)
+      expectTypeOf(withError.data).toEqualTypeOf<string | undefined>()
+      expectTypeOf(withError.error).toEqualTypeOf<Error | null>()
 
       // it should provide the result type in the configuration
       createQuery(() => ({
@@ -82,14 +82,14 @@ describe('createQuery', () => {
       // it should be possible to specify a union type as result type
       const unionTypeSync = createQuery(() => ({
         queryKey: key,
-        queryFn: () => (Math.random() > 0.5 ? 'a' : 'b'),
+        queryFn: () => (Math.random() > 0.5 ? ('a' as const) : ('b' as const)),
       }))
-      expectTypeOf<'a' | 'b' | undefined>(unionTypeSync.data)
+      expectTypeOf(unionTypeSync.data).toEqualTypeOf<'a' | 'b' | undefined>()
       const unionTypeAsync = createQuery<'a' | 'b'>(() => ({
         queryKey: key,
         queryFn: () => Promise.resolve(Math.random() > 0.5 ? 'a' : 'b'),
       }))
-      expectTypeOf<'a' | 'b' | undefined>(unionTypeAsync.data)
+      expectTypeOf(unionTypeAsync.data).toEqualTypeOf<'a' | 'b' | undefined>()
 
       // should error when the query function result does not match with the specified type
       // @ts-expect-error
@@ -104,15 +104,19 @@ describe('createQuery', () => {
         queryKey: key,
         queryFn: () => queryFn(),
       }))
-      expectTypeOf<string | undefined>(fromGenericQueryFn.data)
-      expectTypeOf<unknown>(fromGenericQueryFn.error)
+      expectTypeOf(fromGenericQueryFn.data).toEqualTypeOf<string | undefined>()
+      expectTypeOf(fromGenericQueryFn.error).toEqualTypeOf<Error | null>()
 
       const fromGenericOptionsQueryFn = createQuery(() => ({
         queryKey: key,
         queryFn: () => queryFn(),
       }))
-      expectTypeOf<string | undefined>(fromGenericOptionsQueryFn.data)
-      expectTypeOf<unknown>(fromGenericOptionsQueryFn.error)
+      expectTypeOf(fromGenericOptionsQueryFn.data).toEqualTypeOf<
+        string | undefined
+      >()
+      expectTypeOf(
+        fromGenericOptionsQueryFn.error,
+      ).toEqualTypeOf<Error | null>()
 
       type MyData = number
       type MyQueryKey = readonly ['my-data', number]
@@ -131,7 +135,7 @@ describe('createQuery', () => {
       const getMyDataStringKey: QueryFunction<MyData, ['1']> = async (
         context,
       ) => {
-        expectTypeOf<['1']>(context.queryKey)
+        expectTypeOf(context.queryKey).toEqualTypeOf<['1']>()
         return Number(context.queryKey[0]) + 42
       }
 
@@ -170,7 +174,7 @@ describe('createQuery', () => {
           ...options,
         }))
       const test = useWrappedQuery([''], async () => '1')
-      expectTypeOf<string | undefined>(test.data)
+      expectTypeOf(test.data).toEqualTypeOf<string | undefined>()
 
       // handles wrapped queries with custom fetcher passed directly to createQuery
       const useWrappedFuncStyleQuery = <
@@ -187,7 +191,7 @@ describe('createQuery', () => {
         >,
       ) => createQuery(() => ({ queryKey: qk, queryFn: fetcher, ...options }))
       const testFuncStyle = useWrappedFuncStyleQuery([''], async () => true)
-      expectTypeOf<boolean | undefined>(testFuncStyle.data)
+      expectTypeOf(testFuncStyle.data).toEqualTypeOf<boolean | undefined>()
     }
   })
 
@@ -240,14 +244,14 @@ describe('createQuery', () => {
       })
 
       if (state.isPending) {
-        expectTypeOf<undefined>(state.data)
-        expectTypeOf<null>(state.error)
+        expectTypeOf(state.data).toEqualTypeOf<undefined>()
+        expectTypeOf(state.error).toEqualTypeOf<null>()
       } else if (state.isLoadingError) {
-        expectTypeOf<undefined>(state.data)
-        expectTypeOf<Error>(state.error)
+        expectTypeOf(state.data).toEqualTypeOf<undefined>()
+        expectTypeOf(state.error).toEqualTypeOf<Error>()
       } else {
-        expectTypeOf<string>(state.data)
-        expectTypeOf<Error | null>(state.error)
+        expectTypeOf(state.data).toEqualTypeOf<string>()
+        expectTypeOf(state.error).toEqualTypeOf<Error | null>()
       }
 
       return (

package/src/__tests__/useMutationState.test-d.tsx

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

package/src/__tests__/useMutationState.test.tsx

@@ -1,34 +1,12 @@
-import { describe, expect, expectTypeOf, it } from 'vitest'
+import { describe, expect, it } from 'vitest'
 import { fireEvent, render, waitFor } from '@solidjs/testing-library'
 import { createEffect } from 'solid-js'
 import { useMutationState } from '../useMutationState'
 import { createMutation } from '../createMutation'
 import { QueryClientProvider } from '../QueryClientProvider'
-import { createQueryClient, doNotExecute, sleep } from './utils'
-import type { MutationState, MutationStatus } from '@tanstack/query-core'
+import { createQueryClient, sleep } from './utils'
 
 describe('useMutationState', () => {
-  describe('types', () => {
-    it('should default to QueryState', () => {
-      doNotExecute(() => {
-        const result = useMutationState(() => ({
-          filters: { status: 'pending' },
-        }))
-
-        expectTypeOf<Array<MutationState>>(result())
-      })
-    })
-    it('should infer with select', () => {
-      doNotExecute(() => {
-        const result = useMutationState(() => ({
-          filters: { status: 'pending' },
-          select: (mutation) => mutation.state.status,
-        }))
-
-        expectTypeOf<Array<MutationStatus>>(result())
-      })
-    })
-  })
   it('should return variables after calling mutate', async () => {
     const queryClient = createQueryClient()
     const variables: Array<Array<unknown>> = []

package/src/__tests__/utils.tsx

@@ -59,12 +59,3 @@ export function setActTimeout(fn: () => void, ms?: number) {
     fn()
   }, ms)
 }
-
-/**
- * Assert the parameter is not typed as `any`
- */
-export function expectTypeNotAny<T>(_: 0 extends 1 & T ? never : T): void {
-  return undefined
-}
-
-export const doNotExecute = (_func: () => void) => true