grouping observers by getters in addObserver

src/reactor.js

@@ -195,7 +195,7 @@ class Reactor {
       return
     }
 
-    let observerIdsToNotify = Immutable.Set().withMutations(set => {
+    let gettersToNotify = Immutable.Set().withMutations(set => {
       // notify all observers
       set.union(this.observerState.get('any'))
 
@@ -208,16 +208,7 @@ class Reactor {
       })
     })
 
-    observerIdsToNotify.forEach((observerId) => {
-      const entry = this.observerState.getIn(['observersMap', observerId])
-      if (!entry) {
-        // don't notify here in the case a handler called unobserve on another observer
-        return
-      }
-
-      const getter = entry.get('getter')
-      const handler = entry.get('handler')
-
+    gettersToNotify.forEach(getter => {
       const prevEvaluateResult = fns.evaluate(this.prevReactorState, getter)
       const currEvaluateResult = fns.evaluate(this.reactorState, getter)
 
@@ -228,7 +219,11 @@ class Reactor {
       const currValue = currEvaluateResult.result
 
       if (!Immutable.is(prevValue, currValue)) {
-        handler.call(null, currValue)
+        const handlers = this.observerState.getIn(['gettersMap', getter])
+          .map(observerId => this.observerState.getIn(['observersMap', observerId, 'handler']))
+           // don't notify here in the case a handler called unobserve on another observer
+
+        handlers.forEach(handler => handler.call(null, currValue))
       }
     })
 

src/reactor/fns.js

@@ -171,18 +171,26 @@ exports.addObserver = function(observerState, getter, handler) {
     handler: handler,
   })
 
-  let updatedObserverState
+  let updatedObserverState = observerState.updateIn(['gettersMap', getter]
+    , observerIds =>
+        observerIds
+          ? observerIds.add(currId)
+          : Immutable.Set([]).add(currId)
+  )
+
   if (storeDeps.size === 0) {
     // no storeDeps means the observer is dependent on any of the state changing
-    updatedObserverState = observerState.update('any', observerIds => observerIds.add(currId))
+
+    updatedObserverState = updatedObserverState.updateIn(['any'], getters => getters.add(getter))
   } else {
-    updatedObserverState = observerState.withMutations(map => {
+    updatedObserverState = updatedObserverState.withMutations(map => {
       storeDeps.forEach(storeId => {
-        let path = ['stores', storeId]
-        if (!map.hasIn(path)) {
-          map.setIn(path, Immutable.Set([]))
-        }
-        map.updateIn(['stores', storeId], observerIds => observerIds.add(currId))
+        map.updateIn(['stores', storeId]
+          , getters =>
+              getters
+                ? getters.add(getter)
+                : Immutable.Set([]).add(getter)
+        )
       })
     })
   }
@@ -195,6 +203,7 @@ exports.addObserver = function(observerState, getter, handler) {
     observerState: updatedObserverState,
     entry: entry,
   }
+
 }
 
 /**
@@ -240,23 +249,27 @@ exports.removeObserver = function(observerState, getter, handler) {
 exports.removeObserverByEntry = function(observerState, entry) {
   return observerState.withMutations(map => {
     const id = entry.get('id')
+    const getter = entry.get('getter')
     const storeDeps = entry.get('storeDeps')
 
-    if (storeDeps.size === 0) {
-      map.update('any', anyObsevers => anyObsevers.remove(id))
-    } else {
-      storeDeps.forEach(storeId => {
-        map.updateIn(['stores', storeId], observers => {
-          if (observers) {
-            // check for observers being present because reactor.reset() can be called before an unwatch fn
-            return observers.remove(id)
-          }
-          return observers
+    map.updateIn(['gettersMap', getter], observerIds => observerIds.remove(id));
+
+    if (map.getIn(['gettersMap', getter]).size <= 0) {
+
+      if (storeDeps.size === 0) {
+        // no storeDeps means the observer is dependent on any of the state changing
+        map.update('any', getters => getters.remove(getter));
+      } else {
+        storeDeps.forEach(storeId => {
+          map.updateIn(['stores', storeId]
+            , getters => getters.remove(getter) )
         })
-      })
+      }
+
     }
 
     map.removeIn(['observersMap', id])
+
   })
 }
 

src/reactor/records.js

@@ -12,11 +12,13 @@ const ReactorState = Immutable.Record({
 })
 
 const ObserverState = Immutable.Record({
-  // observers registered to any store change
+  // getters registered to any store change
   any: Immutable.Set([]),
-  // observers registered to specific store changes
+  // getters registered to specific store changes
   stores: Immutable.Map({}),
 
+  gettersMap: Immutable.Map({}),
+
   observersMap: Immutable.Map({}),
 
   nextId: 1,