refactor(overmind): refactor types to work with override and simplify operations

Author: christianalfoni

packages/demos/react-todomvc/src/app/index.js

@@ -1,10 +1,10 @@
-import App from 'overmind'
+import Overmind from 'overmind'
 import createConnect from 'overmind-react'
 import * as effects from './effects'
 import * as actions from './actions'
 import * as state from './state'
 
-const app = new App({
+const app = new Overmind({
   state,
   actions,
   effects,

packages/demos/react-typescript-todomvc/src/app/actions.ts

@@ -1,6 +1,5 @@
 import * as React from 'react'
-
-import { Action } from './'
+import { Action } from 'overmind'
 import * as mutations from './mutations'
 import * as operations from './operations'
 import { Todo } from './state'

packages/demos/react-typescript-todomvc/src/app/index.ts

@@ -1,11 +1,4 @@
-import App, {
-  TAction,
-  TApp,
-  TContext,
-  TDerive,
-  TMutate,
-  TReaction,
-} from 'overmind'
+import Overmind, { TApp } from 'overmind'
 import createConnect, { TConnect } from 'overmind-react'
 
 import * as actions from './actions'
@@ -18,38 +11,14 @@ const config = {
   state,
 }
 
-const app = new App(config)
+declare module 'overmind' {
+  interface App extends TApp<typeof config> {}
+}
+
+const app = new Overmind(config)
 
 export type Connect = TConnect<typeof app>
 
 export const connect = createConnect(app)
 
-type IApp = TApp<typeof config>
-
 export default app
-
-// ==== The following types are copied from overmind documentation ====
-
-export type Action<Value = void, ReturnValue = Value> = TAction<
-  IApp,
-  Value,
-  ReturnValue
->
-
-export type Mutate<Value = any> = TMutate<IApp, Value>
-
-export type Context<Value> = TContext<IApp, Value>
-
-// Operations
-export type Map<Value, ReturnValue = Value> = (
-  ctx: Context<Value>
-) => ReturnValue
-export type Filter<Value = any> = (ctx: Context<Value>) => boolean
-export type When<Value = any> = (ctx: Context<Value>) => boolean
-export type Run<Value = any> = (ctx: Context<Value>) => void
-export type Fork<Value = any> = (ctx: Context<Value>) => string
-export type Attempt<Value, ReturnValue> = (ctx: Context<Value>) => ReturnValue
-
-export type Derive<Value> = TDerive<IApp, Value>
-
-export type Reaction = TReaction<IApp>

packages/demos/react-typescript-todomvc/src/app/mutations.ts

@@ -1,20 +1,20 @@
-import { Mutate } from './'
+import { Operation } from 'overmind'
 import { Todo } from './state'
 
 let nextTodoId = 0
 
-export const setNewTodoTitle: Mutate<string> = ({ state, value }) =>
+export const setNewTodoTitle: Operation.Mutate<string> = ({ state, value }) =>
   (state.newTodoTitle = value)
 
-export const addTodo: Mutate = ({ state }) =>
+export const addTodo: Operation.Mutate = ({ state }) =>
   state.todos.unshift({
     id: String(nextTodoId++),
     title: state.newTodoTitle,
     completed: false,
   })
 
-export const clearNewTodoTitle: Mutate = ({ state }) =>
+export const clearNewTodoTitle: Operation.Mutate = ({ state }) =>
   (state.newTodoTitle = '')
 
-export const toggleCompleted: Mutate<Todo> = ({ value: todo }) =>
+export const toggleCompleted: Operation.Mutate<Todo> = ({ value: todo }) =>
   (todo.completed = !todo.completed)

packages/demos/react-typescript-todomvc/src/app/operations.ts

@@ -1,9 +1,11 @@
-import { Map, Run } from './'
+import { Operation } from 'overmind'
 
 type ChangeEvent = React.ChangeEvent<HTMLInputElement>
 
-export const getEventValue: Map<ChangeEvent, string> = ({ value: event }) =>
-  event.currentTarget.value
+export const getEventValue: Operation.Map<ChangeEvent, string> = ({
+  value: event,
+}) => event.currentTarget.value
 
-export const preventEventDefault: Run<React.FormEvent> = ({ value: event }) =>
-  event.preventDefault()
+export const preventEventDefault: Operation.Run<React.FormEvent> = ({
+  value: event,
+}) => event.preventDefault()

packages/demos/vue-todomvc/src/app/index.js

@@ -1,10 +1,10 @@
-import App from 'overmind'
+import Overmind from 'overmind'
 import createConnect from 'overmind-vue'
 import * as effects from './effects'
 import * as actions from './actions'
 import * as state from './state'
 
-const app = new App(
+const app = new Overmind(
   {
     state,
     actions,

packages/node_modules/overmind-devtools/src/app/actions.ts

@@ -1,4 +1,4 @@
-import { Action } from './'
+import { Action } from 'overmind'
 import * as mutations from './mutations'
 import * as operations from './operations'
 import { Message, Tab } from './types'

packages/node_modules/overmind-devtools/src/app/index.ts

@@ -1,11 +1,4 @@
-import Overmind, {
-  TAction,
-  TApp,
-  TContext,
-  TDerive,
-  TMutate,
-  TReaction,
-} from 'overmind'
+import Overmind, { TApp } from 'overmind'
 import createConnect, { TConnect } from 'overmind-react'
 
 import * as actions from './actions'
@@ -18,35 +11,9 @@ const config = {
   state,
 }
 
-type App = TApp<typeof config>
-
-export type Action<Value = void, ReturnValue = any> = TAction<
-  App,
-  Value,
-  ReturnValue
->
-
-export type Mutate<Value = any> = TMutate<App, Value>
-
-export type Context<Value> = TContext<App, Value>
-
-export type Map<Value, ReturnValue = Value> = (
-  ctx: Context<Value>
-) => ReturnValue
-
-export type Filter<Value = any> = (ctx: Context<Value>) => boolean
-
-export type When<Value = any> = (ctx: Context<Value>) => boolean
-
-export type Run<Value = any> = (ctx: Context<Value>) => void
-
-export type Fork<Value = any> = (ctx: Context<Value>) => string
-
-export type Attempt<Value, ReturnValue> = (ctx: Context<Value>) => ReturnValue
-
-export type Derive<Value> = TDerive<App, Value>
-
-export type Reaction = TReaction<App>
+declare module 'overmind' {
+  interface App extends TApp<typeof config> {}
+}
 
 const app = new Overmind(config, {
   devtools: false,

packages/node_modules/overmind-devtools/src/app/mutations.ts

@@ -1,4 +1,4 @@
-import { Mutate } from './'
+import { Operation } from 'overmind'
 import {
   ActionGroupItem,
   ActionItem,
@@ -14,24 +14,26 @@ import {
   runMutation,
 } from './utils'
 
-export const setPort: Mutate<string> = ({ state, value: port }) => {
+export const setPort: Operation.Mutate<string> = ({ state, value: port }) => {
   if (port) {
     state.port = port
   }
 }
 
-export const selectApp: Mutate<string> = ({ state, value: appName }) =>
-  (state.currentAppName = appName)
+export const selectApp: Operation.Mutate<string> = ({
+  state,
+  value: appName,
+}) => (state.currentAppName = appName)
 
-export const setConnecting: Mutate = ({ state }) => {
+export const setConnecting: Operation.Mutate = ({ state }) => {
   state.error = null
   state.isConnecting = true
 }
 
-export const setPortExists: Mutate = ({ state }) =>
+export const setPortExists: Operation.Mutate = ({ state }) =>
   (state.error = 'PORT_EXISTS')
 
-export const ensureCurrentApp: Mutate<Message> = ({
+export const ensureCurrentApp: Operation.Mutate<Message> = ({
   state,
   value: message,
 }) => {
@@ -40,27 +42,27 @@ export const ensureCurrentApp: Mutate<Message> = ({
   }
 }
 
-export const setError: Mutate<string> = ({ state, value: error }) =>
+export const setError: Operation.Mutate<string> = ({ state, value: error }) =>
   (state.error = error)
 
-export const setNewPortValue: Mutate<string> = ({ state, value }) =>
+export const setNewPortValue: Operation.Mutate<string> = ({ state, value }) =>
   (state.newPortValue = value)
 
-export const resetNewPortValue: Mutate = ({ state }) =>
+export const resetNewPortValue: Operation.Mutate = ({ state }) =>
   (state.newPortValue = '')
 
-export const addMessagesFromClient: Mutate<Message> = ({
+export const addMessagesFromClient: Operation.Mutate<Message> = ({
   state,
   value: message,
 }) =>
   (state.apps[message.appName].messages = message.messages
     .reverse()
     .concat(state.apps[message.appName].messages))
 
-export const changeTab: Mutate<Tab> = ({ state, value: tab }) =>
+export const changeTab: Operation.Mutate<Tab> = ({ state, value: tab }) =>
   (state.currentTab = tab)
 
-export const toggleExpandStatePath: Mutate<string[]> = ({
+export const toggleExpandStatePath: Operation.Mutate<string[]> = ({
   state,
   value: path,
 }) => {
@@ -76,7 +78,7 @@ export const toggleExpandStatePath: Mutate<string[]> = ({
   }
 }
 
-export const performMutationsByMessageType: Mutate<Message> = ({
+export const performMutationsByMessageType: Operation.Mutate<Message> = ({
   state,
   value: message,
 }) => {
@@ -325,7 +327,7 @@ export const performMutationsByMessageType: Mutate<Message> = ({
   })
 }
 
-export const toggleActionItemCollapse: Mutate<string> = ({
+export const toggleActionItemCollapse: Operation.Mutate<string> = ({
   state,
   value: actionId,
 }) => {
@@ -342,21 +344,25 @@ export const toggleActionItemCollapse: Mutate<string> = ({
   }
 }
 
-export const selectAction: Mutate<string> = ({ state, value: actionId }) =>
-  (state.currentApp.currentActionId = actionId)
+export const selectAction: Operation.Mutate<string> = ({
+  state,
+  value: actionId,
+}) => (state.currentApp.currentActionId = actionId)
 
 type Collapse = {
   isCollapsed: boolean
 }
 
-export const toggleCollapsed: Mutate<Collapse> = ({ value: item }) => {
+export const toggleCollapsed: Operation.Mutate<Collapse> = ({
+  value: item,
+}) => {
   item.isCollapsed = !item.isCollapsed
 }
 
-export const toggleExpandAllActions: Mutate = ({ state }) =>
+export const toggleExpandAllActions: Operation.Mutate = ({ state }) =>
   (state.expandAllActionDetails = !state.expandAllActionDetails)
 
-export const toggleGroupedComponent: Mutate<string> = ({
+export const toggleGroupedComponent: Operation.Mutate<string> = ({
   state,
   value: name,
 }) => {

packages/node_modules/overmind-devtools/src/app/operations.ts

@@ -1,30 +1,32 @@
-import { When, Filter, Map, Run } from './'
+import { Operation } from 'overmind'
 import { Message } from './types'
 
-export const isPortExistsMessage: When<Message> = ({ value: message }) =>
-  message.messages[0].type === 'PORT_EXISTS'
+export const isPortExistsMessage: Operation.When<Message> = ({
+  value: message,
+}) => message.messages[0].type === 'PORT_EXISTS'
 
-export const confirm: (text: string) => Filter = (text) => ({ utils }) =>
-  utils.confirmDialog(text)
+export const confirm: (text: string) => Operation.Filter = (text) => ({
+  utils,
+}) => utils.confirmDialog(text)
 
-export const getCurrentPortFromStorage: Map<any, Promise<string>> = ({
+export const getCurrentPortFromStorage: Operation.Map<any, Promise<string>> = ({
   storage,
 }) => storage.get<string>('currentPort')
 
-export const getNewPortFromState: Map<any, string> = ({ state }) =>
+export const getNewPortFromState: Operation.Map<any, string> = ({ state }) =>
   state.newPortValue
 
-export const toNumber: Map<string, string> = ({ value }) =>
+export const toNumber: Operation.Map<string, string> = ({ value }) =>
   String(Number(value))
 
-export const connectCurrentPort: (action: (message: any) => void) => Run = (
-  action
-) => ({ state, connector }) => {
+export const connectCurrentPort: (
+  action: (message: any) => void
+) => Operation.Run = (action) => ({ state, connector }) => {
   connector.connect(
     state.port,
     action
   )
 }
 
-export const isNotExpandingAllActions: Filter = ({ state }) =>
+export const isNotExpandingAllActions: Operation.Filter = ({ state }) =>
   !state.expandAllActionDetails