state.ts

import { derive } from 'overmind'
import * as derived from './derived'

export type Mutation = {
  args: any[]
  method: string
  path: string
}

export type Effect = {
  args: any[]
  method: string
  name: string
  result: any
}

export enum ActionsListItemType {
  ACTION = 'ACTION',
  GROUP = 'GROUP',
}

export type ActionItem = {
  type: ActionsListItemType.ACTION
  id: string
  actionId: string
}

export type ActionGroupItem = {
  type: ActionsListItemType.GROUP
  id: string
  actionId: string
  isCollapsed: boolean
  actionIds: string[]
}

export type ActionsListItem = ActionItem | ActionGroupItem

export type Operator = {
  name: string
  actionId: number
  executionId: number
  isAsync: boolean
  isRunning: boolean
  isCollapsed: boolean
  operatorId: number
  mutations: Mutation[]
  effects: Effect[]
  path: string[]
  type: string
  result: any
}

export type Operators = {
  [id: string]: Operator
}

export type Action = {
  actionName: string
  actionId: number
  executionId: number
  isRunning: boolean
  operators: Operators
  value: any
}

export type Actions = {
  [id: string]: Action
}

export type Flush = {
  flushId: number
  mutations: Mutation[]
  components: string[]
  derived: string[]
  computed: string[]
}

export type FlushReference = {
  flushId: number
  isCollapsed: boolean
}

export type Flushes = {
  [id: string]: Flush
}

export type Component = {
  id: string
  name: string
  isMounted: boolean
  paths: string[]
  updateCount: number
}

export type Derived = {
  flushId: number
  path: string
  paths: string[]
  updateCount: number
  value: any
}

export type Computed = {
  cacheKeyIndex: number
  cacheKeysCount: number
  flushId: number
  limit: number
  path: string
  paths: string[]
  updateCount: number
  value: number
}

export type Components = {
  [id: string]: Component
}

export type DerivedMap = {
  [path: string]: Derived
}

export type ComputedMap = {
  [path: string]: Computed
}

export type App = {
  name: string
  port: string
  messages: AppMessage[]
  state: object
  components: Components
  derived: Derived
  computed: Computed
  flushes: Flushes
  flushByActionId: {
    [id: string]: FlushReference
  }
  flushByOperatorId: {
    [id: string]: FlushReference
  }
  actions: Actions
  actionsList: ActionsListItem[]
  currentActionId: string
}

export type Apps = {
  [port: string]: App
}

export type AppMessage = {
  type: string
  data: any
}

export type Message = {
  port: string
  message: AppMessage[]
}

export enum Tab {
  Actions = 'Actions',
  State = 'State',
  Console = 'Console',
  Components = 'Components',
  Flushes = 'Flushes',
  Remove = 'Remove',
}

export type State = {
  isConnecting: boolean
  isLoading: boolean
  isAddingPort: boolean
  error: string
  currentPort: string
  apps: Apps
  newPortValue: string
  currentTab: Tab
  expandedStatePaths: string[]
  currentApp: App
  componentsMounted: Component[]
  componentsUpdateCount: number
  componentsStatePathCount: number
  flushes: Flush[]
  flushesMutationsCount: number
  flushesStatePathCount: number
  currentAction: Action
}

const state: State = {
  isConnecting: true,
  isLoading: true,
  isAddingPort: false,
  error: null,
  currentPort: null,
  apps: {},
  newPortValue: '',
  currentTab: Tab.State,
  expandedStatePaths: [''],
  currentApp: derive(derived.currentApp),
  componentsMounted: derive(derived.componentsMounted),
  componentsUpdateCount: derive(derived.componentsUpdateCount),
  componentsStatePathCount: derive(derived.componentsStatePathCount),
  flushes: derive(derived.flushes),
  flushesMutationsCount: derive(derived.flushesMutationsCount),
  flushesStatePathCount: derive(derived.flushesStatePathCount),
  currentAction: derive(derived.currentAction),
}

export default state