Make typings compatible with Redux 4.0.0

index.d.ts

@@ -1,18 +1,24 @@
-import {Middleware, Dispatch} from "redux";
+import { Middleware, Action, AnyAction } from "redux";
 
 
-export type ThunkAction<R, S, E> = (dispatch: Dispatch<S>, getState: () => S,
-                                    extraArgument: E) => R;
+export type ThunkAction<R, S, E, A extends Action> = (
+  dispatch: ThunkDispatch<S, E, A>,
+  getState: () => S,
+  extraArgument: E
+) => R;
 
-declare module "redux" {
-  export interface Dispatch<S> {
-    <R, E>(asyncAction: ThunkAction<R, S, E>): R;
-  }
+interface ThunkDispatch<S, E, A extends Action> {
+  <T extends A>(action: T): T;
 }
 
+interface ThunkDispatch<S, E, A extends Action> {
+  <R>(asyncAction: ThunkAction<R, S, E, A>): R;
+}
+
+type ThunkMiddleware<E, S = {}, A extends Action = AnyAction> = Middleware<ThunkDispatch<S, E, A>, S, ThunkDispatch<S, E, A>>;
 
-declare const thunk: Middleware & {
-  withExtraArgument(extraArgument: any): Middleware;
+declare const thunk: ThunkMiddleware<undefined> & {
+  withExtraArgument<E>(extraArgument: E): ThunkMiddleware<E>
 };
 
 export default thunk;

package.json

@@ -69,10 +69,10 @@
     "eslint-config-airbnb": "1.0.2",
     "eslint-plugin-react": "^4.1.0",
     "mocha": "^2.2.5",
-    "redux": "^3.4.0",
+    "redux": "4.0.0-beta.2",
     "rimraf": "^2.5.2",
-    "typescript": "^1.8.10",
-    "typescript-definition-tester": "0.0.4",
+    "typescript": "~2.4.0",
+    "typescript-definition-tester": "0.0.5",
     "webpack": "^1.12.14"
   }
 }

test/typescript.ts

@@ -1,33 +1,52 @@
-import {Store, Middleware} from 'redux';
-import thunk, {ThunkAction} from '../index.d.ts';
+import { createStore, applyMiddleware } from 'redux';
+import thunk, { ThunkAction } from '../index';
 
+type State = {
+  foo: string;
+};
+
+type Actions = { type: 'FOO' };
 
-declare const store: Store<{foo: string}>;
+function fakeReducer(state: State, action: Actions): State {
+  return state;
+}
+
+const store = createStore(fakeReducer, applyMiddleware(thunk));
 
 store.dispatch(dispatch => {
-  dispatch({type: 'FOO'});
+  dispatch({ type: 'FOO' });
 });
 
-store.dispatch((dispatch, getState) => {
-  const state = getState();
+function testGetState(): ThunkAction<void, State, {}, Actions> {
+  return (dispatch, getState) => {
+    const state = getState();
+    const foo: string = state.foo;
+  };
+}
 
-  const foo: string = state.foo;
-});
+store.dispatch(testGetState());
 
-const middleware: Middleware = thunk.withExtraArgument('bar');
+const storeThunkArg = createStore(
+  fakeReducer,
+  applyMiddleware(thunk.withExtraArgument('bar'))
+);
 
-store.dispatch((dispatch, getState, extraArg) => {
+storeThunkArg.dispatch((dispatch, getState, extraArg) => {
+  const bar: string = extraArg;
   console.log(extraArg);
 });
 
-const thunkAction: ThunkAction<void, {foo: string}, {bar: number}> =
-  (dispatch, getState, extraArg) => {
-    const foo: string = getState().foo;
-    const bar: number = extraArg.bar;
+const thunkAction: ThunkAction<void, State, { bar: number }, Actions> = (
+  dispatch,
+  getState,
+  extraArg
+) => {
+  const foo: string = getState().foo;
+  const bar: number = extraArg.bar;
 
-    dispatch({type: 'FOO'});
-  };
+  dispatch({ type: 'FOO' });
+};
 
-const thunkActionDispatchOnly: ThunkAction<void, {}, {}> = dispatch => {
-  dispatch({type: 'FOO'});
+const thunkActionDispatchOnly: ThunkAction<void, {}, {}, Actions> = dispatch => {
+  dispatch({ type: 'FOO' });
 };