update dispatch signature

Author: Péter Hauszknecht

src/store/index.ts

@@ -17,12 +17,12 @@ export default class Store<State, R = Reducer<State>> implements IStore<State, R
 
   getState: GetState<State> = () => this.state;
 
-  dispatch: Dispatch<R> = reducer => {
+  dispatch: Dispatch<R, State> = reducer => {
     if (typeof reducer !== 'function')
       throw new Error('Reducer is not a function: dispatch takes only reducers as functions.');
     this.state = reducer(this.state);
     this.listeners.forEach(listener => listener());
-    return <R>reducer;
+    return this.state;
   };
 
   subscribe = (listener: Listener): Unsubscribe => {

src/store/middlewares/thunk.ts

@@ -1,24 +1,27 @@
 import { Middleware, GetState, Dispatch, Reducer, Store } from '../types';
 
 export interface ThunkMiddleware<State, ExtraArgument>
-  extends Middleware<State, Reducer<State>, Thunk<State, ExtraArgument, any>> {
+  extends Middleware<State, Reducer<State>, Thunk<State, ExtraArgument>> {
+  (store: Store<State, Reducer<State> | Delegate<State, ExtraArgument>>): {
+    (next: Dispatch<Reducer<State>, State>): Dispatch<Delegate<State, ExtraArgument>>;
+  };
   withExtraArgument: <EA>(extraArgument: EA) => ThunkMiddleware<State, EA>;
 }
 
-export interface Delegate<State, ExtraArgument, Return> {
+export interface Delegate<State, ExtraArgument, Return = any> {
   (dispatch: ThunkDispatch<State, ExtraArgument>, getState: GetState<State>, extraArgument: ExtraArgument): Return;
 }
 
-export interface ThunkDispatch<State, ExtraArgument> extends Dispatch<Reducer<State>> {
-  <Return>(reducer: Thunk<State, ExtraArgument, Return>): Return;
+export interface Thunk<State, ExtraArgument, Return = any> {
+  (state: State): Delegate<State, ExtraArgument, Return>;
 }
 
-export interface Thunk<State, ExtraArgument, Return> {
-  (state: State): Delegate<State, ExtraArgument, Return>;
+export interface ThunkDispatch<State, ExtraArgument> extends Dispatch<Reducer<State>, State> {
+  <Return>(thunk: Thunk<State, ExtraArgument, Return>): Return;
 }
 
-const thunkFactory = (extraArgument?) => {
-  const thunk = store => next => reducer => {
+const thunkFactory = <State, ExtraArgument>(extraArgument?: ExtraArgument) => {
+  const thunk = (store => next => reducer => {
     if (typeof reducer !== 'function') throw new Error('Thunk requires reducers as functions');
     const state = store.getState();
     const result = reducer(state);
@@ -27,8 +30,8 @@ const thunkFactory = (extraArgument?) => {
       next(_ => result);
       return reducer;
     }
-  };
-  thunk['withExtraArgument'] = thunkFactory;
+  }) as ThunkMiddleware<State, ExtraArgument>;
+  thunk.withExtraArgument = thunkFactory;
   return thunk;
 };
 

src/store/types.ts

@@ -6,8 +6,8 @@ export interface Reducer<State> {
   (state: State): State;
 }
 
-export interface Dispatch<Reducer> {
-  (reducer: Reducer): Reducer;
+export interface Dispatch<Reducer, State = any> {
+  (reducer: Reducer): State;
 }
 
 export interface Listener {
@@ -20,15 +20,13 @@ export interface Unsubscribe {
 
 export interface Middleware<State, R1, R2> {
   (store: Store<State, R1>): {
-    (next: Dispatch<R1>): {
-      (reducer: R2): any;
-    };
+    (next: Dispatch<R1, State>): Dispatch<R2>;
   };
 }
 
 export interface Store<State, R = Reducer<State>> {
   getState: GetState<State>;
-  dispatch: Dispatch<R>;
+  dispatch: Dispatch<R, State>;
   subscribe(listener: Listener): Unsubscribe;
   addMiddleware<R2>(...middlewares: Middleware<State, R, R2>[]): Store<State, R | R2>;
 }

src/test/store.spec.ts

@@ -36,10 +36,10 @@ describe('store', () => {
       assert.strictEqual(store.getState(), 2);
     });
 
-    it('dispatch returns the reducer', () => {
+    it('dispatch returns the new state', () => {
       const store = new Store(1);
       const reducer = state => state + 1;
-      assert.strictEqual(store.dispatch(reducer), reducer);
+      assert.strictEqual(store.dispatch(reducer), 2);
     });
   });