Fix formatting

Author: markerikson

docs/usage/WritingCustomMiddleware.md

@@ -39,74 +39,75 @@ You might still want to use custom middleware in one of two cases:
 ### Create side effects for actions
 
 This is the most common middleware. Here's what it looks like for [rtk listener middleware](https://github.com/reduxjs/redux-toolkit/blob/0678c2e195a70c34cd26bddbfd29043bc36d1362/packages/toolkit/src/listenerMiddleware/index.ts#L427):
+
 ```ts
 const middleware: ListenerMiddleware<S, D, ExtraArgument> =
-    (api) => (next) => (action) => {
-      if (addListener.match(action)) {
-        return startListening(action.payload)
-      }
-
-      if (clearAllListeners.match(action)) {
-        clearListenerMiddleware()
-        return
-      }
+  api => next => action => {
+    if (addListener.match(action)) {
+      return startListening(action.payload)
+    }
 
-      if (removeListener.match(action)) {
-        return stopListening(action.payload)
-      }
+    if (clearAllListeners.match(action)) {
+      clearListenerMiddleware()
+      return
+    }
 
-      // Need to get this state _before_ the reducer processes the action
-      let originalState: S | typeof INTERNAL_NIL_TOKEN = api.getState()
+    if (removeListener.match(action)) {
+      return stopListening(action.payload)
+    }
 
-      // `getOriginalState` can only be called synchronously.
-      // @see https://github.com/reduxjs/redux-toolkit/discussions/1648#discussioncomment-1932820
-      const getOriginalState = (): S => {
-        if (originalState === INTERNAL_NIL_TOKEN) {
-          throw new Error(
-            `${alm}: getOriginalState can only be called synchronously`
-          )
-        }
+    // Need to get this state _before_ the reducer processes the action
+    let originalState: S | typeof INTERNAL_NIL_TOKEN = api.getState()
 
-        return originalState as S
+    // `getOriginalState` can only be called synchronously.
+    // @see https://github.com/reduxjs/redux-toolkit/discussions/1648#discussioncomment-1932820
+    const getOriginalState = (): S => {
+      if (originalState === INTERNAL_NIL_TOKEN) {
+        throw new Error(
+          `${alm}: getOriginalState can only be called synchronously`
+        )
       }
 
-      let result: unknown
+      return originalState as S
+    }
 
-      try {
-        // Actually forward the action to the reducer before we handle listeners
-        result = next(action)
+    let result: unknown
 
-        if (listenerMap.size > 0) {
-          let currentState = api.getState()
-          // Work around ESBuild+TS transpilation issue
-          const listenerEntries = Array.from(listenerMap.values())
-          for (let entry of listenerEntries) {
-            let runListener = false
+    try {
+      // Actually forward the action to the reducer before we handle listeners
+      result = next(action)
 
-            try {
-              runListener = entry.predicate(action, currentState, originalState)
-            } catch (predicateError) {
-              runListener = false
+      if (listenerMap.size > 0) {
+        let currentState = api.getState()
+        // Work around ESBuild+TS transpilation issue
+        const listenerEntries = Array.from(listenerMap.values())
+        for (let entry of listenerEntries) {
+          let runListener = false
 
-              safelyNotifyError(onError, predicateError, {
-                raisedBy: 'predicate',
-              })
-            }
+          try {
+            runListener = entry.predicate(action, currentState, originalState)
+          } catch (predicateError) {
+            runListener = false
 
-            if (!runListener) {
-              continue
-            }
+            safelyNotifyError(onError, predicateError, {
+              raisedBy: 'predicate'
+            })
+          }
 
-            notifyListener(entry, action, api, getOriginalState)
+          if (!runListener) {
+            continue
           }
+
+          notifyListener(entry, action, api, getOriginalState)
         }
-      } finally {
-        // Remove `originalState` store from this scope.
-        originalState = INTERNAL_NIL_TOKEN
       }
-
-      return result
+    } finally {
+      // Remove `originalState` store from this scope.
+      originalState = INTERNAL_NIL_TOKEN
     }
+
+    return result
+  }
 ```
 
 In the first part, it listens to `addListener`, `clearAllListeners` and `removeListener` actions to change which listeners should be invoked later on.
@@ -120,20 +121,20 @@ It is common to have side effects after dispatching th eaction, because this all
 While these patterns are less common, most of them (except for cancelling actions) are used by [redux thunk middleware](https://github.com/reduxjs/redux-thunk/blob/587a85b1d908e8b7cf2297bec6e15807d3b7dc62/src/index.ts#L22):
 
 ```ts
-  const middleware: ThunkMiddleware<State, BasicAction, ExtraThunkArg> =
-    ({ dispatch, getState }) =>
-    next =>
-    action => {
-      // The thunk middleware looks for any functions that were passed to `store.dispatch`.
-      // If this "action" is really a function, call it and return the result.
-      if (typeof action === 'function') {
-        // Inject the store's `dispatch` and `getState` methods, as well as any "extra arg"
-        return action(dispatch, getState, extraArgument)
-      }
-
-      // Otherwise, pass the action down the middleware chain as usual
-      return next(action)
+const middleware: ThunkMiddleware<State, BasicAction, ExtraThunkArg> =
+  ({ dispatch, getState }) =>
+  next =>
+  action => {
+    // The thunk middleware looks for any functions that were passed to `store.dispatch`.
+    // If this "action" is really a function, call it and return the result.
+    if (typeof action === 'function') {
+      // Inject the store's `dispatch` and `getState` methods, as well as any "extra arg"
+      return action(dispatch, getState, extraArgument)
     }
+
+    // Otherwise, pass the action down the middleware chain as usual
+    return next(action)
+  }
 ```
 
 Usually, `dispatch` can only handle JSON actions. This middleware adds the ability to also handle actions in the form of functions. It also changes the return type of the dispatch function itself by passing the return value of the function-action to be the return value of the dispatch function.