Replace all Function references with AnyFunction

Author: aryaemami59

docs/api/actionCreatorMiddleware.mdx

@@ -54,7 +54,7 @@ import reducer from './reducer'
 // Augment middleware to consider all functions with a static type property to be action creators
 const isActionCreator = (
   action: unknown,
-): action is Function & { type: unknown } =>
+): action is (...args: any) => any & { type: unknown } =>
   typeof action === 'function' && 'type' in action
 
 const actionCreatorMiddleware = createActionCreatorInvariantMiddleware({

packages/toolkit/src/actionCreatorInvariantMiddleware.ts

@@ -1,20 +1,23 @@
 import type { Middleware } from 'redux'
 import { isActionCreator as isRTKAction } from './createAction'
+import type { AnyFunction } from './tsHelpers'
 
 export interface ActionCreatorInvariantMiddlewareOptions {
   /**
    * The function to identify whether a value is an action creator.
    * The default checks for a function with a static type property and match method.
    */
-  isActionCreator?: (action: unknown) => action is Function & { type?: unknown }
+  isActionCreator?: (
+    action: unknown,
+  ) => action is AnyFunction & { type?: unknown }
 }
 
 export function getMessage(type?: unknown) {
   const splitType = type ? `${type}`.split('/') : []
   const actionName = splitType[splitType.length - 1] || 'actionCreator'
   return `Detected an action creator with type "${
     type || 'unknown'
-  }" being dispatched. 
+  }" being dispatched.
 Make sure you're calling the action creator before dispatching, i.e. \`dispatch(${actionName}())\` instead of \`dispatch(${actionName})\`. This is necessary even if the action has no payload.`
 }
 

packages/toolkit/src/createAction.ts

@@ -1,9 +1,10 @@
 import { isAction } from 'redux'
 import type {
-  IsUnknownOrNonInferrable,
+  AnyFunction,
   IfMaybeUndefined,
   IfVoid,
   IsAny,
+  IsUnknownOrNonInferrable,
 } from './tsHelpers'
 import { hasMatchFunction } from './tsHelpers'
 
@@ -257,7 +258,7 @@ export function createAction<
   prepareAction: PA,
 ): PayloadActionCreator<ReturnType<PA>['payload'], T, PA>
 
-export function createAction(type: string, prepareAction?: Function): any {
+export function createAction(type: string, prepareAction?: AnyFunction): any {
   function actionCreator(...args: any[]) {
     if (prepareAction) {
       const prepared = prepareAction(...args)
@@ -290,7 +291,7 @@ export function createAction(type: string, prepareAction?: Function): any {
  */
 export function isActionCreator(
   action: unknown,
-): action is BaseActionCreator<unknown, string> & Function {
+): action is BaseActionCreator<unknown, string> & AnyFunction {
   return (
     typeof action === 'function' &&
     'type' in action &&

packages/toolkit/src/createReducer.ts

@@ -3,7 +3,7 @@ import { produce as createNextState, isDraft, isDraftable } from 'immer'
 import type { Action, Reducer, UnknownAction } from 'redux'
 import type { ActionReducerMapBuilder } from './mapBuilders'
 import { executeReducerBuilderCallback } from './mapBuilders'
-import type { NoInfer, TypeGuard } from './tsHelpers'
+import type { AnyFunction, NoInfer, TypeGuard } from './tsHelpers'
 import { freezeDraftable } from './utils'
 
 /**
@@ -63,7 +63,7 @@ export type CaseReducers<S, AS extends Actions> = {
   [T in keyof AS]: AS[T] extends Action ? CaseReducer<S, AS[T]> : void
 }
 
-export type NotFunction<T> = T extends Function ? never : T
+export type NotFunction<T> = T extends AnyFunction ? never : T
 
 function isStateFunction<S>(x: unknown): x is () => S {
   return typeof x === 'function'

packages/toolkit/src/createSlice.ts

@@ -25,7 +25,7 @@ import type {
 import { createReducer } from './createReducer'
 import type { ActionReducerMapBuilder, TypedActionCreator } from './mapBuilders'
 import { executeReducerBuilderCallback } from './mapBuilders'
-import type { Id, TypeGuard } from './tsHelpers'
+import type { AnyFunction, Id, TypeGuard } from './tsHelpers'
 import { getOrInsertComputed } from './utils'
 
 const asyncThunkSymbol = /* @__PURE__ */ Symbol.for(
@@ -864,7 +864,7 @@ interface ReducerHandlingContext<State> {
   >
   sliceCaseReducersByType: Record<string, CaseReducer<State, any>>
   sliceMatchers: ActionMatcherDescriptionCollection<State>
-  actionCreators: Record<string, Function>
+  actionCreators: Record<string, AnyFunction>
 }
 
 interface ReducerHandlingContextMethods<State> {
@@ -915,7 +915,7 @@ interface ReducerHandlingContextMethods<State> {
    */
   exposeAction(
     name: string,
-    actionCreator: Function,
+    actionCreator: AnyFunction,
   ): ReducerHandlingContextMethods<State>
   /**
    * Add a case reducer to be exposed under the final `slice.caseReducers` key.

packages/toolkit/src/devtoolsExtension.ts

@@ -1,5 +1,6 @@
 import type { Action, ActionCreator, StoreEnhancer } from 'redux'
 import { compose } from 'redux'
+import type { AnyFunction } from './tsHelpers'
 
 /**
  * @public
@@ -223,7 +224,7 @@ export const composeWithDevTools: ComposeWithDevTools =
     : function () {
         if (arguments.length === 0) return undefined
         if (typeof arguments[0] === 'object') return compose
-        return compose.apply(null, arguments as any as Function[])
+        return compose.apply(null, arguments as any as AnyFunction[])
       }
 
 /**

packages/toolkit/src/query/endpointDefinitions.ts

@@ -1,4 +1,5 @@
 import type { Api } from '@reduxjs/toolkit/query'
+import type { AnyFunction } from '../tsHelpers'
 import type {
   BaseQueryApi,
   BaseQueryArg,
@@ -1039,7 +1040,7 @@ export function calculateProvidedBy<ResultType, QueryArg, ErrorType, MetaType>(
   return []
 }
 
-function isFunction<T>(t: T): t is Extract<T, Function> {
+function isFunction<T>(t: T): t is Extract<T, AnyFunction> {
   return typeof t === 'function'
 }
 

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

@@ -1,8 +1,11 @@
 import type { ActionCreatorInvariantMiddlewareOptions } from '@internal/actionCreatorInvariantMiddleware'
-import { getMessage } from '@internal/actionCreatorInvariantMiddleware'
-import { createActionCreatorInvariantMiddleware } from '@internal/actionCreatorInvariantMiddleware'
+import {
+  createActionCreatorInvariantMiddleware,
+  getMessage,
+} from '@internal/actionCreatorInvariantMiddleware'
 import type { MiddlewareAPI } from '@reduxjs/toolkit'
 import { createAction } from '@reduxjs/toolkit'
+import type { AnyFunction } from '../tsHelpers'
 
 describe('createActionCreatorInvariantMiddleware', () => {
   const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
@@ -50,7 +53,7 @@ describe('createActionCreatorInvariantMiddleware', () => {
   it('allows passing a custom predicate', () => {
     let predicateCalled = false
     const testAction = makeActionTester({
-      isActionCreator(action): action is Function {
+      isActionCreator(action): action is AnyFunction {
         predicateCalled = true
         return false
       },

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

@@ -1,3 +1,4 @@
+import type { AsyncThunkDispatchConfig } from '@internal/createAsyncThunk'
 import type { TSVersion } from '@phryneas/ts-version'
 import type {
   AsyncThunk,
@@ -14,9 +15,11 @@ import {
 } from '@reduxjs/toolkit'
 import type { AxiosError } from 'axios'
 import apiRequest from 'axios'
-import type { AsyncThunkDispatchConfig } from '@internal/createAsyncThunk'
+import type { AnyFunction, AnyNonNullishValue } from '../tsHelpers'
 
-const defaultDispatch = (() => {}) as ThunkDispatch<{}, any, UnknownAction>
+const defaultDispatch = (() => {
+  /* No-Op */
+}) as ThunkDispatch<AnyNonNullishValue, any, UnknownAction>
 const unknownAction = { type: 'foo' } as UnknownAction
 
 describe('type tests', () => {
@@ -96,19 +99,17 @@ describe('type tests', () => {
       { id: 'a', title: 'First' },
     ]
 
-    const correctDispatch = (() => {}) as ThunkDispatch<
-      BookModel[],
-      { userAPI: Function },
-      UnknownAction
-    >
+    const correctDispatch = (() => {
+      /* No-Op */
+    }) as ThunkDispatch<BookModel[], { userAPI: AnyFunction }, UnknownAction>
 
     // Verify that the the first type args to createAsyncThunk line up right
     const fetchBooksTAC = createAsyncThunk<
       BookModel[],
       number,
       {
         state: BooksState
-        extra: { userAPI: Function }
+        extra: { userAPI: AnyFunction }
       }
     >(
       'books/fetch',
@@ -119,7 +120,7 @@ describe('type tests', () => {
 
         expectTypeOf(state).toEqualTypeOf<BookModel[]>()
 
-        expectTypeOf(extra).toEqualTypeOf<{ userAPI: Function }>()
+        expectTypeOf(extra).toEqualTypeOf<{ userAPI: AnyFunction }>()
 
         return fakeBooks
       },
@@ -160,7 +161,7 @@ describe('type tests', () => {
 
   test('regression #1156: union return values fall back to allowing only single member', () => {
     const fn = createAsyncThunk('session/isAdmin', async () => {
-      const response: boolean = false
+      const response = false
       return response
     })
   })
@@ -493,15 +494,19 @@ describe('type tests', () => {
       return 'ret' as const
     })
 
-    expectTypeOf(thunk).toEqualTypeOf<AsyncThunk<'ret', void, {}>>()
+    expectTypeOf(thunk).toEqualTypeOf<
+      AsyncThunk<'ret', void, AnyNonNullishValue>
+    >()
   })
 
   test('createAsyncThunk without generics, accessing `api` does not break return type', () => {
     const thunk = createAsyncThunk('test', (_: void, api) => {
       return 'ret' as const
     })
 
-    expectTypeOf(thunk).toEqualTypeOf<AsyncThunk<'ret', void, {}>>()
+    expectTypeOf(thunk).toEqualTypeOf<
+      AsyncThunk<'ret', void, AnyNonNullishValue>
+    >()
   })
 
   test('createAsyncThunk rejectWithValue without generics: Expect correct return type', () => {
@@ -551,17 +556,26 @@ describe('type tests', () => {
     }
 
     // has to stay on one line or type tests fail in older TS versions
-    // prettier-ignore
-    // @ts-expect-error
-    const shouldFail = createAsyncThunk('without generics', () => {}, { serializeError: funkySerializeError })
+    const shouldFail = createAsyncThunk(
+      'without generics',
+      () => {
+        /* No-Op */
+      },
+      // @ts-expect-error
+      { serializeError: funkySerializeError },
+    )
 
     const shouldWork = createAsyncThunk<
       any,
       void,
       { serializedErrorType: Funky }
-    >('with generics', () => {}, {
-      serializeError: funkySerializeError,
-    })
+    >(
+      'with generics',
+      () => {
+        /* No-Op */
+      },
+      { serializeError: funkySerializeError },
+    )
 
     if (shouldWork.rejected.match(unknownAction)) {
       expectTypeOf(unknownAction.error).toEqualTypeOf<Funky>()
@@ -571,33 +585,54 @@ describe('type tests', () => {
   test('`idGenerator` option takes no arguments, and returns a string', () => {
     const returnsNumWithArgs = (foo: any) => 100
     // has to stay on one line or type tests fail in older TS versions
-    // prettier-ignore
-    // @ts-expect-error
-    const shouldFailNumWithArgs = createAsyncThunk('foo', () => {}, { idGenerator: returnsNumWithArgs })
+    const shouldFailNumWithArgs = createAsyncThunk(
+      'foo',
+      () => {
+        /* No-Op */
+      },
+      // @ts-expect-error
+      { idGenerator: returnsNumWithArgs },
+    )
 
     const returnsNumWithoutArgs = () => 100
-    // prettier-ignore
-    // @ts-expect-error
-    const shouldFailNumWithoutArgs = createAsyncThunk('foo', () => {}, { idGenerator: returnsNumWithoutArgs })
+    const shouldFailNumWithoutArgs = createAsyncThunk(
+      'foo',
+      () => {
+        /* No-Op */
+      },
+      // @ts-expect-error
+      { idGenerator: returnsNumWithoutArgs },
+    )
 
     const returnsStrWithNumberArg = (foo: number) => 'foo'
-    // prettier-ignore
-    // @ts-expect-error
-    const shouldFailWrongArgs = createAsyncThunk('foo', (arg: string) => {}, { idGenerator: returnsStrWithNumberArg })
+    const shouldFailWrongArgs = createAsyncThunk(
+      'foo',
+      (arg: string) => {
+        /* No-Op */
+      },
+      // @ts-expect-error
+      { idGenerator: returnsStrWithNumberArg },
+    )
 
     const returnsStrWithStringArg = (foo: string) => 'foo'
     const shoulducceedCorrectArgs = createAsyncThunk(
       'foo',
-      (arg: string) => {},
+      (arg: string) => {
+        /* No-Op */
+      },
       {
         idGenerator: returnsStrWithStringArg,
       },
     )
 
     const returnsStrWithoutArgs = () => 'foo'
-    const shouldSucceed = createAsyncThunk('foo', () => {}, {
-      idGenerator: returnsStrWithoutArgs,
-    })
+    const shouldSucceed = createAsyncThunk(
+      'foo',
+      () => {
+        /* No-Op */
+      },
+      { idGenerator: returnsStrWithoutArgs },
+    )
   })
 
   test('fulfillWithValue should infer return value', () => {
@@ -633,8 +668,14 @@ describe('type tests', () => {
 
   test('meta return values', () => {
     // return values
-    createAsyncThunk<'ret', void, {}>('test', (_, api) => 'ret' as const)
-    createAsyncThunk<'ret', void, {}>('test', async (_, api) => 'ret' as const)
+    createAsyncThunk<'ret', void, AnyNonNullishValue>(
+      'test',
+      (_, api) => 'ret' as const,
+    )
+    createAsyncThunk<'ret', void, AnyNonNullishValue>(
+      'test',
+      async (_, api) => 'ret' as const,
+    )
     createAsyncThunk<'ret', void, { fulfilledMeta: string }>('test', (_, api) =>
       api.fulfillWithValue('ret' as const, ''),
     )

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

@@ -10,6 +10,7 @@ import { thunk } from 'redux-thunk'
 import { vi } from 'vitest'
 
 import { buildGetDefaultMiddleware } from '@internal/getDefaultMiddleware'
+import type { AnyFunction } from '../tsHelpers'
 
 const getDefaultMiddleware = buildGetDefaultMiddleware()
 
@@ -180,7 +181,7 @@ it('allows passing options to actionCreatorCheck', () => {
       immutableCheck: false,
       serializableCheck: false,
       actionCreatorCheck: {
-        isActionCreator: (action: unknown): action is Function => {
+        isActionCreator: (action: unknown): action is AnyFunction => {
           actionCreatorCheckWasCalled = true
           return false
         },