- update Dispatch signature

- simplify type annotations
- remove static thunk member from Store

Author: Péter Hauszknecht

src/store/index.ts

@@ -1,23 +1,19 @@
 import { Store as IStore, Listener, Unsubscribe, Middleware, Reducer, Dispatch, GetState } from './types';
-import thunk, { ThunkMiddleware } from './middlewares/thunk';
 
 export * from './types';
 export * from './middlewares/thunk';
-export { thunk };
 
-export default class Store<State, R = Reducer<State>> implements IStore<State, R> {
-  static thunk = thunk;
-
-  private state: State;
+export default class Store<S> implements IStore<S> {
+  private state: S;
   private listeners: Listener[] = [];
 
-  constructor(initialState: State) {
+  constructor(initialState: S) {
     this.state = initialState;
   }
 
-  getState: GetState<State> = () => this.state;
+  getState: GetState<S> = () => this.state;
 
-  dispatch: Dispatch<R, State> = reducer => {
+  dispatch: Dispatch<S> = reducer => {
     if (typeof reducer !== 'function')
       throw new Error('Reducer is not a function: dispatch takes only reducers as functions.');
     this.state = reducer(this.state);
@@ -32,7 +28,7 @@ export default class Store<State, R = Reducer<State>> implements IStore<State, R
     return () => (this.listeners = this.listeners.filter(lis => lis !== listener));
   };
 
-  addMiddleware = <R2>(...middlewares: Middleware<State, R, R2>[]): Store<State, R | R2> => {
+  addMiddleware = (...middlewares: Middleware[]): this => {
     if (middlewares.some(middleware => typeof middleware !== 'function'))
       throw new Error('Middleware is not a function: addMiddleware takes only middlewares as functions.');
     middlewares.forEach(middleware => (this.dispatch = middleware(this)(this.dispatch) as any));

src/store/middlewares/thunk.ts

@@ -1,38 +1,34 @@
-import { Middleware, GetState, Dispatch, Reducer, Store } from '../types';
-
-export interface ThunkMiddleware<S, EA>
-  extends Middleware<S, Reducer<S>, Thunk<S, EA>> {
-  (store: Store<S, Reducer<S> | Delegate<S, EA>>): {
-    (next: Dispatch<Reducer<S>, S>): Dispatch<Delegate<S, EA>>;
-  };
-  withExtraArgument: <EA>(extraArgument: EA) => ThunkMiddleware<S, EA>;
+import { Middleware, Dispatch, GetState } from '../types';
+
+export interface Delegate<S, E, R> {
+  (dispatch: Dispatch<S>, getState: GetState<S>, extraArgument: E): R;
 }
 
-export interface Delegate<S, EA, RE = any> {
-  (dispatch: ThunkDispatch<S, EA>, getState: GetState<S>, extraArgument: EA): RE;
+export interface Thunk<S, E, R> {
+  (state: S): Delegate<S, E, R>;
 }
 
-export interface Thunk<S, EA, RE = any> {
-  (state: S): Delegate<S, EA, RE>;
+declare module '../types' {
+  export interface Dispatch<S> {
+    <R, E = any>(thunk: Thunk<S, E, R>): R;
+  }
 }
 
-export interface ThunkDispatch<S, EA> extends Dispatch<Reducer<S>, S> {
-  <Return>(thunk: Thunk<S, EA, Return>): Return;
+export interface ThunkMiddleware<E> extends Middleware {
+  withExtraArgument: <E>(extraArgument: E) => ThunkMiddleware<E>;
 }
 
-const thunkFactory = <S, EA>(extraArgument?: EA) => {
+const thunkFactory = <E>(extraArgument?: E): ThunkMiddleware<E> => {
   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);
+    if (typeof reducer !== 'function') throw new Error('Thunk reducer must return a function');
+    const result = reducer(store.getState());
     if (typeof result === 'function') return result(store.dispatch, store.getState, extraArgument);
-    else {
-      next(_ => result);
-      return reducer;
-    }
-  }) as ThunkMiddleware<S, EA>;
+    else return next(_ => result);
+  }) as ThunkMiddleware<E>;
+
   thunk.withExtraArgument = thunkFactory;
+
   return thunk;
 };
 
-export default thunkFactory() as ThunkMiddleware<any, any>;
+export const thunk = thunkFactory();

src/store/types.ts

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

src/test/thunk.spec.ts

@@ -1,29 +1,25 @@
 import 'mocha';
 import * as assert from 'assert';
-import Store, { thunk, Thunk, Reducer } from '../store';
+import Store, { thunk } from '../store';
 
 process.env.NODE_ENV = 'test';
 
 describe('thunk', () => {
-  it('as Store static member', () => {
-    assert.strictEqual(Store.thunk, thunk);
-  });
-
   it('dispatch invokes the delegate', () => {
-    const store = new Store(1).addMiddleware<Thunk<number, void, any>>(thunk);
+    const store = new Store(1).addMiddleware(thunk);
     assert.strictEqual(store.getState(), 1);
-    store.dispatch((state => (dispatch, getState) => {
-      store.dispatch(state => getState() + 1);
-    }) as Thunk<number, void, void>);
+    store.dispatch(state => (dispatch, getState) => {
+      dispatch(state => getState() + 1);
+    });
     assert.strictEqual(store.getState(), 2);
   });
 
-  it('dispatch returns the delegate', () => {
-    const store = new Store(1).addMiddleware<Thunk<number, void, any>>(thunk);
+  it('dispatch returns the result of delegate', () => {
+    const store = new Store(1).addMiddleware(thunk);
     const expected = 8;
     assert.strictEqual(
       store.dispatch(state => dispatch => {
-        store.dispatch(state => state + 1);
+        dispatch(state => state + 1);
         return expected;
       }),
       expected
@@ -32,9 +28,9 @@ describe('thunk', () => {
 
   it('extra arguments are provided', () => {
     const add = (a, b) => a + b;
-    const store = new Store(1).addMiddleware<Thunk<number, typeof add, any>>(thunk.withExtraArgument(add));
+    const store = new Store(1).addMiddleware(thunk.withExtraArgument(add));
     store.dispatch(state => (dispatch, getState, add) => {
-      store.dispatch(state => add(state, 1));
+      dispatch(state => add(state, 1));
     });
     assert.strictEqual(store.getState(), 2);
   });