refactor(proxy-state-tree): wIP scoping

Author: christianalfoni

packages/node_modules/overmind-react/src/index.ts

@@ -36,7 +36,7 @@ export type TConnect<Config extends Configuration> = {
 let nextComponentId = 0
 
 export const createHook = <A extends Overmind<Configuration>>(overmind: A) => {
-  let componentInstanceId = 0
+  let currentComponentInstanceId = 0
   const {
     ReactCurrentOwner,
   } = __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
@@ -55,55 +55,62 @@ export const createHook = <A extends Overmind<Configuration>>(overmind: A) => {
       typeof component.__componentId === 'undefined'
         ? nextComponentId++
         : component.__componentId
-    const [overmindState, setOvermindState] = useState<any>({})
+    const [tree] = useState<any>(() =>
+      (overmind as any).proxyStateTree.getScopedTree()
+    )
+    const [componentInstanceId, updateComponent] = useState<any>(
+      () => currentComponentInstanceId++
+    )
 
-    const trackId = overmind.trackState()
-    useLayoutEffect(() => {
-      const paths = overmind.clearTrackState(trackId)
+    tree.track(() => {
+      updateComponent((state) => state)
+    })
 
-      if (overmindState.listener) {
-        overmind.eventHub.emitAsync(EventType.COMPONENT_UPDATE, {
+    /*
+          overmind.eventHub.emitAsync(EventType.COMPONENT_UPDATE, {
+        componentId: component.__componentId,
+        componentInstanceId: componentInstanceId,
+        name,
+        flushId,
+        paths: [],
+      })
+    useEffect(() => {
+     if (trackId === 0) {
+        overmind.eventHub.emitAsync(EventType.COMPONENT_ADD, {
           componentId: component.__componentId,
-          componentInstanceId: overmindState.componentInstanceId,
+          componentInstanceId: componentInstanceId,
           name,
-          paths: Array.from(paths),
+          paths: Array.from(paths) as any,
         })
-        overmindState.listener.update(paths)
       } else {
-        overmindState.componentInstanceId = componentInstanceId++
-        overmindState.listener = overmind.addFlushListener(paths, (flushId) => {
-          overmind.eventHub.emitAsync(EventType.COMPONENT_UPDATE, {
-            componentId: component.__componentId,
-            componentInstanceId: overmindState.componentInstanceId,
-            name,
-            flushId,
-            paths: Array.from(paths),
-          })
-          setOvermindState((state) => state)
-        })
-        overmind.eventHub.emitAsync(EventType.COMPONENT_ADD, {
+        overmind.eventHub.emitAsync(EventType.COMPONENT_UPDATE, {
           componentId: component.__componentId,
-          componentInstanceId: overmindState.componentInstanceId,
+          componentInstanceId,
           name,
-          paths: Array.from(paths),
+          paths: Array.from(paths) as any,
         })
       }
+
+      return () => {
+        listener.dispose()
+      }
     })
+    */
+
     useEffect(() => {
       return () => {
-        if (!overmindState.listener) {
-          return
-        }
-
         overmind.eventHub.emitAsync(EventType.COMPONENT_REMOVE, {
           componentId: component.__componentId,
-          componentInstanceId: overmindState.componentInstanceId,
+          componentInstanceId,
           name,
         })
-        overmindState.listener.dispose()
       }
     }, [])
-    return overmind
+
+    return {
+      state: tree.get(),
+      actions: overmind.actions,
+    }
   }
 }
 

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

@@ -0,0 +1,21 @@
+import { IProxyStateTree } from './'
+import { scopeState } from './proxify'
+
+export interface IMutation {
+  method: string
+  path: string
+  args: any[]
+}
+
+const cache = []
+
+export class TrackMutationTree<T extends object> {
+  private master: IProxyStateTree
+  state: T
+  constructor(state: T) {
+    this.state = cache.pop() || scopeState(this, state)
+  }
+  dispose() {
+    cache.push(this)
+  }
+}

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

@@ -0,0 +1,29 @@
+import { IProxyStateTree } from './'
+import { scopeState } from './proxify'
+
+export interface ITrackCallback {
+  (flushId: number, isAsync: boolean): void
+}
+
+const cache = []
+
+export class TrackStateAccessTree<T extends object> {
+  master: IProxyStateTree
+  paths: Set<string> = new Set()
+  callback: ITrackCallback
+  state: T
+  constructor(state: T) {
+    this.state = cache.pop() || scopeState(this, state)
+  }
+  addTrackingPath(path: string) {
+    this.paths.add(path)
+    this.master.addPathDependency(path, this.callback)
+  }
+  track(cb: ITrackCallback) {
+    this.paths.clear()
+    this.callback = cb
+  }
+  dispose() {
+    cache.push(this)
+  }
+}

packages/node_modules/proxy-state-tree/src/index.test.ts

@@ -6,12 +6,13 @@ describe('CREATION', () => {
 
     expect(tree).toBeInstanceOf(ProxyStateTree)
   })
-
+})
+describe('TrackStateAccessTree', () => {
   test('should create proxy of root state', () => {
     const state = {}
     const tree = new ProxyStateTree(state)
 
-    expect(tree.get()[IS_PROXY]).toBeTruthy()
+    expect(tree.trackStateAccess().state[IS_PROXY]).toBeTruthy()
   })
 
   test('should not create nested proxies when initialized', () => {
@@ -23,7 +24,8 @@ describe('CREATION', () => {
     expect(state.foo[IS_PROXY]).not.toBeTruthy()
   })
 })
-
+describe('TrackMutationTree', () => {})
+/*
 describe('TRACKING', () => {
   test('should allow callback to run when tracking is finished', () => {
     let hasCalledCb = false
@@ -988,3 +990,4 @@ describe('SCOPED', () => {
     expect(state.foo === state.foo).toBe(true)
   })
 })
+*/