feat(overmind): allow transition callback

Author: christianalfoni

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

@@ -184,9 +184,42 @@ describe('Statemachine', () => {
 
     const state = statemachine<States>({
       FOO: ['BAR'],
-      BAR: (_, state) => state.transition({
-        current: 'FOO'
+      BAR: () => 'FOO'
+    }).create({
+      current: 'FOO'
+    })
+    const transition: Action = ({ state }) => {
+      state.transition({
+        current: 'BAR'
       })
+    }
+
+    const config = {
+      state,
+      actions: {
+        transition
+      }
+    } 
+
+    interface Action extends IAction<typeof config, void, void> {}
+
+    const overmind = createOvermindMock(config)
+    
+
+    overmind.actions.transition()
+    expect(overmind.state.current).toBe('FOO')
+  })
+
+  test('should allow back transition', () => {
+    type States = {
+     current: 'FOO'
+    } | {
+      current: 'BAR'
+    } 
+
+    const state = statemachine<States>({
+      FOO: ['BAR'],
+      BAR: () => true
     }).create({
       current: 'FOO'
     })
@@ -212,6 +245,43 @@ describe('Statemachine', () => {
     expect(overmind.state.current).toBe('FOO')
   })
 
+  test('should allow using callback for transition', () => {
+    type States = {
+      current: 'FOO'
+    } | {
+      current: 'BAR'
+      bar: string
+    } 
+
+    const state = statemachine<States>({
+      FOO: ['BAR'],
+      BAR: []
+    }).create({
+      current: 'FOO'
+    })
+    const transition: Action = ({ state }) => {
+      state.transition('BAR', (state) => {
+        state.bar = 'bar2'
+      })
+    }
+
+    const config = {
+      state,
+      actions: {
+        transition
+      }
+    } 
+
+    interface Action extends IAction<typeof config, void, void> {}
+
+    const overmind = createOvermindMock(config)
+    
+
+    overmind.actions.transition()
+    expect(overmind.state.current).toBe('BAR')
+    expect(overmind.state.matches('BAR')?.bar).toBe('bar2')
+  })
+
   test('should flush changes to transitions', () => {
     expect.assertions(1)
 

packages/node_modules/overmind/src/statemachine.ts

@@ -10,7 +10,7 @@ type TStates = {
 }
 
 export type StatemachineTransitions<States extends TStates, BaseState extends IState> = {
-  [State in States["current"]]: Array<States["current"]> | ((payload: Omit<States extends { current: State } ? States : never, 'current'>, state: Statemachine<States, BaseState>) => undefined | Statemachine<States, BaseState> | Array<States["current"]> | boolean)
+  [State in States["current"]]: Array<States["current"]> | ((payload: Omit<States extends { current: State } ? States : never, 'current'>, state: Statemachine<States, BaseState>) =>  States["current"] | Array<States["current"]> | boolean)
 }
 
 export interface MachineMethods<States extends TStates, Base extends IState> {
@@ -20,6 +20,10 @@ export interface MachineMethods<States extends TStates, Base extends IState> {
   transition<T extends States["current"]>(
     newState: Partial<Base> & States extends { current: T } ? States : never
   ): Statemachine<States extends { current: T} ? States : never, Base> | undefined
+  transition<T extends States["current"]>(
+    newState: T,
+    cb: (state: Statemachine<States extends { current: T} ? States : never, Base>) => void
+  ): Statemachine<States extends { current: T} ? States : never, Base> | undefined
 }
 
 export type Statemachine<States extends TStates, Base extends IState = never> = ([Base] extends [never] ? MachineMethods<States, {}> : Base & MachineMethods<States, Base>) & States
@@ -54,7 +58,7 @@ export class StateMachine<Base extends IState, States extends TStates>  {
     this[TRANSITIONS] = transitions
     Object.assign(this, state)
   }
-  transition(newState: any) {
+  transition(...args) {
     if (this[VALUE][IS_DISPOSED]) {
       if (process.env.NODE_ENV === 'development') {
         console.warn(`Overmind - The statemachine at "${this[PATH]}" has been disposed, but you tried to transition on it`)
@@ -64,13 +68,15 @@ export class StateMachine<Base extends IState, States extends TStates>  {
 
     const transition = this[VALUE][CURRENT_DYNAMIC_TRANSITION] || this[VALUE][TRANSITIONS][this.current]
 
-    if (transition.includes(newState.current)) {
+    const newState = args.length === 2 ? args[0] : args[0].current
+
+    if (transition.includes(newState)) {
       let dynamicResult: any
 
       this[VALUE][CURRENT_DYNAMIC_TRANSITION] = null
 
-      if (typeof this[VALUE][TRANSITIONS][newState.current] === 'function') {
-        dynamicResult = this[VALUE][TRANSITIONS][newState.current](newState, this)
+      if (typeof this[VALUE][TRANSITIONS][newState] === 'function') {
+        dynamicResult = this[VALUE][TRANSITIONS][newState](newState, this)
 
         if (!dynamicResult) {
           return
@@ -81,13 +87,30 @@ export class StateMachine<Base extends IState, States extends TStates>  {
         }
       }
 
-      Object.assign(this, newState)
+      const existingState = this.current
+      if (args.length === 2) {
+        this.current = newState
+        args[1](this)
+      } else {
+        Object.assign(this, args[0])
+      }
+      
+
+      if (typeof dynamicResult === 'string') {
+        this[VALUE][CURRENT_DYNAMIC_TRANSITION] = [dynamicResult]
+        return this.transition({ current: dynamicResult })
+      }
+
+      if (dynamicResult === true) {
+        this[VALUE][CURRENT_DYNAMIC_TRANSITION] = [existingState]
+        return this.transition({ current: existingState })
+      }
 
       return this
-    } else if (process.env.NODE_ENV === 'development' && newState.current !== this.current) {
+    } else if (process.env.NODE_ENV === 'development' && newState !== this.current) {
       console.warn(`Overmind Statemachine - You tried to transition into "${newState.current}", but it is not a valid transition. The valid transitions are ${JSON.stringify(transition)}`)
-    } else if (process.env.NODE_ENV === 'development' && newState.current === this.current) {
-      console.warn(`Overmind Statemachine - You tried to transition into "${newState.current}", but you are already in this state. Do a "match" before running this piece of logic or add it as a valid state transition for this state`)
+    } else if (process.env.NODE_ENV === 'development' && newState === this.current) {
+      console.warn(`Overmind Statemachine - You tried to transition into "${newState}", but you are already in this state. Do a "match" before running this piece of logic or add it as a valid state transition for this state`)
     }
 
     return