feat(overmind): added statemachines

Author: christianalfoni

packages/node_modules/overmind/src/index.ts

@@ -70,6 +70,8 @@ export { MODE_DEFAULT, MODE_TEST, MODE_SSR } from './utils'
 
 export { SERIALIZE, rehydrate } from './rehydrate'
 
+export { Statemachine, statemachine } from './statemachine'
+
 /** This type can be overwriten by app developers if they want to avoid
  * typing and then they can import `Action`,  `Operation` etc. directly from
  * overmind.

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

@@ -44,15 +44,12 @@ describe('Mock', () => {
 
     overmind.state.foo = 'bar2'
 
-    expect(overmind.hydrate()).toEqual([
-      {
-        method: 'set',
-        path: 'foo',
-        args: ['bar2'],
-      },
-    ])
+    const mutations = overmind.hydrate()
+    expect(mutations[0].method).toBe('set')
+    expect(mutations[0].path).toBe('foo')
+    expect(mutations[0].args).toEqual(['bar2'])
   })
-  test.only('should rehydrate mutation', () => {
+  test('should rehydrate mutation', () => {
     type State = {
       foo: string
     }

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

@@ -0,0 +1,164 @@
+import { IAction , createOvermind, createOvermindMock } from './'
+
+import { Statemachine, statemachine } from './statemachine'
+
+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']
+        }
+      })
+    }
+    const config = {
+      state,
+    } 
+
+    const overmind = createOvermindMock(config)
+
+    expect(overmind.state.machine.current).toBe('FOO')
+  })
+  test('should transition state', () => {
+
+    type State = {
+      machine: Statemachine<'FOO' | 'BAR'>
+    }
+
+    const state: State = {
+      machine: statemachine<'FOO' | 'BAR'>({
+        initial: 'FOO',
+        states: {
+          FOO: ['BAR'],
+          BAR: ['FOO']
+        }
+      })
+    }
+    const transition: Action = ({ state }) => {
+      state.machine.BAR()
+    }
+
+    const config = {
+      state,
+      actions: {
+        transition
+      }
+    } 
+
+    interface Action extends IAction<typeof config, void, void> {}
+
+    const overmind = createOvermindMock(config)
+    overmind.actions.transition()
+    expect(overmind.state.machine.current).toBe('BAR')
+  })
+  test('should ignore transition to invalid state', () => {
+
+    type State = {
+      machine: Statemachine<'FOO' | 'BAR'>
+    }
+
+    const state: State = {
+      machine: statemachine<'FOO' | 'BAR'>({
+        initial: 'FOO',
+        states: {
+          FOO: [],
+          BAR: ['FOO']
+        }
+      })
+    }
+    const transition: Action = ({ state }) => {
+      state.machine.BAR()
+    }
+
+    const config = {
+      state,
+      actions: {
+        transition
+      }
+    } 
+
+    interface Action extends IAction<typeof config, void, void> {}
+
+    const overmind = createOvermindMock(config)
+    overmind.actions.transition()
+    expect(overmind.state.machine.current).toBe('FOO')
+  })
+  test('should run entry and exit transition', () => {
+    expect.assertions(3)
+    type State = {
+      machine: Statemachine<'FOO' | 'BAR'>
+    }
+
+    const state: State = {
+      machine: statemachine<'FOO' | 'BAR'>({
+        initial: 'FOO',
+        states: {
+          FOO: ['BAR'],
+          BAR: ['FOO']
+        }
+      })
+    }
+    const transition: Action = ({ state }) => {
+      state.machine.BAR(() => {
+        expect(state.machine.current).toBe('BAR')
+        state.machine.FOO()
+      }, () => {
+        expect(state.machine.current).toBe('BAR')
+      })
+    }
+
+    const config = {
+      state,
+      actions: {
+        transition
+      }
+    } 
+
+    interface Action extends IAction<typeof config, void, void> {}
+
+    const overmind = createOvermindMock(config)
+    overmind.actions.transition()
+    expect(overmind.state.machine.current).toBe('FOO')
+  })
+  test('should flush changes to transitions', () => {
+    expect.assertions(1)
+
+    type State = {
+      machine: Statemachine<'FOO' | 'BAR'>
+    }
+
+    const state: State = {
+      machine: statemachine<'FOO' | 'BAR'>({
+        initial: 'FOO',
+        states: {
+          FOO: ['BAR'],
+          BAR: ['FOO']
+        }
+      })
+    }
+    const transition: Action = ({ state }) => {
+      state.machine.BAR()
+    }
+
+    const config = {
+      state,
+      actions: {
+        transition
+      }
+    } 
+
+    interface Action extends IAction<typeof config, void, void> {}
+
+    const overmind = createOvermind(config)
+    overmind.reaction((state) => state.machine.current, (value) => {
+      expect(value).toBe('BAR')
+    })
+    overmind.actions.transition()
+  })
+})

packages/node_modules/overmind/src/statemachine.ts

@@ -0,0 +1,47 @@
+import { Derive } from './'
+
+export type StatemachineDefinition<States extends string> = {
+  initial: States,
+  states: {
+    [State in States]: Array<States>
+  }
+}
+
+export type Statemachine<States extends string> = {
+  current: States
+  reset: () => void
+} & {
+  [State in States]: Derive<any, <T>(entry?: () => T, exit?: () => void) => T>
+}
+
+export function statemachine<States extends string>(chart: StatemachineDefinition<States>): Statemachine<States> {
+  let currentExit
+
+  return {
+    current: chart.initial,
+    ...Object.keys(chart.states).reduce((aggr, key) => {
+      aggr[key] = () => { 
+        return function (entry, exit) {
+          if (chart.states[this.current].includes(key as any)) {
+            if (currentExit) currentExit()
+            currentExit = exit
+            this.current = key
+            return entry && entry()
+          }
+        }
+      }
+  
+      return aggr
+    }, {}),
+    reset: () => {
+      return function() {
+        const caller = this
+        caller.current = chart.initial
+        if (currentExit) {
+          currentExit()
+          currentExit = null
+        }
+      }
+    }
+  } as any
+}