chore(merge): fix merge conflict

Author: christianalfoni

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: [christianalfoni]

packages/node_modules/overmind-devtools/src/main.js

@@ -168,9 +168,26 @@ function createWindow() {
   )
 
   startDevtoolBackend().then(openDevtools)
+
+  /*
+    BUG FIX: https://github.com/electron/electron/issues/13008#issuecomment-575909942
+  */
+ let redirectURL = 'data:application/x-javascript;base64,UHJvZHVjdFJlZ2lzdHJ5SW1wbC5SZWdpc3RyeT1jbGFzc3tjb25zdHJ1Y3Rvcigpe31uYW1lRm9yVXJsKHIpe3JldHVybiBudWxsfWVudHJ5Rm9yVXJsKHIpe3JldHVybiBudWxsfXR5cGVGb3JVcmwocil7cmV0dXJuIG51bGx9fSxQcm9kdWN0UmVnaXN0cnlJbXBsLl9oYXNoRm9yRG9tYWluPWZ1bmN0aW9uKHIpe3JldHVybiIifSxQcm9kdWN0UmVnaXN0cnlJbXBsLnJlZ2lzdGVyPWZ1bmN0aW9uKHIsdCl7UHJvZHVjdFJlZ2lzdHJ5SW1wbC5fcHJvZHVjdHNCeURvbWFpbkhhc2g9bmV3IE1hcH0sUHJvZHVjdFJlZ2lzdHJ5SW1wbC5fcHJvZHVjdHNCeURvbWFpbkhhc2g9bmV3IE1hcCxQcm9kdWN0UmVnaXN0cnlJbXBsLnJlZ2lzdGVyKFtdLFtdKSxQcm9kdWN0UmVnaXN0cnlJbXBsLnNoYTE9ZnVuY3Rpb24ocil7cmV0dXJuIiJ9Ow==';
+ electron.session.defaultSession.webRequest.onBeforeRequest((details, callback) => {
+   if ((/^devtools:\/\/devtools\/remote\/serve_file\/@[0-9a-f]{40}\/product_registry_impl\/product_registry_impl_module.js$/ui).test(details.url)) {
+     // eslint-disable-next-line
+     callback({
+       redirectURL
+     });
+     return;
+   }
+   // eslint-disable-next-line
+   callback({});
+ });
 }
 
 // This method will be called when Electron has finished
 // initialization and is ready to create browser windows.
 // Some APIs can only be used after this event occurs.
 app.on('ready', createWindow)
+

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.
@@ -239,6 +241,12 @@ export class Overmind<ThisConfig extends IConfiguration>
     this.eventHub = eventHub as EventEmitter<Events>
     this.mode = mode
 
+
+    /*
+      Expose the created actions
+    */
+    this.actions = this.getActions(configuration.actions)
+    
     if (mode.mode === MODE_SSR) {
       return
     }
@@ -343,11 +351,6 @@ export class Overmind<ThisConfig extends IConfiguration>
       })
     }
 
-    /*
-      Expose the created actions
-    */
-    this.actions = this.getActions(configuration.actions)
-
     if (mode.mode === MODE_DEFAULT && configuration.onInitialize) {
       const onInitialize = this.createAction(
         'onInitialize',

packages/node_modules/overmind/src/internalTypes.ts

@@ -5,7 +5,7 @@ import {
   ITrackStateTree,
 } from 'proxy-state-tree'
 
-import { IAction, IOperator, IState } from './types'
+import { IAction, IConfiguration, IDerive, IOperator, IState } from './types'
 
 export type SubType<Base, Condition> = Pick<
   Base,
@@ -151,12 +151,10 @@ export interface Events {
 
 // ============= PRIVATE TYPES FOR APP
 
-type Derived = (parent: any, config: any) => any
-
 export type ResolveState<State extends IState | null> = State extends undefined
   ? {}
   : {
-      [P in keyof State]: State[P] extends Derived
+      [P in keyof State]: State[P] extends IDerive<IConfiguration, IState, any>
         ? ReturnType<State[P]>
         : State[P] extends Array<any>
         ? State[P]

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,162 @@
+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.only('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,46 @@
+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]: <T>(entry?: () => T, exit?: () => void) => T
+}
+
+class Machine<States extends string>  {
+  current: States
+  private _currentExit: (() => void) | undefined
+  constructor(definition: StatemachineDefinition<States>) {
+    this.current = definition.initial
+
+    Object.keys(definition.states).reduce((aggr, key) => {
+      aggr[key] = (entry, exit) => {
+        if (definition.states[this.current].includes(key as any)) {
+          if (this._currentExit) this._currentExit()
+          this._currentExit = exit
+          this.current = key as any
+          return entry && entry()
+        }
+      }
+  
+      return aggr
+    }, this)
+  }
+  reset() {
+    if (this._currentExit) {
+      this._currentExit()
+      this._currentExit = undefined
+    }
+  }
+}
+
+export function statemachine<States extends string>(definition: StatemachineDefinition<States>): Statemachine<States> {
+  return new Machine(definition) as any
+}