fix(overmind): correctly track on current tree

Author: christianalfoni

packages/node_modules/overmind/src/derived.ts

@@ -14,7 +14,7 @@ import { EventType, Events } from './internalTypes'
 export class Derived {
   private isDirty: boolean = true
   private trackStateTree: ITrackStateTree<any>
-  private previousTreeAccess: any
+  private previousProxifier: any
   private value: any
   private paths: Set<string>
   private updateCount: number = 0
@@ -31,12 +31,12 @@ export class Derived {
 
     return boundEvaluate
   }
-  private createScope(tree, path) {
+  private runScope(tree, path) {
     const pathAsArray = path.split('.')
     pathAsArray.pop()
     const parent = pathAsArray.reduce((curr, key) => curr[key], tree.state)
 
-    return () => this.cb(parent, tree.state)
+    return this.cb(parent, tree.state)
   }
   evaluate(
     eventHub: EventEmitter<Events>,
@@ -47,50 +47,33 @@ export class Derived {
     if (!this.trackStateTree) {
       this.trackStateTree = proxyStateTree.getTrackStateTree()
       this.trackStateTree.shouldTrack = true
-      this.trackStateTree.callback = () => {
-        this.isDirty = true
-      }
+      this.disposeOnMutation = proxyStateTree.onMutation(
+        (_, paths, flushId) => {
+          if (this.isDirty) {
+            return
+          }
 
-      if (process.env.NODE_ENV === 'development') {
-        this.disposeOnMutation = proxyStateTree.onMutation(
-          (_, paths, flushId) => {
-            if (this.isDirty) {
+          for (let mutationPath of paths) {
+            if (this.paths.has(mutationPath)) {
+              this.isDirty = true
+              eventHub.emitAsync(EventType.DERIVED_DIRTY, {
+                derivedPath: path,
+                path: mutationPath,
+                flushId,
+              })
               return
             }
-
-            for (let mutationPath of paths) {
-              if (this.paths.has(mutationPath)) {
-                this.isDirty = true
-                eventHub.emitAsync(EventType.DERIVED_DIRTY, {
-                  derivedPath: path,
-                  path: mutationPath,
-                  flushId,
-                })
-                return
-              }
-            }
           }
-        )
-      }
-    }
-
-    let isDirty
-
-    // During development we need to re-evaluate the derived so that
-    // it tracks on the mutation tree passed in, in case of mutations
-    // of the returned derived
-    if (process.env.NODE_ENV === 'development') {
-      isDirty =
-        this.isDirty ||
-        (tree instanceof MutationTree && this.previousTreeAccess !== tree)
-    } else {
-      isDirty = this.isDirty
+        }
+      )
     }
 
-    if (isDirty) {
+    // During development we need to move the ownership of whatever state is returned from
+    // the derived to track it correctly. In production we only have one proxifier, so no worries
+    if (this.isDirty || this.previousProxifier !== tree.proxifier) {
       const getPaths = tree.trackPaths()
 
-      this.value = this.createScope(tree, path)()
+      this.value = this.runScope(tree, path)
       this.isDirty = false
       this.paths = getPaths()
 
@@ -118,7 +101,7 @@ export class Derived {
       }
     }
 
-    this.previousTreeAccess = tree
+    this.previousProxifier = tree.proxifier
 
     return this.value
   }

packages/node_modules/proxy-state-tree/src/MutationTree.ts

@@ -15,7 +15,7 @@ export class MutationTree<T extends object> implements IMutationTree<T> {
   mutations: IMutation[] = []
   objectChanges = new Set<string>()
   isTracking: boolean = false
-  onPathAccess: (path: string) => void
+  trackPathListeners: Array<(path: string) => void> = []
   constructor(master: IProxyStateTree<T>, proxifier?: IProxifier<T>) {
     this.isTracking = true
     this.master = master
@@ -24,11 +24,14 @@ export class MutationTree<T extends object> implements IMutationTree<T> {
   }
   trackPaths() {
     const paths = new Set<string>()
-    this.onPathAccess = (path) => {
+    const listener = (path) => {
       paths.add(path)
     }
+    const index = this.trackPathListeners.push(listener) - 1
+
     return () => {
-      this.onPathAccess = null
+      this.trackPathListeners.splice(index, 1)
+
       return paths
     }
   }

packages/node_modules/proxy-state-tree/src/Proxyfier.ts

@@ -110,10 +110,10 @@ export class Proxifier {
 
         const trackingTree = proxifier.getTrackingTree()
         const nestedPath = proxifier.concat(path, prop)
+        const currentTree = trackingTree || proxifier.tree
 
         trackingTree && trackingTree.proxifier.trackPath(nestedPath)
-
-        proxifier.tree.onPathAccess && proxifier.tree.onPathAccess(nestedPath)
+        currentTree.trackPathListeners.forEach((cb) => cb(nestedPath))
 
         const method = String(prop)
 
@@ -203,25 +203,19 @@ export class Proxifier {
         const trackingTree = proxifier.getTrackingTree()
         const targetValue = target[prop]
         const nestedPath = proxifier.concat(path, prop)
+        const currentTree = trackingTree || proxifier.tree
 
         trackingTree && trackingTree.proxifier.trackPath(nestedPath)
-
-        proxifier.tree.onPathAccess && proxifier.tree.onPathAccess(nestedPath)
+        currentTree.trackPathListeners.forEach((cb) => cb(nestedPath))
 
         if (typeof targetValue === 'function') {
-          const dynamicValue = proxifier.tree.master.options.dynamicWrapper
+          return proxifier.tree.master.options.dynamicWrapper
             ? proxifier.tree.master.options.dynamicWrapper(
-                proxifier.tree,
+                trackingTree || proxifier.tree,
                 nestedPath,
                 targetValue
               )
             : targetValue(proxifier.tree, nestedPath)
-
-          if (dynamicValue && dynamicValue[IS_PROXY]) {
-            return proxifier.proxify(dynamicValue[VALUE], dynamicValue[PATH])
-          }
-
-          return dynamicValue
         }
 
         if (targetValue === undefined) {

packages/node_modules/proxy-state-tree/src/TrackStateTree.ts

@@ -13,21 +13,22 @@ export class TrackStateTree<T extends object> implements ITrackStateTree<T> {
   shouldTrack: boolean = false
   state: T
   proxifier: IProxifier<T>
-  onPathAccess: (path: string) => void
+  trackPathListeners: Array<(path: string) => void> = []
   constructor(master: IProxyStateTree<T>) {
     this.master = master
     this.proxifier = master.proxifier
     this.state = master.state
   }
   trackPaths() {
     const paths = new Set<string>()
-
-    this.onPathAccess = (path) => {
+    const listener = (path) => {
       paths.add(path)
     }
+    const index = this.trackPathListeners.push(listener) - 1
 
     return () => {
-      this.onPathAccess = null
+      this.trackPathListeners.splice(index, 1)
+
       return paths
     }
   }

packages/node_modules/proxy-state-tree/src/types.ts

@@ -34,7 +34,7 @@ export interface IMutationTree<T extends object> {
   proxifier: IProxifier<T>
   mutations: IMutation[]
   state: T
-  onPathAccess: (path: string) => void
+  trackPathListeners: Array<(path: string) => void>
 }
 
 export interface ITrackCallback {
@@ -66,7 +66,7 @@ export interface ITrackStateTree<T extends object> {
   state: T
   pathDependencies: Set<string>
   callback: ITrackCallback
-  onPathAccess: (path: string) => void
+  trackPathListeners: Array<(path: string) => void>
 }
 
 export interface IOptions {