extract middleware types from index.d.ts (reduxjs#3543)

* extract middleware types from index.d.ts

* move PreloadedState/CombinedState into types/store.ts

Author: cellog

src/types/middleware.ts

@@ -0,0 +1,31 @@
+import { Dispatch } from './store'
+import { AnyAction } from './actions'
+
+export interface MiddlewareAPI<D extends Dispatch = Dispatch, S = any> {
+  dispatch: D
+  getState(): S
+}
+
+/**
+ * A middleware is a higher-order function that composes a dispatch function
+ * to return a new dispatch function. It often turns async actions into
+ * actions.
+ *
+ * Middleware is composable using function composition. It is useful for
+ * logging actions, performing side effects like routing, or turning an
+ * asynchronous API call into a series of synchronous actions.
+ *
+ * @template DispatchExt Extra Dispatch signature added by this middleware.
+ * @template S The type of the state supported by this middleware.
+ * @template D The type of Dispatch of the store where this middleware is
+ *   installed.
+ */
+export interface Middleware<
+  _DispatchExt = {}, // TODO: remove unused component
+  S = any,
+  D extends Dispatch = Dispatch
+> {
+  (api: MiddlewareAPI<D, S>): (
+    next: Dispatch<AnyAction>
+  ) => (action: any) => any
+}

src/types/reducers.ts

@@ -1,43 +1,4 @@
 import { Action, AnyAction } from './actions'
-/**
- * Internal "virtual" symbol used to make the `CombinedState` type unique.
- */
-declare const $CombinedState: unique symbol
-
-/**
- * State base type for reducers created with `combineReducers()`.
- *
- * This type allows the `createStore()` method to infer which levels of the
- * preloaded state can be partial.
- *
- * Because Typescript is really duck-typed, a type needs to have some
- * identifying property to differentiate it from other types with matching
- * prototypes for type checking purposes. That's why this type has the
- * `$CombinedState` symbol property. Without the property, this type would
- * match any object. The symbol doesn't really exist because it's an internal
- * (i.e. not exported), and internally we never check its value. Since it's a
- * symbol property, it's not expected to be unumerable, and the value is
- * typed as always undefined, so its never expected to have a meaningful
- * value anyway. It just makes this type distinquishable from plain `{}`.
- */
-export type CombinedState<S> = { readonly [$CombinedState]?: undefined } & S
-
-/**
- * Recursively makes combined state objects partial. Only combined state _root
- * objects_ (i.e. the generated higher level object with keys mapping to
- * individual reducers) are partial.
- */
-export type PreloadedState<S> = Required<S> extends {
-  [$CombinedState]: undefined
-}
-  ? S extends CombinedState<infer S1>
-    ? {
-        [K in keyof S1]?: S1[K] extends object ? PreloadedState<S1[K]> : S1[K]
-      }
-    : never
-  : {
-      [K in keyof S]: S[K] extends object ? PreloadedState<S[K]> : S[K]
-    }
 
 /* reducers */
 

src/types/store.ts

@@ -1,8 +1,72 @@
 /// <reference types="symbol-observable" />
-import { Dispatch, PreloadedState } from '../..'
 import { Action, AnyAction } from './actions'
 import { Reducer } from './reducers'
 
+/**
+ * Internal "virtual" symbol used to make the `CombinedState` type unique.
+ */
+declare const $CombinedState: unique symbol
+
+/**
+ * State base type for reducers created with `combineReducers()`.
+ *
+ * This type allows the `createStore()` method to infer which levels of the
+ * preloaded state can be partial.
+ *
+ * Because Typescript is really duck-typed, a type needs to have some
+ * identifying property to differentiate it from other types with matching
+ * prototypes for type checking purposes. That's why this type has the
+ * `$CombinedState` symbol property. Without the property, this type would
+ * match any object. The symbol doesn't really exist because it's an internal
+ * (i.e. not exported), and internally we never check its value. Since it's a
+ * symbol property, it's not expected to be unumerable, and the value is
+ * typed as always undefined, so its never expected to have a meaningful
+ * value anyway. It just makes this type distinquishable from plain `{}`.
+ */
+export type CombinedState<S> = { readonly [$CombinedState]?: undefined } & S
+
+/**
+ * Recursively makes combined state objects partial. Only combined state _root
+ * objects_ (i.e. the generated higher level object with keys mapping to
+ * individual reducers) are partial.
+ */
+export type PreloadedState<S> = Required<S> extends {
+  [$CombinedState]: undefined
+}
+  ? S extends CombinedState<infer S1>
+    ? {
+        [K in keyof S1]?: S1[K] extends object ? PreloadedState<S1[K]> : S1[K]
+      }
+    : never
+  : {
+      [K in keyof S]: S[K] extends object ? PreloadedState<S[K]> : S[K]
+    }
+
+/**
+ * A *dispatching function* (or simply *dispatch function*) is a function that
+ * accepts an action or an async action; it then may or may not dispatch one
+ * or more actions to the store.
+ *
+ * We must distinguish between dispatching functions in general and the base
+ * `dispatch` function provided by the store instance without any middleware.
+ *
+ * The base dispatch function *always* synchronously sends an action to the
+ * store's reducer, along with the previous state returned by the store, to
+ * calculate a new state. It expects actions to be plain objects ready to be
+ * consumed by the reducer.
+ *
+ * Middleware wraps the base dispatch function. It allows the dispatch
+ * function to handle async actions in addition to actions. Middleware may
+ * transform, delay, ignore, or otherwise interpret actions or async actions
+ * before passing them to the next middleware.
+ *
+ * @template A The type of things (actions or otherwise) which may be
+ *   dispatched.
+ */
+export interface Dispatch<A extends Action = AnyAction> {
+  <T extends A>(action: T, ...extraArgs: any[]): T
+}
+
 /**
  * Function to remove listener added by `Store.subscribe()`.
  */