refactor: define inline access modifiers and initializers

Author: Guria

packages/node_modules/action-chain/src/ActionBase.ts

@@ -1,10 +1,7 @@
 import { ActionChain, Execution, ExecutionContext } from './ActionChain'
 
 export class StopExecution {
-  value: any
-  constructor(value) {
-    this.value = value
-  }
+  constructor(public value) {}
 }
 export class ActionBase<Effects> {
   static nextActionId: number = 0

packages/node_modules/betsy/src/index.ts

@@ -4,11 +4,7 @@ export type Listener = {
 }
 
 export class EventEmitter<T> {
-  private events: Map<keyof T, Listener[]>
-
-  constructor() {
-    this.events = new Map()
-  }
+  private events = new Map<keyof T, Listener[]>()
 
   emit<K extends keyof T>(event: K, msg: T[K]) {
     const listeners = this.events.get(event) || []

packages/node_modules/overmind/src/Action.ts

@@ -1,5 +1,5 @@
 import ProxyStateTree from 'proxy-state-tree'
-import { ActionBase, StopExecution } from 'action-chain'
+import { ActionBase, StopExecution, ActionChain } from 'action-chain'
 
 type OperatorCallback<Effects, Value, NewValue = Value> = (
   effects: Effects,
@@ -30,10 +30,13 @@ export default class Action<
   InitialValue,
   Value = InitialValue
 > extends ActionBase<Effects> {
-  private proxyStateTree: ProxyStateTree
-  constructor(proxyStateTree, actionChain, initialActionId?, runOperators?) {
+  constructor(
+    private proxyStateTree: ProxyStateTree,
+    actionChain: ActionChain<Effects>,
+    initialActionId?: number,
+    runOperators?
+  ) {
     super(actionChain, initialActionId, runOperators)
-    this.proxyStateTree = proxyStateTree
   }
   fork: <Paths>(
     cb: (effects: Effects, value: Value) => keyof Paths,

packages/node_modules/overmind/src/Devtools.ts

@@ -40,20 +40,12 @@ function debounce(func, wait) {
 }
 
 export default class Devtools {
-  buffer: string[]
-  ws: WebSocket
-  isConnected: boolean
-  doReconnect: boolean
-  hasWarnedReconnect: boolean
-  reconnectInterval: number
-  constructor() {
-    this.ws = null
-    this.isConnected = false
-    this.doReconnect = false
-    this.reconnectInterval = 10000
-    this.hasWarnedReconnect = false
-    this.buffer = []
-  }
+  private buffer: string[] = []
+  private ws: WebSocket = null
+  private isConnected: boolean = false
+  private doReconnect: boolean = false
+  private hasWarnedReconnect: boolean = false
+  private reconnectInterval: number = 10000
   connect = (host: string, onMessage: (message: Message) => void) => {
     this.ws = new WebSocket(`ws://${host}`)
     this.ws.onmessage = (event) => onMessage(JSON.parse(event.data))

packages/node_modules/overmind/src/computed.ts

@@ -15,12 +15,13 @@ type Cache = {
 }
 
 export class Computed {
-  cb: (config: any) => (state: object) => void
-  cacheLimit: number = 10
-  cacheKeys: Cache[] = []
-  cache: Map<any, Cache> = new Map()
-  constructor(cb, options: ComputedOptions = {}) {
-    this.cb = cb
+  private cacheLimit: number = 10
+  private cacheKeys: Cache[] = []
+  private cache: Map<any, Cache> = new Map()
+  constructor(
+    private cb: (config: any) => (state: object) => void,
+    options: ComputedOptions = {}
+  ) {
     this.cacheLimit = options.cacheLimit || this.cacheLimit
     return this.evaluate.bind(this)
   }

packages/node_modules/overmind/src/derived.ts

@@ -3,18 +3,12 @@ import ProxyStateTree from 'proxy-state-tree'
 import { Events, EventType } from './'
 
 class Derived {
-  isDirty: boolean
-  proxyStateTreeListener: any
-  value: any
-  cb: (state: object) => void
-  paths: Set<string>
-  updateCount: number
-  constructor(cb) {
-    this.isDirty = true
-    this.proxyStateTreeListener = null
-    this.value = null
-    this.cb = cb
-    this.updateCount = 0
+  private isDirty: boolean = true
+  private proxyStateTreeListener: any = null
+  private value: any = null
+  private paths: Set<string>
+  private updateCount: number = 0
+  constructor(private cb: (state: object) => void) {
     return this.evaluate.bind(this)
   }
   evaluate(

packages/node_modules/overmind/src/reaction.ts

@@ -3,23 +3,14 @@ import ProxyStateTree from 'proxy-state-tree'
 import { Events, EventType } from './'
 
 class Reaction {
-  eventHub: EventEmitter<Events>
-  proxyStateTree: ProxyStateTree
-  path: string
-  proxyStateTreeListener: any
-  statePath: string
-  updateCount: number
+  private proxyStateTreeListener: any = null
+  private updateCount: number = 0
+  private statePath: string
   constructor(
-    eventHub: EventEmitter<Events>,
-    proxyStateTree: ProxyStateTree,
-    path
-  ) {
-    this.eventHub = eventHub
-    this.proxyStateTree = proxyStateTree
-    this.path = path
-    this.proxyStateTreeListener = null
-    this.updateCount = 0
-  }
+    private eventHub: EventEmitter<Events>,
+    private proxyStateTree: ProxyStateTree,
+    private path: string
+  ) {}
   create(stateCb: (state: object) => any, cb: any) {
     const trackId = this.proxyStateTree.startPathsTracking()
     stateCb(this.proxyStateTree.get())

packages/node_modules/proxy-state-tree/src/index.ts

@@ -13,18 +13,16 @@ export type Mutation = {
 }
 
 class ProxyStateTree {
-  state: object
-  options: Options
-  pathDependencies: object
-  globalDependencies: Set<Function>
-  objectChanges: Set<string>
-  mutations: Mutation[]
-  currentMutations: Mutation[]
-  paths: Set<string>[]
-  status: STATUS
-  proxy: any
-  currentFlushId: number
-  constructor(state: object, options: Options = {}) {
+  pathDependencies: object = {}
+  private globalDependencies = new Set<Function>()
+  private objectChanges = new Set<string>()
+  private mutations: Mutation[] = []
+  private currentMutations: Mutation[] = []
+  private paths: Set<string>[] = []
+  private status: STATUS = STATUS.IDLE
+  private currentFlushId: number = 0
+  private proxy: any
+  constructor(private state: object, private options: Options = {}) {
     if (!isPlainObject(state)) {
       throw new Error(
         'You did not pass a plain object as state to Proxy State Tree'
@@ -35,17 +33,7 @@ class ProxyStateTree {
       options.devmode = true
     }
 
-    this.state = state
-    this.options = options
-    this.pathDependencies = {}
-    this.globalDependencies = new Set()
-    this.mutations = []
-    this.currentMutations = []
-    this.paths = []
-    this.objectChanges = new Set()
-    this.status = STATUS.IDLE
     this.proxy = proxify(this, state)
-    this.currentFlushId = 0
   }
   get() {
     return this.proxy