Migrate type tests to Vitest

.gitignore

@@ -30,3 +30,5 @@ typesversions
 !.yarn/versions
 .pnp.*
 *.tgz
+
+tsconfig.vitest-temp.json

packages/toolkit/src/dynamicMiddleware/tests/index.test-d.ts

@@ -0,0 +1,95 @@
+import type { Action, Middleware, UnknownAction } from 'redux'
+import type { ThunkDispatch } from 'redux-thunk'
+import { configureStore } from '../../configureStore'
+import { createDynamicMiddleware } from '../index'
+
+const untypedInstance = createDynamicMiddleware()
+
+interface AppDispatch extends ThunkDispatch<number, undefined, UnknownAction> {
+  (n: 1): 1
+}
+
+const typedInstance = createDynamicMiddleware<number, AppDispatch>()
+
+declare const staticMiddleware: Middleware<(n: 1) => 1>
+
+const store = configureStore({
+  reducer: () => 0,
+  middleware: (gDM) =>
+    gDM().prepend(typedInstance.middleware).concat(staticMiddleware),
+})
+
+declare const compatibleMiddleware: Middleware<{}, number, AppDispatch>
+declare const incompatibleMiddleware: Middleware<{}, string, AppDispatch>
+
+declare const addedMiddleware: Middleware<(n: 2) => 2>
+
+describe('type tests', () => {
+  test('instance typed at creation ensures middleware compatibility with store', () => {
+    const store = configureStore({
+      reducer: () => '',
+      // @ts-expect-error
+      middleware: (gDM) => gDM().prepend(typedInstance.middleware),
+    })
+  })
+
+  test('instance typed at creation enforces correct middleware type', () => {
+    typedInstance.addMiddleware(
+      compatibleMiddleware,
+      // @ts-expect-error
+      incompatibleMiddleware
+    )
+
+    const dispatch = store.dispatch(
+      typedInstance.withMiddleware(
+        compatibleMiddleware,
+        // @ts-expect-error
+        incompatibleMiddleware
+      )
+    )
+  })
+
+  test('withTypes() enforces correct middleware type', () => {
+    const addMiddleware = untypedInstance.addMiddleware.withTypes<{
+      state: number
+      dispatch: AppDispatch
+    }>()
+
+    addMiddleware(
+      compatibleMiddleware,
+      // @ts-expect-error
+      incompatibleMiddleware
+    )
+
+    const withMiddleware = untypedInstance.withMiddleware.withTypes<{
+      state: number
+      dispatch: AppDispatch
+    }>()
+
+    const dispatch = store.dispatch(
+      withMiddleware(
+        compatibleMiddleware,
+        // @ts-expect-error
+        incompatibleMiddleware
+      )
+    )
+  })
+
+  test('withMiddleware returns typed dispatch, with any applicable extensions', () => {
+    const dispatch = store.dispatch(
+      typedInstance.withMiddleware(addedMiddleware)
+    )
+
+    // standard
+    expectTypeOf(dispatch({ type: 'foo' })).toEqualTypeOf<Action<string>>()
+
+    // thunk
+    expectTypeOf(dispatch(() => 'foo')).toBeString()
+
+    // static
+    expectTypeOf(dispatch(1)).toEqualTypeOf<1>()
+
+    // added
+    expectTypeOf(dispatch(2)).toEqualTypeOf<2>()
+  })
+})

packages/toolkit/src/dynamicMiddleware/tests/react.test-d.ts

@@ -0,0 +1,81 @@
+import type { Context } from 'react'
+import type { ReactReduxContextValue } from 'react-redux'
+import type { Action, Middleware, UnknownAction } from 'redux'
+import type { ThunkDispatch } from 'redux-thunk'
+import { createDynamicMiddleware } from '../react'
+
+interface AppDispatch extends ThunkDispatch<number, undefined, UnknownAction> {
+  (n: 1): 1
+}
+
+const untypedInstance = createDynamicMiddleware()
+
+const typedInstance = createDynamicMiddleware<number, AppDispatch>()
+
+declare const compatibleMiddleware: Middleware<{}, number, AppDispatch>
+declare const incompatibleMiddleware: Middleware<{}, string, AppDispatch>
+
+declare const customContext: Context<ReactReduxContextValue>
+
+declare const addedMiddleware: Middleware<(n: 2) => 2>
+
+describe('type tests', () => {
+  test('instance typed at creation enforces correct middleware type', () => {
+    const useDispatch = typedInstance.createDispatchWithMiddlewareHook(
+      compatibleMiddleware,
+      // @ts-expect-error
+      incompatibleMiddleware
+    )
+
+    const createDispatchWithMiddlewareHook =
+      typedInstance.createDispatchWithMiddlewareHookFactory(customContext)
+    const useDispatchWithContext = createDispatchWithMiddlewareHook(
+      compatibleMiddleware,
+      // @ts-expect-error
+      incompatibleMiddleware
+    )
+  })
+
+  test('withTypes() enforces correct middleware type', () => {
+    const createDispatchWithMiddlewareHook =
+      untypedInstance.createDispatchWithMiddlewareHook.withTypes<{
+        state: number
+        dispatch: AppDispatch
+      }>()
+    const useDispatch = createDispatchWithMiddlewareHook(
+      compatibleMiddleware,
+      // @ts-expect-error
+      incompatibleMiddleware
+    )
+
+    const createCustomDispatchWithMiddlewareHook = untypedInstance
+      .createDispatchWithMiddlewareHookFactory(customContext)
+      .withTypes<{
+        state: number
+        dispatch: AppDispatch
+      }>()
+    const useCustomDispatch = createCustomDispatchWithMiddlewareHook(
+      compatibleMiddleware,
+      // @ts-expect-error
+      incompatibleMiddleware
+    )
+  })
+
+  test('useDispatchWithMW returns typed dispatch, with any applicable extensions', () => {
+    const useDispatchWithMW =
+      typedInstance.createDispatchWithMiddlewareHook(addedMiddleware)
+    const dispatch = useDispatchWithMW()
+
+    // standard
+    expectTypeOf(dispatch({ type: 'foo' })).toEqualTypeOf<Action<string>>()
+
+    // thunk
+    expectTypeOf(dispatch(() => 'foo')).toBeString()
+
+    // static
+    expectTypeOf(dispatch(1)).toEqualTypeOf<1>()
+
+    // added
+    expectTypeOf(dispatch(2)).toEqualTypeOf<2>()
+  })
+})