refactor(overmind-devtools): refactor to new typing

Author: christianalfoni

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

@@ -1,7 +1,7 @@
 import { Action } from './'
 import * as mutations from './mutations'
 import * as operations from './operations'
-import { GroupedComponent, Message, Tab } from './types'
+import { Message, Tab } from './types'
 
 const handleClientMessages: Action<Message> = (action) =>
   action

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

@@ -1,4 +1,4 @@
-import App, {
+import Overmind, {
   TAction,
   TApp,
   TContext,
@@ -18,41 +18,42 @@ const config = {
   state,
 }
 
-const app = new App(config, {
-  devtools: false,
-})
-
-export type Connect = TConnect<typeof app>
-
-export const connect = createConnect(app)
+type App = TApp<typeof config>
 
-export default app
-
-// === copy/paste
-
-type IApp = TApp<typeof config>
 export type Action<Value = void, ReturnValue = any> = TAction<
-  IApp,
+  App,
   Value,
   ReturnValue
 >
 
-export type Mutate<Value = any> = TMutate<IApp, Value>
+export type Mutate<Value = any> = TMutate<App, Value>
 
-export type Context<Value> = TContext<IApp, Value>
+export type Context<Value> = TContext<App, Value>
 
-// Operations
-export namespace Operation {
-  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 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 Derive<Value> = TDerive<IApp, Value>
+export type Run<Value = any> = (ctx: Context<Value>) => void
 
-export type Reaction = TReaction<IApp>
+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>
+
+const app = new Overmind(config, {
+  devtools: false,
+})
+
+export type Connect = TConnect<typeof app>
+
+export const connect = createConnect(app)
+
+export default app

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

@@ -3,7 +3,6 @@ import {
   ActionGroupItem,
   ActionItem,
   ActionsListItemType,
-  GroupedComponent,
   Message,
   Tab,
 } from './types'

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

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