refactor: reorder function declaration in order to remove use before define

Author: FaberVitale

packages/action-listener-middleware/src/index.ts

@@ -413,81 +413,16 @@ export function createActionListenerMiddleware<
     return entry.unsubscribe
   }
 
-  const middleware: Middleware<
-    {
-      (action: Action<'actionListenerMiddleware/add'>): Unsubscribe
-    },
-    S,
-    D
-  > = (api) => (next) => (action) => {
-    if (addListenerAction.match(action)) {
-      let entry = findListenerEntry(
-        (existingEntry) => existingEntry.listener === action.payload.listener
-      )
-
-      if (!entry) {
-        entry = action.payload
+  function findListenerEntry(
+    comparator: (entry: ListenerEntry) => boolean
+  ): ListenerEntry | undefined {
+    for (const entry of listenerMap.values()) {
+      if (comparator(entry)) {
+        return entry
       }
-
-      return insertEntry(entry)
-    }
-    if (removeListenerAction.match(action)) {
-      removeListener(action.payload.type, action.payload.listener)
-      return
     }
 
-    if (listenerMap.size === 0) {
-      return next(action)
-    }
-
-    let result: unknown
-    const originalState = api.getState()
-    const getOriginalState = () => originalState
-
-    for (const currentPhase of actualMiddlewarePhases) {
-      let currentState = api.getState()
-      for (let entry of listenerMap.values()) {
-        const runThisPhase =
-          entry.when === 'both' || entry.when === currentPhase
-
-        let runListener = runThisPhase
-
-        if (runListener) {
-          try {
-            runListener = entry.predicate(action, currentState, originalState)
-          } catch (predicateError) {
-            safelyNotifyError(onError, predicateError)
-            runListener = false
-          }
-        }
-
-        if (!runListener) {
-          continue
-        }
-
-        try {
-          entry.listener(action, {
-            ...api,
-            getOriginalState,
-            // eslint-disable-next-line @typescript-eslint/no-use-before-define
-            condition,
-            currentPhase,
-            extra,
-            unsubscribe: entry.unsubscribe,
-            subscribe: () => {
-              listenerMap.set(entry.id, entry)
-            },
-          })
-        } catch (listenerError) {
-          safelyNotifyError(onError, listenerError)
-        }
-      }
-      if (currentPhase === 'beforeReducer') {
-        result = next(action)
-      } else {
-        return result
-      }
-    }
+    return undefined
   }
 
   const addListener = ((options: FallbackAddListenerOptions) => {
@@ -531,18 +466,6 @@ export function createActionListenerMiddleware<
     return true
   }
 
-  function findListenerEntry(
-    comparator: (entry: ListenerEntry) => boolean
-  ): ListenerEntry | undefined {
-    for (const entry of listenerMap.values()) {
-      if (comparator(entry)) {
-        return entry
-      }
-    }
-
-    return undefined
-  }
-
   const condition: ConditionFunction<S> = async (predicate, timeout) => {
     let unsubscribe: Unsubscribe = () => {}
 
@@ -578,6 +501,82 @@ export function createActionListenerMiddleware<
     return result
   }
 
+  const middleware: Middleware<
+    {
+      (action: Action<'actionListenerMiddleware/add'>): Unsubscribe
+    },
+    S,
+    D
+  > = (api) => (next) => (action) => {
+    if (addListenerAction.match(action)) {
+      let entry = findListenerEntry(
+        (existingEntry) => existingEntry.listener === action.payload.listener
+      )
+
+      if (!entry) {
+        entry = action.payload
+      }
+
+      return insertEntry(entry)
+    }
+    if (removeListenerAction.match(action)) {
+      removeListener(action.payload.type, action.payload.listener)
+      return
+    }
+
+    if (listenerMap.size === 0) {
+      return next(action)
+    }
+
+    let result: unknown
+    const originalState = api.getState()
+    const getOriginalState = () => originalState
+
+    for (const currentPhase of actualMiddlewarePhases) {
+      let currentState = api.getState()
+      for (let entry of listenerMap.values()) {
+        const runThisPhase =
+          entry.when === 'both' || entry.when === currentPhase
+
+        let runListener = runThisPhase
+
+        if (runListener) {
+          try {
+            runListener = entry.predicate(action, currentState, originalState)
+          } catch (predicateError) {
+            safelyNotifyError(onError, predicateError)
+            runListener = false
+          }
+        }
+
+        if (!runListener) {
+          continue
+        }
+
+        try {
+          entry.listener(action, {
+            ...api,
+            getOriginalState,
+            condition,
+            currentPhase,
+            extra,
+            unsubscribe: entry.unsubscribe,
+            subscribe: () => {
+              listenerMap.set(entry.id, entry)
+            },
+          })
+        } catch (listenerError) {
+          safelyNotifyError(onError, listenerError)
+        }
+      }
+      if (currentPhase === 'beforeReducer') {
+        result = next(action)
+      } else {
+        return result
+      }
+    }
+  }
+
   return Object.assign(
     middleware,
     {