feat(overmind): allow functions, use derived for derived and new statemachine api

BREAKING CHANGE:
new statemachine api and derived requires derived function

Author: christianalfoni

packages/node_modules/overmind/src/config/statechart.ts

@@ -308,7 +308,7 @@ export function statechart<C extends IConfiguration, Charts extends Statecharts
     }) as any,
     state: Object.assign(state, {
       states: getInitialStates(charts),
-      actions: ((state) => getCanTransitionActions(actions, charts, state)) as any,
+      actions: derived((state) => getCanTransitionActions(actions, charts, state)) as any,
       matches: derived((state: any) => (match) => {
         const matchPaths = getMatchPaths(match)
         const statesWithoutRootChartIndicator = state.states.map((statePath) => statePath.filter((path) => path !== CHART))

packages/node_modules/overmind/src/derived.ts

@@ -10,6 +10,7 @@ import {
 import { EventType, Events } from './internalTypes'
 
 export const IS_DERIVED = Symbol('IS_DERIVED')
+export const IS_DERIVED_CONSTRUCTOR = Symbol('IS_DERIVED_CONSTRUCTOR')
 
 export class Derived {
   private isDirty: boolean = true

packages/node_modules/overmind/src/index.ts

@@ -13,7 +13,7 @@ import {
   VALUE,
 } from 'proxy-state-tree'
 
-import { Derived, IS_DERIVED } from './derived'
+import { Derived, IS_DERIVED, IS_DERIVED_CONSTRUCTOR } from './derived'
 import { Devtools, DevtoolsMessage } from './Devtools'
 import {
   DefaultMode,
@@ -72,7 +72,10 @@ export { SERIALIZE, rehydrate } from './rehydrate'
 
 export { Statemachine, statemachine } from './statemachine'
 
-export const derived = <D extends (state: IState, rootState: IState) => any>(cb: D): D extends (state: IState, rootState: IState) => infer O ? O : never => cb as any
+export const derived = <D extends (state: IState, rootState: IState) => any>(cb: D): D extends (state: IState, rootState: IState) => infer O ? O : never => {
+  cb[IS_DERIVED_CONSTRUCTOR] = true
+  return cb as any
+}
 
 /** This type can be overwriten by app developers if they want to avoid
  * typing and then they can import `Action`,  `Operation` etc. directly from
@@ -385,11 +388,18 @@ export class Overmind<ThisConfig extends IConfiguration>
             return { func, value: func(eventHub, tree, proxyStateTree, path.split(this.delimiter)) }
           }
 
-          const derived = new Derived(func) as any
+          if (func[IS_DERIVED_CONSTRUCTOR]) {
+            const derived = new Derived(func) as any
+
+            return {
+              func: derived,
+              value: derived(eventHub, tree, proxyStateTree, path.split(this.delimiter))
+            }
+          }
 
           return {
-            func: derived,
-            value: derived(eventHub, tree, proxyStateTree, path.split(this.delimiter))
+            func,
+            value: func
           }
         },    
         onGetter: devmode

packages/node_modules/overmind/src/statemachine.test.ts

@@ -7,42 +7,41 @@ describe('Statemachine', () => {
 
   test('should set initial state', () => {
 
-    type State = {
-      machine: Statemachine<'FOO' | 'BAR'>
-    }
-    const state: State = {
-      machine: statemachine<'FOO' | 'BAR'>({
-        initial: 'FOO',
-        states: {
-          FOO: ['BAR'],
-          BAR: ['FOO']
-        }
-      })
+    type States = {
+      state: 'FOO'
+    } | {
+      state: 'BAR'
     }
+
+    const state = statemachine<States>({
+      FOO: ['BAR'],
+      BAR: ['FOO']
+    }, {
+      state: 'FOO'
+    })
     const config = {
       state,
     } 
 
     const overmind = createOvermindMock(config)
 
-    expect(overmind.state.machine.current).toBe('FOO')
+    expect(overmind.state.state).toBe('FOO')
   })
-  test.only('should transition state', () => {
-    type State = {
-      machine: Statemachine<'FOO' | 'BAR'>
-    }
-
-    const state: State = {
-      machine: statemachine<'FOO' | 'BAR'>({
-        initial: 'FOO',
-        states: {
-          FOO: ['BAR'],
-          BAR: ['FOO']
-        }
-      })
-    }
+  test('should transition state', () => {
+    type States = {
+      state: 'FOO'
+    } | {
+      state: 'BAR'
+    }
+
+    const state = statemachine<States>({
+      FOO: ['BAR'],
+      BAR: ['FOO']
+    }, {
+      state: 'FOO'
+    })
     const transition: Action = ({ state }) => {
-      state.machine.BAR()
+      state.BAR()
     }
 
     const config = {
@@ -56,25 +55,24 @@ describe('Statemachine', () => {
 
     const overmind = createOvermindMock(config)
     overmind.actions.transition()
-    expect(overmind.state.machine.current).toBe('BAR')
+    expect(overmind.state.state).toBe('BAR')
   })
   test('should ignore transition to invalid state', () => {
 
-    type State = {
-      machine: Statemachine<'FOO' | 'BAR'>
+    type States = {
+      state: 'FOO'
+    } | {
+      state: 'BAR'
     }
 
-    const state: State = {
-      machine: statemachine<'FOO' | 'BAR'>({
-        initial: 'FOO',
-        states: {
-          FOO: [],
-          BAR: ['FOO']
-        }
-      })
-    }
+    const state = statemachine<States>({
+      FOO: [],
+      BAR: ['FOO']
+    }, {
+      state: 'FOO'
+    })
     const transition: Action = ({ state }) => {
-      state.machine.BAR()
+      state.BAR()
     }
 
     const config = {
@@ -88,29 +86,29 @@ describe('Statemachine', () => {
 
     const overmind = createOvermindMock(config)
     overmind.actions.transition()
-    expect(overmind.state.machine.current).toBe('FOO')
+    expect(overmind.state.state).toBe('FOO')
   })
   test('should run entry and exit transition', () => {
     expect.assertions(3)
-    type State = {
-      machine: Statemachine<'FOO' | 'BAR'>
+    type States = {
+      state: 'FOO'
+    } | {
+      state: 'BAR'
     }
 
-    const state: State = {
-      machine: statemachine<'FOO' | 'BAR'>({
-        initial: 'FOO',
-        states: {
-          FOO: ['BAR'],
-          BAR: ['FOO']
-        }
+    const state = statemachine<States>({
+        FOO: ['BAR'],
+        BAR: ['FOO']
+      }, {
+        state: 'FOO'
       })
-    }
+    
     const transition: Action = ({ state }) => {
-      state.machine.BAR(() => {
-        expect(state.machine.current).toBe('BAR')
-        state.machine.FOO()
+      state.BAR(() => {
+        expect(state.state).toBe('BAR')
+        state.FOO()
       }, () => {
-        expect(state.machine.current).toBe('BAR')
+        expect(state.state).toBe('BAR')
       })
     }
 
@@ -125,26 +123,26 @@ describe('Statemachine', () => {
 
     const overmind = createOvermindMock(config)
     overmind.actions.transition()
-    expect(overmind.state.machine.current).toBe('FOO')
+    expect(overmind.state.state).toBe('FOO')
   })
   test('should flush changes to transitions', () => {
     expect.assertions(1)
 
-    type State = {
-      machine: Statemachine<'FOO' | 'BAR'>
+    type States = {
+      state: 'FOO'
+    } | {
+      state: 'BAR'
     }
 
-    const state: State = {
-      machine: statemachine<'FOO' | 'BAR'>({
-        initial: 'FOO',
-        states: {
-          FOO: ['BAR'],
-          BAR: ['FOO']
-        }
+    const state = statemachine<States>({
+      FOO: ['BAR'],
+      BAR: ['FOO']
+      }, {
+        state: 'FOO'
       })
-    }
+    
     const transition: Action = ({ state }) => {
-      state.machine.BAR()
+      state.BAR()
     }
 
     const config = {
@@ -157,7 +155,7 @@ describe('Statemachine', () => {
     interface Action extends IAction<typeof config, void, void> {}
 
     const overmind = createOvermind(config)
-    overmind.reaction((state) => state.machine.current, (value) => {
+    overmind.reaction((state) => state.state, (value) => {
       expect(value).toBe('BAR')
     })
     overmind.actions.transition()
@@ -166,23 +164,20 @@ describe('Statemachine', () => {
   test('should error when mutating async in transitions', async () => {
     expect.assertions(1)
 
-    type State = {
-      machine: Statemachine<'FOO' | 'BAR'>
-      foo: string
+    type States = {
+      state: 'FOO'
+    } | {
+      state: 'BAR'
     }
 
-    const state: State = {
-      machine: statemachine<'FOO' | 'BAR'>({
-        initial: 'FOO',
-        states: {
-          FOO: ['BAR'],
-          BAR: ['FOO']
-        }
-      }),
-      foo: 'bar'
-    }
+    const state = statemachine<States>({
+        FOO: ['BAR'],
+        BAR: ['FOO']
+      }, {
+        state: 'FOO'
+      })
     const transition: Action = ({ state }) => {
-      return state.machine.BAR(async () => {
+      return state.BAR(async () => {
         await Promise.resolve()
         expect(state[PROXY_TREE].master.mutationTree.isBlocking).toBe(true)
       })
@@ -201,4 +196,39 @@ describe('Statemachine', () => {
 
     return overmind.actions.transition()
   })
+
+  test('should reset a statemachine', () => {
+    expect.assertions(1)
+
+    type States = {
+      state: 'FOO'
+    } | {
+      state: 'BAR'
+    }
+
+    const state = statemachine<States>({
+      FOO: ['BAR'],
+      BAR: ['FOO']
+      }, {
+        state: 'FOO'
+      })
+    
+    const transition: Action = ({ state }) => {
+      state.BAR()
+    }
+
+    const config = {
+      state,
+      actions: {
+        transition
+      }
+    } 
+
+    interface Action extends IAction<typeof config, void, void> {}
+
+    const overmind = createOvermind(config)
+    overmind.actions.transition()
+    overmind.state.reset()
+    expect(overmind.state.state).toBe('FOO')
+  })
 })