Fix issue with renaming type imports

- It seems like `tsup` can't handle `import type { Dispatch as ReduxDispatch }`, so we'll remove them.

Author: aryaemami59

packages/toolkit/src/dynamicMiddleware/index.ts

@@ -1,27 +1,29 @@
-import type {
-  Middleware,
-  Dispatch as ReduxDispatch,
-  UnknownAction,
-} from 'redux'
+import type { Dispatch, Middleware, UnknownAction } from 'redux'
 import { compose } from 'redux'
 import { createAction } from '../createAction'
 import { isAllOf } from '../matchers'
 import { nanoid } from '../nanoid'
 import { emplace, find } from '../utils'
 import type {
-  WithMiddleware,
   AddMiddleware,
-  MiddlewareEntry,
   DynamicMiddleware,
   DynamicMiddlewareInstance,
+  MiddlewareEntry,
+  WithMiddleware,
+} from './types'
+export type {
+  DynamicMiddlewareInstance,
+  GetDispatch,
+  GetState,
+  MiddlewareApiConfig,
 } from './types'
 
 const createMiddlewareEntry = <
   State = any,
-  Dispatch extends ReduxDispatch<UnknownAction> = ReduxDispatch<UnknownAction>,
+  DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>,
 >(
-  middleware: Middleware<any, State, Dispatch>,
-): MiddlewareEntry<State, Dispatch> => ({
+  middleware: Middleware<any, State, DispatchType>,
+): MiddlewareEntry<State, DispatchType> => ({
   id: nanoid(),
   middleware,
   applied: new Map(),
@@ -34,26 +36,28 @@ const matchInstance =
 
 export const createDynamicMiddleware = <
   State = any,
-  Dispatch extends ReduxDispatch<UnknownAction> = ReduxDispatch<UnknownAction>,
->(): DynamicMiddlewareInstance<State, Dispatch> => {
+  DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>,
+>(): DynamicMiddlewareInstance<State, DispatchType> => {
   const instanceId = nanoid()
-  const middlewareMap = new Map<string, MiddlewareEntry<State, Dispatch>>()
+  const middlewareMap = new Map<string, MiddlewareEntry<State, DispatchType>>()
 
   const withMiddleware = Object.assign(
     createAction(
       'dynamicMiddleware/add',
-      (...middlewares: Middleware<any, State, Dispatch>[]) => ({
+      (...middlewares: Middleware<any, State, DispatchType>[]) => ({
         payload: middlewares,
         meta: {
           instanceId,
         },
       }),
     ),
     { withTypes: () => withMiddleware },
-  ) as WithMiddleware<State, Dispatch>
+  ) as WithMiddleware<State, DispatchType>
 
   const addMiddleware = Object.assign(
-    function addMiddleware(...middlewares: Middleware<any, State, Dispatch>[]) {
+    function addMiddleware(
+      ...middlewares: Middleware<any, State, DispatchType>[]
+    ) {
       middlewares.forEach((middleware) => {
         let entry = find(
           Array.from(middlewareMap.values()),
@@ -66,9 +70,9 @@ export const createDynamicMiddleware = <
       })
     },
     { withTypes: () => addMiddleware },
-  ) as AddMiddleware<State, Dispatch>
+  ) as AddMiddleware<State, DispatchType>
 
-  const getFinalMiddleware: Middleware<{}, State, Dispatch> = (api) => {
+  const getFinalMiddleware: Middleware<{}, State, DispatchType> = (api) => {
     const appliedMiddleware = Array.from(middlewareMap.values()).map((entry) =>
       emplace(entry.applied, api, { insert: () => entry.middleware(api) }),
     )
@@ -77,7 +81,7 @@ export const createDynamicMiddleware = <
 
   const isWithMiddleware = isAllOf(withMiddleware, matchInstance(instanceId))
 
-  const middleware: DynamicMiddleware<State, Dispatch> =
+  const middleware: DynamicMiddleware<State, DispatchType> =
     (api) => (next) => (action) => {
       if (isWithMiddleware(action)) {
         addMiddleware(...action.payload)

packages/toolkit/src/dynamicMiddleware/react/index.ts

@@ -1,43 +1,38 @@
 import type {
-  Action as ReduxAction,
-  UnknownAction,
-  Dispatch as ReduxDispatch,
-  Middleware,
-} from 'redux'
-import type { TSHelpersExtractDispatchExtensions } from '@reduxjs/toolkit'
+  DynamicMiddlewareInstance,
+  GetDispatch,
+  GetState,
+  MiddlewareApiConfig,
+  TSHelpersExtractDispatchExtensions,
+} from '@reduxjs/toolkit'
 import { createDynamicMiddleware as cDM } from '@reduxjs/toolkit'
+import type { Context } from 'react'
 import type { ReactReduxContextValue } from 'react-redux'
 import {
+  createDispatchHook,
   ReactReduxContext,
   useDispatch as useDefaultDispatch,
-  createDispatchHook,
 } from 'react-redux'
-import type { Context } from 'react'
-import type {
-  DynamicMiddlewareInstance,
-  GetDispatch,
-  GetState,
-  MiddlewareApiConfig,
-} from '@reduxjs/toolkit'
+import type { Action, Dispatch, Middleware, UnknownAction } from 'redux'
 
 export type UseDispatchWithMiddlewareHook<
-  Middlewares extends Middleware<any, State, Dispatch>[] = [],
+  Middlewares extends Middleware<any, State, DispatchType>[] = [],
   State = any,
-  Dispatch extends ReduxDispatch<UnknownAction> = ReduxDispatch<UnknownAction>,
-> = () => TSHelpersExtractDispatchExtensions<Middlewares> & Dispatch
+  DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>,
+> = () => TSHelpersExtractDispatchExtensions<Middlewares> & DispatchType
 
 export type CreateDispatchWithMiddlewareHook<
   State = any,
-  Dispatch extends ReduxDispatch<UnknownAction> = ReduxDispatch<UnknownAction>,
+  DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>,
 > = {
   <
     Middlewares extends [
-      Middleware<any, State, Dispatch>,
-      ...Middleware<any, State, Dispatch>[],
+      Middleware<any, State, DispatchType>,
+      ...Middleware<any, State, DispatchType>[],
     ],
   >(
     ...middlewares: Middlewares
-  ): UseDispatchWithMiddlewareHook<Middlewares, State, Dispatch>
+  ): UseDispatchWithMiddlewareHook<Middlewares, State, DispatchType>
   withTypes<
     MiddlewareConfig extends MiddlewareApiConfig,
   >(): CreateDispatchWithMiddlewareHook<
@@ -46,43 +41,43 @@ export type CreateDispatchWithMiddlewareHook<
   >
 }
 
-type ActionFromDispatch<Dispatch extends ReduxDispatch<ReduxAction>> =
-  Dispatch extends ReduxDispatch<infer Action> ? Action : never
+type ActionFromDispatch<DispatchType extends Dispatch<Action>> =
+  DispatchType extends Dispatch<infer Action> ? Action : never
 
 interface ReactDynamicMiddlewareInstance<
   State = any,
-  Dispatch extends ReduxDispatch<UnknownAction> = ReduxDispatch<UnknownAction>,
-> extends DynamicMiddlewareInstance<State, Dispatch> {
+  DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>,
+> extends DynamicMiddlewareInstance<State, DispatchType> {
   createDispatchWithMiddlewareHookFactory: (
     context?: Context<ReactReduxContextValue<
       State,
-      ActionFromDispatch<Dispatch>
+      ActionFromDispatch<DispatchType>
     > | null>,
-  ) => CreateDispatchWithMiddlewareHook<State, Dispatch>
+  ) => CreateDispatchWithMiddlewareHook<State, DispatchType>
   createDispatchWithMiddlewareHook: CreateDispatchWithMiddlewareHook<
     State,
-    Dispatch
+    DispatchType
   >
 }
 
 export const createDynamicMiddleware = <
   State = any,
-  Dispatch extends ReduxDispatch<UnknownAction> = ReduxDispatch<UnknownAction>,
->(): ReactDynamicMiddlewareInstance<State, Dispatch> => {
-  const instance = cDM<State, Dispatch>()
+  DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>,
+>(): ReactDynamicMiddlewareInstance<State, DispatchType> => {
+  const instance = cDM<State, DispatchType>()
   const createDispatchWithMiddlewareHookFactory = (
     // @ts-ignore
     context: Context<ReactReduxContextValue<
       State,
-      ActionFromDispatch<Dispatch>
+      ActionFromDispatch<DispatchType>
     > | null> = ReactReduxContext,
   ) => {
     const useDispatch =
       context === ReactReduxContext
         ? useDefaultDispatch
         : createDispatchHook(context)
     function createDispatchWithMiddlewareHook<
-      Middlewares extends Middleware<any, State, Dispatch>[],
+      Middlewares extends Middleware<any, State, DispatchType>[],
     >(...middlewares: Middlewares) {
       instance.addMiddleware(...middlewares)
       return useDispatch
@@ -91,7 +86,7 @@ export const createDynamicMiddleware = <
       createDispatchWithMiddlewareHook
     return createDispatchWithMiddlewareHook as CreateDispatchWithMiddlewareHook<
       State,
-      Dispatch
+      DispatchType
     >
   }
 

packages/toolkit/src/dynamicMiddleware/types.ts

@@ -1,11 +1,6 @@
-import type {
-  Middleware,
-  Dispatch as ReduxDispatch,
-  UnknownAction,
-  MiddlewareAPI,
-} from 'redux'
+import type { Dispatch, Middleware, MiddlewareAPI, UnknownAction } from 'redux'
+import type { BaseActionCreator, PayloadAction } from '../createAction'
 import type { ExtractDispatchExtensions, FallbackIfUnknown } from '../tsHelpers'
-import type { PayloadAction, BaseActionCreator } from '../createAction'
 
 export type GetMiddlewareApi<MiddlewareApiConfig> = MiddlewareAPI<
   GetDispatch<MiddlewareApiConfig>,
@@ -14,7 +9,7 @@ export type GetMiddlewareApi<MiddlewareApiConfig> = MiddlewareAPI<
 
 export type MiddlewareApiConfig = {
   state?: unknown
-  dispatch?: ReduxDispatch
+  dispatch?: Dispatch
 }
 
 // TODO: consolidate with cAT helpers?
@@ -25,16 +20,16 @@ export type GetState<MiddlewareApiConfig> = MiddlewareApiConfig extends {
   : unknown
 
 export type GetDispatch<MiddlewareApiConfig> = MiddlewareApiConfig extends {
-  dispatch: infer Dispatch
+  dispatch: infer DispatchType
 }
-  ? FallbackIfUnknown<Dispatch, ReduxDispatch>
-  : ReduxDispatch
+  ? FallbackIfUnknown<DispatchType, Dispatch>
+  : Dispatch
 
 export type AddMiddleware<
   State = any,
-  Dispatch extends ReduxDispatch<UnknownAction> = ReduxDispatch<UnknownAction>,
+  DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>,
 > = {
-  (...middlewares: Middleware<any, State, Dispatch>[]): void
+  (...middlewares: Middleware<any, State, DispatchType>[]): void
   withTypes<MiddlewareConfig extends MiddlewareApiConfig>(): AddMiddleware<
     GetState<MiddlewareConfig>,
     GetDispatch<MiddlewareConfig>
@@ -43,13 +38,13 @@ export type AddMiddleware<
 
 export interface WithMiddleware<
   State = any,
-  Dispatch extends ReduxDispatch<UnknownAction> = ReduxDispatch<UnknownAction>,
+  DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>,
 > extends BaseActionCreator<
-    Middleware<any, State, Dispatch>[],
+    Middleware<any, State, DispatchType>[],
     'dynamicMiddleware/add',
     { instanceId: string }
   > {
-  <Middlewares extends Middleware<any, State, Dispatch>[]>(
+  <Middlewares extends Middleware<any, State, DispatchType>[]>(
     ...middlewares: Middlewares
   ): PayloadAction<Middlewares, 'dynamicMiddleware/add', { instanceId: string }>
   withTypes<MiddlewareConfig extends MiddlewareApiConfig>(): WithMiddleware<
@@ -67,27 +62,27 @@ export interface DynamicDispatch {
 
 export type MiddlewareEntry<
   State = unknown,
-  Dispatch extends ReduxDispatch<UnknownAction> = ReduxDispatch<UnknownAction>,
+  DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>,
 > = {
   id: string
-  middleware: Middleware<any, State, Dispatch>
+  middleware: Middleware<any, State, DispatchType>
   applied: Map<
-    MiddlewareAPI<Dispatch, State>,
-    ReturnType<Middleware<any, State, Dispatch>>
+    MiddlewareAPI<DispatchType, State>,
+    ReturnType<Middleware<any, State, DispatchType>>
   >
 }
 
 export type DynamicMiddleware<
   State = unknown,
-  Dispatch extends ReduxDispatch<UnknownAction> = ReduxDispatch<UnknownAction>,
-> = Middleware<DynamicDispatch, State, Dispatch>
+  DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>,
+> = Middleware<DynamicDispatch, State, DispatchType>
 
 export type DynamicMiddlewareInstance<
   State = unknown,
-  Dispatch extends ReduxDispatch<UnknownAction> = ReduxDispatch<UnknownAction>,
+  DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>,
 > = {
-  middleware: DynamicMiddleware<State, Dispatch>
-  addMiddleware: AddMiddleware<State, Dispatch>
-  withMiddleware: WithMiddleware<State, Dispatch>
+  middleware: DynamicMiddleware<State, DispatchType>
+  addMiddleware: AddMiddleware<State, DispatchType>
+  withMiddleware: WithMiddleware<State, DispatchType>
   instanceId: string
 }