Fix issues related to the @typescript-eslint/prefer-function-type rule

Author: aryaemami59

packages/toolkit/src/devtoolsExtension.ts

@@ -14,7 +14,7 @@ export interface DevToolsEnhancerOptions {
   /**
    * action creators functions to be available in the Dispatcher.
    */
-  actionCreators?: ActionCreator<any>[] | { [key: string]: ActionCreator<any> }
+  actionCreators?: ActionCreator<any>[] | Record<string, ActionCreator<any>>
   /**
    * if more than one action is dispatched in the indicated interval, all new actions will be collected and sent at once.
    * It is the joint between performance and speed. When set to `0`, all actions will be sent instantly.
@@ -232,9 +232,9 @@ export const composeWithDevTools: ComposeWithDevTools =
 /**
  * @public
  */
-export const devToolsEnhancer: {
-  (options: DevToolsEnhancerOptions): StoreEnhancer<any>
-} =
+export const devToolsEnhancer: (
+  options: DevToolsEnhancerOptions,
+) => StoreEnhancer<any> =
   typeof window !== 'undefined' && (window as any).__REDUX_DEVTOOLS_EXTENSION__
     ? (window as any).__REDUX_DEVTOOLS_EXTENSION__
     : function () {

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

@@ -1,9 +1,9 @@
 import type { Middleware } from 'redux'
-import { createDynamicMiddleware } from '../index'
 import { configureStore } from '../../configureStore'
 import type { BaseActionCreator, PayloadAction } from '../../createAction'
 import { createAction } from '../../createAction'
 import { isAllOf } from '../../matchers'
+import { createDynamicMiddleware } from '../index'
 
 const probeType = 'probeableMW/probe'
 
@@ -21,9 +21,7 @@ const matchId =
 
 export const makeProbeableMiddleware = <Id extends number>(
   id: Id,
-): Middleware<{
-  (action: PayloadAction<Id, typeof probeType>): Id
-}> => {
+): Middleware<(action: PayloadAction<Id, typeof probeType>) => Id> => {
   const isMiddlewareAction = isAllOf(probeMiddleware, matchId(id))
   return (api) => (next) => (action) => {
     if (isMiddlewareAction(action)) {

packages/toolkit/src/dynamicMiddleware/types.ts

@@ -52,6 +52,7 @@ export interface DynamicDispatch {
   // return a version of dispatch that knows about middleware
   <Middlewares extends Middleware<any>[]>(
     action: PayloadAction<Middlewares, 'dynamicMiddleware/add'>,
+    // eslint-disable-next-line @typescript-eslint/prefer-function-type
   ): ExtractDispatchExtensions<Middlewares> & this
 }
 

packages/toolkit/src/listenerMiddleware/types.ts

@@ -72,14 +72,10 @@ export interface ForkedTaskAPI {
 }
 
 /** @public */
-export interface AsyncTaskExecutor<T> {
-  (forkApi: ForkedTaskAPI): Promise<T>
-}
+export type AsyncTaskExecutor<T> = (forkApi: ForkedTaskAPI) => Promise<T>
 
 /** @public */
-export interface SyncTaskExecutor<T> {
-  (forkApi: ForkedTaskAPI): T
-}
+export type SyncTaskExecutor<T> = (forkApi: ForkedTaskAPI) => T
 
 /** @public */
 export type ForkedTaskExecutor<T> = AsyncTaskExecutor<T> | SyncTaskExecutor<T>
@@ -295,9 +291,10 @@ export interface ListenerErrorInfo {
  * @param error The thrown error.
  * @param errorInfo Additional information regarding the thrown error.
  */
-export interface ListenerErrorHandler {
-  (error: unknown, errorInfo: ListenerErrorInfo): void
-}
+export type ListenerErrorHandler = (
+  error: unknown,
+  errorInfo: ListenerErrorInfo,
+) => void
 
 /** @public */
 export interface CreateListenerMiddlewareOptions<ExtraArgument = unknown> {
@@ -318,9 +315,7 @@ export type ListenerMiddleware<
   >,
   ExtraArgument = unknown,
 > = Middleware<
-  {
-    (action: Action<'listenerMiddleware/add'>): UnsubscribeListener
-  },
+  (action: Action<'listenerMiddleware/add'>) => UnsubscribeListener,
   State,
   DispatchType
 >

packages/toolkit/src/query/core/buildMiddleware/types.ts

@@ -89,7 +89,7 @@ export type InternalHandlerBuilder<ReturnType = void> = (
   input: BuildSubMiddlewareInput,
 ) => ApiMiddlewareInternalHandler<ReturnType>
 
-export interface PromiseConstructorWithKnownReason {
+export type PromiseConstructorWithKnownReason =
   /**
    * Creates a new Promise with a known rejection reason.
    * @param executor A callback used to initialize the promise. This callback is passed two arguments:
@@ -101,8 +101,7 @@ export interface PromiseConstructorWithKnownReason {
       resolve: (value: T | PromiseLike<T>) => void,
       reject: (reason?: R) => void,
     ) => void,
-  ): PromiseWithKnownReason<T, R>
-}
+  ) => PromiseWithKnownReason<T, R>
 
 export type PromiseWithKnownReason<T, R> = Omit<
   Promise<T>,

packages/toolkit/src/query/createApi.ts

@@ -210,7 +210,7 @@ export interface CreateApiOptions<
       >
 }
 
-export type CreateApi<Modules extends ModuleName> = {
+export type CreateApi<Modules extends ModuleName> =
   /**
    * Creates a service to use in your application. Contains only the basic redux logic (the core module).
    *
@@ -223,8 +223,7 @@ export type CreateApi<Modules extends ModuleName> = {
     TagTypes extends string = never,
   >(
     options: CreateApiOptions<BaseQuery, Definitions, ReducerPath, TagTypes>,
-  ): Api<BaseQuery, Definitions, ReducerPath, TagTypes, Modules>
-}
+  ) => Api<BaseQuery, Definitions, ReducerPath, TagTypes, Modules>
 
 /**
  * Builds a `createApi` method based on the provided `modules`.

packages/toolkit/src/query/react/buildHooks.ts

@@ -267,7 +267,7 @@ export type TypedUseLazyQuery<
   QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>
 >
 
-export type LazyQueryTrigger<D extends QueryDefinition<any, any, any, any>> = {
+export type LazyQueryTrigger<D extends QueryDefinition<any, any, any, any>> =
   /**
    * Triggers a lazy query.
    *
@@ -291,8 +291,7 @@ export type LazyQueryTrigger<D extends QueryDefinition<any, any, any, any>> = {
   (
     arg: QueryArgFrom<D>,
     preferCacheValue?: boolean,
-  ): QueryActionCreatorResult<D>
-}
+  ) => QueryActionCreatorResult<D>
 
 export type TypedLazyQueryTrigger<
   ResultType,
@@ -583,25 +582,23 @@ export type TypedUseMutation<
 >
 
 export type MutationTrigger<D extends MutationDefinition<any, any, any, any>> =
-  {
-    /**
-     * Triggers the mutation and returns a Promise.
-     * @remarks
-     * If you need to access the error or success payload immediately after a mutation, you can chain .unwrap().
-     *
-     * @example
-     * ```ts
-     * // codeblock-meta title="Using .unwrap with async await"
-     * try {
-     *   const payload = await addPost({ id: 1, name: 'Example' }).unwrap();
-     *   console.log('fulfilled', payload)
-     * } catch (error) {
-     *   console.error('rejected', error);
-     * }
-     * ```
-     */
-    (arg: QueryArgFrom<D>): MutationActionCreatorResult<D>
-  }
+  /**
+   * Triggers the mutation and returns a Promise.
+   * @remarks
+   * If you need to access the error or success payload immediately after a mutation, you can chain .unwrap().
+   *
+   * @example
+   * ```ts
+   * // codeblock-meta title="Using .unwrap with async await"
+   * try {
+   *   const payload = await addPost({ id: 1, name: 'Example' }).unwrap();
+   *   console.log('fulfilled', payload)
+   * } catch (error) {
+   *   console.error('rejected', error);
+   * }
+   * ```
+   */
+  (arg: QueryArgFrom<D>) => MutationActionCreatorResult<D>
 
 export type TypedMutationTrigger<
   ResultType,

packages/toolkit/src/tests/configureStore.test-d.ts

@@ -777,9 +777,7 @@ describe('type tests', () => {
     // A fake middleware that tells TS that an unsubscribe callback is being returned for a given action
     // This is the same signature that the "listener" middleware uses
     const dummyMiddleware: Middleware<
-      {
-        (action: Action<'actionListenerMiddleware/add'>): Unsubscribe
-      },
+      (action: Action<'actionListenerMiddleware/add'>) => Unsubscribe,
       CounterState
     > = (storeApi) => (next) => (action) => {}
 

packages/toolkit/src/tests/getDefaultMiddleware.test-d.ts

@@ -11,13 +11,9 @@ import type {
 } from '@reduxjs/toolkit'
 import { configureStore } from '@reduxjs/toolkit'
 
-declare const middleware1: Middleware<{
-  (_: string): number
-}>
+declare const middleware1: Middleware<(_: string) => number>
 
-declare const middleware2: Middleware<{
-  (_: number): string
-}>
+declare const middleware2: Middleware<(_: number) => string>
 
 type ThunkReturn = Promise<'thunk'>
 declare const thunkCreator: () => () => ThunkReturn
@@ -136,9 +132,7 @@ describe('type tests', () => {
     expectTypeOf(m2).toMatchTypeOf<Tuple<[]>>()
 
     const dummyMiddleware: Middleware<
-      {
-        (action: Action<'actionListenerMiddleware/add'>): () => void
-      },
+      (action: Action<'actionListenerMiddleware/add'>) => () => void,
       { counter: number }
     > = (storeApi) => (next) => (action) => {
       return next(action)

packages/toolkit/src/tests/getDefaultMiddleware.test.ts

@@ -1,3 +1,4 @@
+import { buildGetDefaultMiddleware } from '@internal/getDefaultMiddleware'
 import { Tuple } from '@internal/utils'
 import type {
   Action,
@@ -7,9 +8,6 @@ import type {
 } from '@reduxjs/toolkit'
 import { configureStore } from '@reduxjs/toolkit'
 import { thunk } from 'redux-thunk'
-import { vi } from 'vitest'
-
-import { buildGetDefaultMiddleware } from '@internal/getDefaultMiddleware'
 import type { AnyFunction, AnyNonNullishValue } from '../tsHelpers'
 
 const getDefaultMiddleware = buildGetDefaultMiddleware()
@@ -77,9 +75,7 @@ describe('getDefaultMiddleware', () => {
     })
 
     const dummyMiddleware: Middleware<
-      {
-        (action: Action<'actionListenerMiddleware/add'>): () => void
-      },
+      (action: Action<'actionListenerMiddleware/add'>) => () => void,
       { counter: number }
     > = (storeApi) => (next) => (action) => {
       return next(action)