index.ts

import { IS_PROXY, VALUE, PATH, STATUS, proxify } from './proxify'
const isPlainObject = require('is-plain-object')
const IS_PRODUCTION = process.env.NODE_ENV === 'production'

export type Options = {
  devmode?: boolean
  dynamicWrapper?: Function
}

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

export type MutationCallback = (
  mutation: Mutation,
  paths: Set<string>,
  flushId: number
) => void

let hasWarnedFlushWhileTracking = false

export class ProxyStateTree {
  pathDependencies: object = {}
  private parentTree: ProxyStateTree
  private globalDependencies = new Set<Function>()
  private objectChanges = new Set<string>()
  private mutations: Mutation[] = []
  private currentMutations: Mutation[] = []
  private paths: Set<string>[] = []
  private status: Set<STATUS> = new Set()
  private currentFlushId: number = 0
  private completedTrackingCallbacks = []
  private mutationCallbacks: MutationCallback[] = []
  private proxy: any
  private PROXY = Symbol('TREE_INSTANCE')
  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'
      )
    }

    if (typeof options.devmode === 'undefined') {
      options.devmode = true
    }

    this.proxy = proxify(this, state)
  }
  private addMutation(mutation: Mutation) {
    this.currentMutations.push(mutation)
    const paths = new Set([...this.objectChanges, mutation.path])

    if (this.parentTree) {
      for (let cb of this.parentTree.mutationCallbacks) {
        cb(mutation, paths, this.parentTree.currentFlushId + 1)
      }
      for (let cb of this.mutationCallbacks) {
        cb(mutation, paths, this.parentTree.currentFlushId + 1)
      }
    } else {
      for (let cb of this.mutationCallbacks) {
        cb(mutation, paths, this.currentFlushId + 1)
      }
    }
  }
  get() {
    return this.proxy
  }
  getScopedTree() {
    const instance = new ProxyStateTree(this.state, this.options)
    instance.parentTree = this

    return instance
  }
  scope(value) {
    return value && value[IS_PROXY]
      ? proxify(this, value[VALUE], value[PATH])
      : value
  }
  addTrackingPath(path) {
    if (this.status.has(STATUS.TRACKING_PATHS)) {
      this.paths[this.paths.length - 1].add(path)
    }
  }
  flush() {
    const paths = new Set()
    const pathCallbacksToCall = new Set()
    const mutations = this.mutations.slice()

    if (
      this.status.has(STATUS.TRACKING_PATHS) &&
      !hasWarnedFlushWhileTracking
    ) {
      console.warn(
        'PROXY-STATE-TREE has detected that it is flushing out mutations while tracking state changes. Please report this warning with information about any unexpected behaviour'
      )
      hasWarnedFlushWhileTracking = true
    }

    const tree = this.parentTree || this
    const flushId = tree.currentFlushId++

    for (let objectChange of tree.objectChanges) {
      if (tree.pathDependencies[objectChange]) {
        paths.add(objectChange)
      }
    }

    for (let mutation of mutations) {
      paths.add(mutation.path)
    }

    // Sort so that parent paths are called first
    const sortedPaths = Array.from(paths).sort()

    for (let path of sortedPaths) {
      if (tree.pathDependencies[path]) {
        for (let callback of tree.pathDependencies[path]) {
          pathCallbacksToCall.add(callback)
        }
      }
    }

    for (let callback of pathCallbacksToCall) {
      callback(flushId)
    }

    paths.clear()
    pathCallbacksToCall.clear()
    this.mutations.length = 0
    tree.objectChanges.clear()

    for (let globalDependency of tree.globalDependencies) {
      globalDependency(mutations, flushId)
    }

    return {
      mutations,
      flushId,
    }
  }
  startMutationTracking() {
    this.status.add(STATUS.TRACKING_MUTATIONS)
  }
  clearMutationTracking() {
    const currentMutations = this.currentMutations.slice()

    this.status.delete(STATUS.TRACKING_MUTATIONS)
    this.currentMutations.length = 0
    this.mutations = this.mutations.concat(currentMutations)

    return currentMutations
  }
  startPathsTracking() {
    this.status.add(STATUS.TRACKING_PATHS)

    return this.paths.push(new Set()) - 1
  }
  clearPathsTracking(index: number, cb?: () => void) {
    const pathSet = this.paths.splice(index, 1, null)[0]

    while (this.paths[this.paths.length - 1] === null) {
      this.paths.pop()
    }

    if (cb) {
      this.completedTrackingCallbacks.push(cb)
    }

    if (!this.paths.length) {
      this.status.delete(STATUS.TRACKING_PATHS)
      while (this.completedTrackingCallbacks.length) {
        this.completedTrackingCallbacks.shift()()
      }
    }

    return pathSet
  }
  addMutationListener(cb: MutationCallback) {
    const index = this.mutationCallbacks.push(cb) - 1

    return () => {
      this.mutationCallbacks.splice(index, 1)
    }
  }
  addFlushListener(cb: (mutations: Mutation[], flushId: number) => void)
  addFlushListener(initialPaths: Set<string>, cb: (flushId: number) => void)
  addFlushListener() {
    if (arguments.length === 1) {
      const cb = arguments[0]
      const globalDependencies = this.globalDependencies
      globalDependencies.add(cb)

      return {
        dispose() {
          globalDependencies.delete(cb)
        },
      }
    } else {
      const initialPaths = arguments[0]
      const cb = arguments[1]
      const pathDependencies = this.pathDependencies
      let currentStringPaths = initialPaths

      for (let currentStringPath of currentStringPaths) {
        pathDependencies[currentStringPath] = pathDependencies[
          currentStringPath
        ]
          ? pathDependencies[currentStringPath].add(cb)
          : new Set([cb])
      }

      return {
        update(newStringPaths: Set<string>) {
          for (let currentStringPath of currentStringPaths) {
            if (!newStringPaths.has(currentStringPath)) {
              pathDependencies[currentStringPath].delete(cb)
            }
          }

          for (let newStringPath of newStringPaths) {
            if (!currentStringPaths.has(newStringPath)) {
              pathDependencies[newStringPath] = pathDependencies[newStringPath]
                ? pathDependencies[newStringPath].add(cb)
                : new Set([cb])
            }
          }

          currentStringPaths = newStringPaths
        },
        dispose() {
          for (let currentStringPath of currentStringPaths) {
            pathDependencies[currentStringPath].delete(cb)

            if (pathDependencies[currentStringPath].size === 0) {
              delete pathDependencies[currentStringPath]
            }
          }
        },
      }
    }
  }
}

export { IS_PROXY, VALUE, PATH }