avoid useless calls to listeners

src/createStore.js

@@ -58,6 +58,8 @@ export default function createStore(reducer, preloadedState, enhancer) {
   var currentState = preloadedState
   var currentListeners = []
   var nextListeners = currentListeners
+  var listeners = []
+  var listenerId = 0
   var isDispatching = false
 
   function ensureCanMutateNextListeners() {
@@ -140,8 +142,14 @@ export default function createStore(reducer, preloadedState, enhancer) {
       isSubscribed = false
 
       ensureCanMutateNextListeners()
-      var index = nextListeners.indexOf(listener)
+      let index = nextListeners.indexOf(listener)
       nextListeners.splice(index, 1)
+
+      index = listeners.indexOf(listener)
+      if (index !== -1 && index > listenerId) {
+        listener()
+        listeners.splice(index, 1)
+      }
     }
   }
 
@@ -196,10 +204,13 @@ export default function createStore(reducer, preloadedState, enhancer) {
       isDispatching = false
     }
 
-    var listeners = currentListeners = nextListeners
-    for (var i = 0; i < listeners.length; i++) {
-      listeners[i]()
+    listeners = currentListeners = nextListeners
+    for (listenerId = 0; listenerId < listeners.length; listenerId++) {
+      listeners[listenerId]()
     }
+    currentListeners = nextListeners
+    listeners = []
+    listenerId = 0
 
     return action
   }

test/createStore.spec.js

@@ -1,13 +1,13 @@
 import expect from 'expect'
 import { createStore, combineReducers } from '../src/index'
-import { 
-  addTodo, 
-  dispatchInMiddle, 
+import {
+  addTodo,
+  dispatchInMiddle,
   getStateInMiddle,
   subscribeInMiddle,
   unsubscribeInMiddle,
-  throwError, 
-  unknownAction 
+  throwError,
+  unknownAction
 } from './helpers/actionCreators'
 import * as reducers from './helpers/reducers'
 import * as Rx from 'rxjs'
@@ -388,18 +388,40 @@ describe('createStore', () => {
 
     store.dispatch(unknownAction())
     expect(listener1.calls.length).toBe(1)
-    expect(listener2.calls.length).toBe(2)
-    expect(listener3.calls.length).toBe(2)
+    expect(listener2.calls.length).toBe(1)
+    expect(listener3.calls.length).toBe(1)
     expect(listener4.calls.length).toBe(1)
 
     unsubscribe4()
     store.dispatch(unknownAction())
     expect(listener1.calls.length).toBe(1)
-    expect(listener2.calls.length).toBe(3)
-    expect(listener3.calls.length).toBe(3)
+    expect(listener2.calls.length).toBe(2)
+    expect(listener3.calls.length).toBe(2)
     expect(listener4.calls.length).toBe(1)
   })
 
+  it('notifies a listener unsubscribed with nested dispatch with the new state', () => {
+    const store = createStore(reducers.todos)
+
+    var firstCall = true
+    const listener1 = expect.createSpy().andCall(() => {
+      unsubscribe2()
+      if (firstCall) {
+        firstCall = false
+        store.dispatch(unknownAction())
+      }
+    })
+    const listener2 = expect.createSpy()
+
+    store.subscribe(listener1)
+    let unsubscribe2 = store.subscribe(listener2)
+
+    store.dispatch(unknownAction())
+    expect(listener1.calls.length).toBe(2)
+    expect(listener2.calls.length).toBe(1)
+  })
+
+
   it('provides an up-to-date state when a subscriber is notified', done => {
     const store = createStore(reducers.todos)
     store.subscribe(() => {