Update formatting for Prettier 2.3

Author: timdorr

docs/recipes/ConfiguringYourStore.md

@@ -72,24 +72,21 @@ export default logger
 ```js
 const round = number => Math.round(number * 100) / 100
 
-const monitorReducerEnhancer = createStore => (
-  reducer,
-  initialState,
-  enhancer
-) => {
-  const monitoredReducer = (state, action) => {
-    const start = performance.now()
-    const newState = reducer(state, action)
-    const end = performance.now()
-    const diff = round(end - start)
-
-    console.log('reducer process time:', diff)
-
-    return newState
-  }
+const monitorReducerEnhancer =
+  createStore => (reducer, initialState, enhancer) => {
+    const monitoredReducer = (state, action) => {
+      const start = performance.now()
+      const newState = reducer(state, action)
+      const end = performance.now()
+      const diff = round(end - start)
 
-  return createStore(monitoredReducer, initialState, enhancer)
-}
+      console.log('reducer process time:', diff)
+
+      return newState
+    }
+
+    return createStore(monitoredReducer, initialState, enhancer)
+  }
 
 export default monitorReducerEnhancer
 ```

docs/recipes/UsageWithTypescript.md

@@ -262,18 +262,18 @@ import { sendMessage } from './store/chat/actions'
 import { RootState } from './store'
 import { ThunkAction } from 'redux-thunk'
 
-export const thunkSendMessage = (
-  message: string
-): ThunkAction<void, RootState, unknown, AnyAction> => async dispatch => {
-  const asyncResp = await exampleAPI()
-  dispatch(
-    sendMessage({
-      message,
-      user: asyncResp,
-      timestamp: new Date().getTime()
-    })
-  )
-}
+export const thunkSendMessage =
+  (message: string): ThunkAction<void, RootState, unknown, AnyAction> =>
+  async dispatch => {
+    const asyncResp = await exampleAPI()
+    dispatch(
+      sendMessage({
+        message,
+        user: asyncResp,
+        timestamp: new Date().getTime()
+      })
+    )
+  }
 
 function exampleAPI() {
   return Promise.resolve('Async Chat Bot')

docs/recipes/WritingTests.md

@@ -414,13 +414,16 @@ Middleware functions wrap behavior of `dispatch` calls in Redux, so to test this
 First, we'll need a middleware function. This is similar to the real [redux-thunk](https://github.com/gaearon/redux-thunk/blob/master/src/index.js).
 
 ```js
-const thunk = ({ dispatch, getState }) => next => action => {
-  if (typeof action === 'function') {
-    return action(dispatch, getState)
-  }
+const thunk =
+  ({ dispatch, getState }) =>
+  next =>
+  action => {
+    if (typeof action === 'function') {
+      return action(dispatch, getState)
+    }
 
-  return next(action)
-}
+    return next(action)
+  }
 ```
 
 We need to create a fake `getState`, `dispatch`, and `next` functions. We use `jest.fn()` to create stubs, but with other test frameworks you would likely use [Sinon](https://sinonjs.org/).

docs/tutorials/essentials/part-2-app-structure.md

@@ -493,13 +493,16 @@ The Redux store can be extended with "middleware", which are a kind of add-on or
 The Redux Thunk middleware modifies the store to let you pass functions into `dispatch`. In fact, it's short enough we can paste it here:
 
 ```js
-const thunkMiddleware = ({ dispatch, getState }) => next => action => {
-  if (typeof action === 'function') {
-    return action(dispatch, getState, extraArgument)
-  }
+const thunkMiddleware =
+  ({ dispatch, getState }) =>
+  next =>
+  action => {
+    if (typeof action === 'function') {
+      return action(dispatch, getState, extraArgument)
+    }
 
-  return next(action)
-}
+    return next(action)
+  }
 ```
 
 It looks to see if the "action" that was passed into `dispatch` is actually a function instead of a plain action object. If it's actually a function, it calls the function, and returns the result. Otherwise, since this must be an action object, it passes the action forward to the store.

docs/tutorials/essentials/part-6-performance-normalization.md

@@ -888,10 +888,8 @@ const usersSlice = createSlice({
 export default usersSlice.reducer
 
 // highlight-start
-export const {
-  selectAll: selectAllUsers,
-  selectById: selectUserById
-} = usersAdapter.getSelectors(state => state.users)
+export const { selectAll: selectAllUsers, selectById: selectUserById } =
+  usersAdapter.getSelectors(state => state.users)
 // highlight-end
 ```
 
@@ -952,9 +950,8 @@ export const { allNotificationsRead } = notificationsSlice.actions
 export default notificationsSlice.reducer
 
 // highlight-start
-export const {
-  selectAll: selectAllNotifications
-} = notificationsAdapter.getSelectors(state => state.notifications)
+export const { selectAll: selectAllNotifications } =
+  notificationsAdapter.getSelectors(state => state.notifications)
 // highlight-end
 ```
 

docs/tutorials/fundamentals/part-8-modern-redux.md

@@ -421,12 +421,8 @@ const todosSlice = createSlice({
   }
 })
 
-export const {
-  todoAdded,
-  todoToggled,
-  todoColorSelected,
-  todoDeleted
-} = todosSlice.actions
+export const { todoAdded, todoToggled, todoColorSelected, todoDeleted } =
+  todosSlice.actions
 
 export default todosSlice.reducer
 ```
@@ -751,10 +747,8 @@ export const {
 export default todosSlice.reducer
 
 // highlight-start
-export const {
-  selectAll: selectTodos,
-  selectById: selectTodoById
-} = todosAdapter.getSelectors(state => state.todos)
+export const { selectAll: selectTodos, selectById: selectTodoById } =
+  todosAdapter.getSelectors(state => state.todos)
 // highlight-end
 
 export const selectTodoIds = createSelector(

src/applyMiddleware.ts

@@ -60,28 +60,29 @@ export default function applyMiddleware<Ext, S = any>(
 export default function applyMiddleware(
   ...middlewares: Middleware[]
 ): StoreEnhancer<any> {
-  return (createStore: StoreEnhancerStoreCreator) => <S, A extends AnyAction>(
-    reducer: Reducer<S, A>,
-    preloadedState?: PreloadedState<S>
-  ) => {
-    const store = createStore(reducer, preloadedState)
-    let dispatch: Dispatch = () => {
-      throw new Error(
-        'Dispatching while constructing your middleware is not allowed. ' +
-          'Other middleware would not be applied to this dispatch.'
-      )
-    }
+  return (createStore: StoreEnhancerStoreCreator) =>
+    <S, A extends AnyAction>(
+      reducer: Reducer<S, A>,
+      preloadedState?: PreloadedState<S>
+    ) => {
+      const store = createStore(reducer, preloadedState)
+      let dispatch: Dispatch = () => {
+        throw new Error(
+          'Dispatching while constructing your middleware is not allowed. ' +
+            'Other middleware would not be applied to this dispatch.'
+        )
+      }
 
-    const middlewareAPI: MiddlewareAPI = {
-      getState: store.getState,
-      dispatch: (action, ...args) => dispatch(action, ...args)
-    }
-    const chain = middlewares.map(middleware => middleware(middlewareAPI))
-    dispatch = compose<typeof dispatch>(...chain)(store.dispatch)
+      const middlewareAPI: MiddlewareAPI = {
+        getState: store.getState,
+        dispatch: (action, ...args) => dispatch(action, ...args)
+      }
+      const chain = middlewares.map(middleware => middleware(middlewareAPI))
+      dispatch = compose<typeof dispatch>(...chain)(store.dispatch)
 
-    return {
-      ...store,
-      dispatch
+      return {
+        ...store,
+        dispatch
+      }
     }
-  }
 }

src/compose.ts

@@ -53,5 +53,9 @@ export default function compose(...funcs: Function[]) {
     return funcs[0]
   }
 
-  return funcs.reduce((a, b) => (...args: any) => a(b(...args)))
+  return funcs.reduce(
+    (a, b) =>
+      (...args: any) =>
+        a(b(...args))
+  )
 }

src/createStore.ts

@@ -292,18 +292,15 @@ export default function createStore<
     }
 
     // TODO: do this more elegantly
-    ;((currentReducer as unknown) as Reducer<
-      NewState,
-      NewActions
-    >) = nextReducer
+    ;(currentReducer as unknown as Reducer<NewState, NewActions>) = nextReducer
 
     // This action has a similar effect to ActionTypes.INIT.
     // Any reducers that existed in both the new and old rootReducer
     // will receive the previous state. This effectively populates
     // the new state tree with any relevant data from the old one.
     dispatch({ type: ActionTypes.REPLACE } as A)
     // change the type of the store by casting it to the new store
-    return (store as unknown) as Store<
+    return store as unknown as Store<
       ExtendState<NewState, StateExt>,
       NewActions,
       StateExt,
@@ -361,12 +358,12 @@ export default function createStore<
   // the initial state tree.
   dispatch({ type: ActionTypes.INIT } as A)
 
-  const store = ({
+  const store = {
     dispatch: dispatch as Dispatch<A>,
     subscribe,
     getState,
     replaceReducer,
     [$$observable]: observable
-  } as unknown) as Store<ExtendState<S, StateExt>, A, StateExt, Ext> & Ext
+  } as unknown as Store<ExtendState<S, StateExt>, A, StateExt, Ext> & Ext
   return store
 }

test/applyMiddleware.spec.ts

@@ -52,9 +52,9 @@ describe('applyMiddleware', () => {
     const store = applyMiddleware(test(spy), thunk)(createStore)(reducers.todos)
 
     // the typing for redux-thunk is super complex, so we will use an as unknown hack
-    const dispatchedValue = (store.dispatch(
+    const dispatchedValue = store.dispatch(
       addTodoAsync('Use Redux')
-    ) as unknown) as Promise<void>
+    ) as unknown as Promise<void>
     return dispatchedValue.then(() => {
       expect(spy.mock.calls.length).toEqual(2)
     })
@@ -92,9 +92,9 @@ describe('applyMiddleware', () => {
     ])
 
     // the typing for redux-thunk is super complex, so we will use an "as unknown" hack
-    const dispatchedValue = (store.dispatch(
+    const dispatchedValue = store.dispatch(
       addTodoAsync('Maybe')
-    ) as unknown) as Promise<void>
+    ) as unknown as Promise<void>
     dispatchedValue.then(() => {
       expect(store.getState()).toEqual([
         {
@@ -122,18 +122,15 @@ describe('applyMiddleware', () => {
       <T extends A>(action: T, extraArg?: string[]): T
     }
 
-    const multiArgMiddleware: Middleware<
-      MultiDispatch,
-      any,
-      MultiDispatch
-    > = _store => {
-      return next => (action, callArgs?: any) => {
-        if (Array.isArray(callArgs)) {
-          return action(...callArgs)
+    const multiArgMiddleware: Middleware<MultiDispatch, any, MultiDispatch> =
+      _store => {
+        return next => (action, callArgs?: any) => {
+          if (Array.isArray(callArgs)) {
+            return action(...callArgs)
+          }
+          return next(action)
         }
-        return next(action)
       }
-    }
 
     function dummyMiddleware({ dispatch }) {
       return _next => action => dispatch(action, testCallArgs)

test/bindActionCreators.spec.ts

@@ -49,14 +49,14 @@ describe('bindActionCreators', () => {
     // as this is testing against invalid values, we will cast to unknown and then back to ActionCreator<any>
     // in a typescript environment this test is unnecessary, but required in javascript
     const boundActionCreators = bindActionCreators(
-      ({
+      {
         ...actionCreators,
         foo: 42,
         bar: 'baz',
         wow: undefined,
         much: {},
         test: null
-      } as unknown) as ActionCreator<any>,
+      } as unknown as ActionCreator<any>,
       store.dispatch
     )
     expect(Object.keys(boundActionCreators)).toEqual(
@@ -94,7 +94,7 @@ describe('bindActionCreators', () => {
   it('throws for a primitive actionCreator', () => {
     expect(() => {
       bindActionCreators(
-        ('string' as unknown) as ActionCreator<any>,
+        'string' as unknown as ActionCreator<any>,
         store.dispatch
       )
     }).toThrow(