Исследуй исходный код react-thunk. Расскажи о нём подробно. import type { Action, AnyAction, Middleware } from 'redux'

/**

The dispatch method as modified by React-Thunk; overloaded so that you can
dispatch:
standard (object) actions: dispatch() returns the action itself
thunk actions: dispatch() returns the thunk's return value
@template State The redux state
@template ExtraThunkArg The extra argument passed to the inner function of
thunks (if specified when setting up the Thunk middleware)
@template BasicAction The (non-thunk) actions that can be dispatched.
*/
export interface ThunkDispatch<
State,
ExtraThunkArg,
BasicAction extends Action,

{
// When the thunk middleware is added, store.dispatch now has three overloads (NOTE: the order here matters for correct behavior and is very fragile - do not reorder these!):

// 1) The specific thunk function overload
/** Accepts a thunk function, runs it, and returns whatever the thunk itself returns */
(
thunkAction: ThunkAction<ReturnType, State, ExtraThunkArg, BasicAction>,
): ReturnType

// 2) The base overload.
/** Accepts a standard action object, and returns that action object */
(action: Action): Action

// 3) A union of the other two overloads. This overload exists to work around a problem
// with TS inference ( see https://github.com/microsoft/TypeScript/issues/14107 )
/** A union of the other two overloads for TS inference purposes */
<ReturnType, Action extends BasicAction>(
action: Action | ThunkAction<ReturnType, State, ExtraThunkArg, BasicAction>,
): Action | ReturnType
}

/**

A "thunk" action (a callback function that can be dispatched to the Redux
store.)
Also known as the "thunk inner function", when used with the typical pattern
of an action creator function that returns a thunk action.
@template ReturnType The return type of the thunk's inner function
@template State The redux state
@template ExtraThunkArg Optional extra argument passed to the inner function
(if specified when setting up the Thunk middleware)
@template BasicAction The (non-thunk) actions that can be dispatched.
*/
export type ThunkAction<
ReturnType,
State,
ExtraThunkArg,
BasicAction extends Action,

= (
dispatch: ThunkDispatch<State, ExtraThunkArg, BasicAction>,
getState: () => State,
extraArgument: ExtraThunkArg,
) => ReturnType

/**

A generic type that takes a thunk action creator and returns a function
signature which matches how it would appear after being processed using
bindActionCreators(): a function that takes the arguments of the outer
function, and returns the return type of the inner "thunk" function.
@template ActionCreator Thunk action creator to be wrapped
*/
export type ThunkActionDispatch<
ActionCreator extends (...args: any[]) => ThunkAction<any, any, any, any>,

= (
...args: Parameters
) => ReturnType<ReturnType>

/**

@template State The redux state
@template BasicAction The (non-thunk) actions that can be dispatched
@template ExtraThunkArg An optional extra argument to pass to a thunk's
inner function. (Only used if you call withExtraArgument())
*/
export type ThunkMiddleware<
State = any,
BasicAction extends Action = AnyAction,
ExtraThunkArg = undefined,

= Middleware<
ThunkDispatch<State, ExtraThunkArg, BasicAction>,
State,
ThunkDispatch<State, ExtraThunkArg, BasicAction>
import type { Action, AnyAction } from 'redux'
import type { ThunkMiddleware } from './types'

export type {
ThunkAction,
ThunkActionDispatch,
ThunkDispatch,
ThunkMiddleware,
} from './types'

/** A function that accepts a potential "extra argument" value to be injected later,

and returns an instance of the thunk middleware that uses that value
*/
function createThunkMiddleware<
State = any,
BasicAction extends Action = AnyAction,
ExtraThunkArg = undefined,

(extraArgument?: ExtraThunkArg) {
// Standard Redux middleware definition pattern:
// See: https://redux.js.org/tutorials/fundamentals/part-4-store#writing-custom-middleware
const middleware: ThunkMiddleware<State, BasicAction, ExtraThunkArg> =
({ dispatch, getState }) =>
next =>
action => {
// The thunk middleware looks for any functions that were passed to store.dispatch.
// If this "action" is really a function, call it and return the result.
if (typeof action === 'function') {
// Inject the store's dispatch and getState methods, as well as any "extra arg"
return action(dispatch, getState, extraArgument)
}

// Otherwise, pass the action down the middleware chain as usual return next(action) }

return middleware
}

export const thunk = createThunkMiddleware()

// Export the factory function so users can create a customized version
// with whatever "extra arg" they want to inject into their thunks
export const withExtraArgument = createThunkMiddleware