prettifying

Author: Péter Hauszknecht

src/store/index.ts

@@ -1,82 +1,61 @@
-import {
-  Store as IStore,
-  Listener,
-  Unsubscribe,
-  Middleware,
-  Reducer,
-  Dispatch,
-  GetState
-} from './types'
-import thunk, { ThunkMiddleware } from './middlewares/thunk'
+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 * from './types';
+export * from './middlewares/thunk';
+export { thunk };
 
-export default class Store<State, R = Reducer<State>>
-  implements IStore<State, R> {
-  static thunk = thunk
+export default class Store<State, R = Reducer<State>> implements IStore<State, R> {
+  static thunk = thunk;
 
-  private state: State
-  private listeners: Function[] = []
-  private middlewares: Function[] = []
+  private state: State;
+  private listeners: Function[] = [];
+  private middlewares: Function[] = [];
 
   constructor(initialState: State) {
-    this.state = initialState
+    this.state = initialState;
   }
 
-  getState: GetState<State> = () => this.state
+  getState: GetState<State> = () => this.state;
 
   dispatch: Dispatch<R> = reducer => {
-    assertReducer(reducer)
-    const finalReducer = this.applyMiddlewares(reducer)
+    assertReducer(reducer);
+    const finalReducer = this.applyMiddlewares(reducer);
     if (typeof finalReducer === 'function') {
-      this.state = finalReducer(this.state)
-      this.listeners.forEach(listener => listener())
+      this.state = finalReducer(this.state);
+      this.listeners.forEach(listener => listener());
     }
-    return <R>finalReducer
-  }
+    return <R>finalReducer;
+  };
 
   subscribe = (listener: Listener): Unsubscribe => {
-    assertListener(listener)
-    this.listeners = [ ...this.listeners, listener ]
-    return () =>
-      (this.listeners = this.listeners.filter(lis => lis !== listener))
-  }
+    assertListener(listener);
+    this.listeners = [ ...this.listeners, listener ];
+    return () => (this.listeners = this.listeners.filter(lis => lis !== listener));
+  };
 
-  addMiddleware = <R2>(
-    ...middlewares: Middleware<State>[]
-  ): Store<State, R | R2> => {
-    assertMiddlewares(middlewares)
-    this.middlewares = [ ...this.middlewares, ...middlewares ]
-    return this
-  }
+  addMiddleware = <R2>(...middlewares: Middleware<State>[]): Store<State, R | R2> => {
+    assertMiddlewares(middlewares);
+    this.middlewares = [ ...this.middlewares, ...middlewares ];
+    return this;
+  };
 
   private applyMiddlewares = (reducer: R): R =>
-    <R>this.middlewares.reduce(
-      (prevReducer, middleware) => middleware(this, prevReducer),
-      reducer
-    )
+    <R>this.middlewares.reduce((prevReducer, middleware) => middleware(this, prevReducer), reducer);
 }
 
 function assertReducer(reducer) {
   if (typeof reducer !== 'function')
-    throw new Error(
-      'Reducer is not a function: dispatch takes only reducers as functions.'
-    )
+    throw new Error('Reducer is not a function: dispatch takes only reducers as functions.');
 }
 
 function assertListener(listener) {
   if (typeof listener !== 'function')
-    throw new Error(
-      'Listener is not a function: subscribe takes only listeners as functions.'
-    )
+    throw new Error('Listener is not a function: subscribe takes only listeners as functions.');
 }
 
 function assertMiddlewares(middlewares) {
   if (middlewares.some(middleware => typeof middleware !== 'function')) {
-    throw new Error(
-      'Middleware is not a function: addMiddleware takes only middlewares as functions.'
-    )
+    throw new Error('Middleware is not a function: addMiddleware takes only middlewares as functions.');
   }
 }

src/store/middlewares/thunk.ts

@@ -1,39 +1,29 @@
-import { Middleware, GetState, Dispatch, Reducer, Store } from '../types'
+import { Middleware, GetState, Dispatch, Reducer, Store } from '../types';
 
-export interface ThunkMiddleware<State, ExtraArgument>
-  extends Middleware<State> {
-  withExtraArgument: (
-    extraArgument: ExtraArgument
-  ) => ThunkMiddleware<State, ExtraArgument>
+export interface ThunkMiddleware<State, ExtraArgument> extends Middleware<State> {
+  withExtraArgument: (extraArgument: ExtraArgument) => ThunkMiddleware<State, ExtraArgument>;
 }
 
 export interface Delegate<State, ExtraArgument, T> {
-  (
-    dispatch: ThunkDispatch<State, ExtraArgument>,
-    getState: GetState<State>,
-    extraArgument: ExtraArgument
-  ): T
+  (dispatch: ThunkDispatch<State, ExtraArgument>, getState: GetState<State>, extraArgument: ExtraArgument): T;
 }
 
-export interface ThunkDispatch<State, ExtraArgument>
-  extends Dispatch<Reducer<State>> {
-  <T>(reducer: Thunk<State, ExtraArgument, T>): T
+export interface ThunkDispatch<State, ExtraArgument> extends Dispatch<Reducer<State>> {
+  <T>(reducer: Thunk<State, ExtraArgument, T>): T;
 }
 
 export interface Thunk<State, ExtraArgument, T> {
-  (state: State): Delegate<State, ExtraArgument, T>
+  (state: State): Delegate<State, ExtraArgument, T>;
 }
 
 function thunkFactory<T>(extraArgument?: T): ThunkMiddleware<any, T> {
   const thunk = ((store, reducer) => {
-    const state = store.getState()
-    const result = reducer(state)
-    return typeof result === 'function'
-      ? result(store.dispatch, store.getState, extraArgument)
-      : reducer
-  }) as ThunkMiddleware<any, T>
-  thunk.withExtraArgument = thunkFactory
-  return thunk
+    const state = store.getState();
+    const result = reducer(state);
+    return typeof result === 'function' ? result(store.dispatch, store.getState, extraArgument) : reducer;
+  }) as ThunkMiddleware<any, T>;
+  thunk.withExtraArgument = thunkFactory;
+  return thunk;
 }
 
-export default thunkFactory()
+export default thunkFactory();

src/store/types.ts

@@ -1,30 +1,30 @@
 export interface GetState<State> {
-  (): State
+  (): State;
 }
 
 export interface Reducer<State> {
-  (state: State): State
+  (state: State): State;
 }
 
 export interface Dispatch<Reducer> {
-  (reducer: Reducer): Reducer
+  (reducer: Reducer): Reducer;
 }
 
 export interface Listener {
-  (): void
+  (): void;
 }
 
 export interface Unsubscribe {
-  (): void
+  (): void;
 }
 
 export interface Middleware<State> {
-  (store: Store<State>, reducer: Reducer<State>): Reducer<State>
+  (store: Store<State>, reducer: Reducer<State>): Reducer<State>;
 }
 
 export interface Store<State, R = Reducer<State>> {
-  getState: GetState<State>
-  dispatch: Dispatch<R>
-  subscribe(listener: Listener): Unsubscribe
-  addMiddleware<R2>(...middlewares: Middleware<State>[]): Store<State, R | R2>
+  getState: GetState<State>;
+  dispatch: Dispatch<R>;
+  subscribe(listener: Listener): Unsubscribe;
+  addMiddleware<R2>(...middlewares: Middleware<State>[]): Store<State, R | R2>;
 }

src/test/store.spec.ts

@@ -1,85 +1,85 @@
-import 'mocha'
-import * as assert from 'assert'
-import Store from '../store'
+import 'mocha';
+import * as assert from 'assert';
+import Store from '../store';
 
-process.env.NODE_ENV = 'test'
+process.env.NODE_ENV = 'test';
 
 describe('store', () => {
   describe('instantiation', () => {
     it('Store instantiation', () => {
-      const store = new Store(1)
-      assert(store)
-      assert(store.getState)
-      assert(store.dispatch)
-      assert(store.subscribe)
-      assert(store.addMiddleware)
-    })
-  })
+      const store = new Store(1);
+      assert(store);
+      assert(store.getState);
+      assert(store.dispatch);
+      assert(store.subscribe);
+      assert(store.addMiddleware);
+    });
+  });
 
   describe('getState', () => {
     it('getState returns the state', () => {
-      const store = new Store(1)
-      assert.strictEqual(store.getState(), 1)
-    })
-  })
+      const store = new Store(1);
+      assert.strictEqual(store.getState(), 1);
+    });
+  });
 
   describe('dispatch', () => {
     it('dispatch throws if its argument is not a function', () => {
-      const store = new Store(1)
-      assert.throws(() => store.dispatch(undefined))
-    })
+      const store = new Store(1);
+      assert.throws(() => store.dispatch(undefined));
+    });
 
     it('dispatch reduces the state', () => {
-      const store = new Store(1)
-      assert.strictEqual(store.getState(), 1)
-      store.dispatch(state => state + 1)
-      assert.strictEqual(store.getState(), 2)
-    })
+      const store = new Store(1);
+      assert.strictEqual(store.getState(), 1);
+      store.dispatch(state => state + 1);
+      assert.strictEqual(store.getState(), 2);
+    });
 
     it('dispatch returns the reducer', () => {
-      const store = new Store(1)
-      const reducer = state => state + 1
-      assert.strictEqual(store.dispatch(reducer), reducer)
-    })
-  })
+      const store = new Store(1);
+      const reducer = state => state + 1;
+      assert.strictEqual(store.dispatch(reducer), reducer);
+    });
+  });
 
   describe('subscribe', () => {
     it('subscribe throws if its argument is not a function', () => {
-      const store = new Store(1)
-      assert.throws(() => store.subscribe(undefined))
-    })
+      const store = new Store(1);
+      assert.throws(() => store.subscribe(undefined));
+    });
 
     it('subscribe returns a subscriber', () => {
-      const store = new Store(1)
-      const subscriber = store.subscribe(() => {})
-      assert.strictEqual(typeof subscriber, 'function')
-    })
+      const store = new Store(1);
+      const subscriber = store.subscribe(() => {});
+      assert.strictEqual(typeof subscriber, 'function');
+    });
 
     it('subscribe performs a subscribtion', done => {
-      const store = new Store(1)
+      const store = new Store(1);
       store.subscribe(() => {
-        done()
-      })
-      store.dispatch(state => state + 1)
-    })
+        done();
+      });
+      store.dispatch(state => state + 1);
+    });
 
     it('subscribtion reads the new state', done => {
-      const store = new Store(1)
+      const store = new Store(1);
       store.subscribe(() => {
-        assert.strictEqual(store.getState(), 2)
-        done()
-      })
-      store.dispatch(state => state + 1)
-    })
+        assert.strictEqual(store.getState(), 2);
+        done();
+      });
+      store.dispatch(state => state + 1);
+    });
 
     it('unsubscribe', done => {
-      const store = new Store(1)
+      const store = new Store(1);
       const unsubscribe = store.subscribe(() => {
-        done(new Error('Unsuccessful subscribtion'))
-      })
-      unsubscribe()
-      store.dispatch(state => state + 1)
-      done()
-    })
-  })
-})
+        done(new Error('Unsuccessful subscribtion'));
+      });
+      unsubscribe();
+      store.dispatch(state => state + 1);
+      done();
+    });
+  });
+});