proxify.ts

const isPlainObject = require('is-plain-object')

export const IS_PROXY = Symbol('IS_PROXY')
export const PATH = Symbol('PATH')
export const VALUE = Symbol('VALUE')

export enum STATUS {
  IDLE = 'IDLE',
  TRACKING_PATHS = 'TRACKING_PATHS',
  TRACKING_MUTATIONS = 'TRACKING_MUTATIONS',
}

function concat(path, prop) {
  return path === undefined ? prop : path + '.' + prop
}

function shouldTrackMutations(tree, path) {
  return tree.options.devmode || (path && tree.pathDependencies[path])
}

const arrayMutations = new Set([
  'push',
  'shift',
  'pop',
  'unshift',
  'splice',
  'reverse',
  'sort',
  'copyWithin',
])

function createArrayProxy(tree, value, path) {
  return new Proxy(value, {
    get(target, prop) {
      if (prop === IS_PROXY) return true
      if (prop === PATH) return path
      if (prop === VALUE) return value

      if (
        prop === 'length' ||
        (typeof target[prop] === 'function' &&
          !arrayMutations.has(String(prop))) ||
        typeof prop === 'symbol'
      ) {
        return target[prop]
      }

      const nestedPath = concat(path, prop)
      if (tree.status === STATUS.TRACKING_PATHS) {
        tree.paths[tree.paths.length - 1].add(nestedPath)
      }

      if (
        arrayMutations.has(String(prop)) &&
        shouldTrackMutations(tree, nestedPath)
      ) {
        if (tree.status !== STATUS.TRACKING_MUTATIONS) {
          throw new Error(
            `proxy-state-tree - You are mutating the path "${nestedPath}", but it is not allowed`
          )
        }
        return (...args) => {
          tree.currentMutations.push({
            method: prop,
            path: path,
            args: args,
          })

          return target[prop](...args)
        }
      }

      if (target[prop] === undefined) {
        return undefined
      }

      return (target[prop] = proxify(tree, target[prop], nestedPath))
    },
    set(target, prop, value) {
      const nestedPath = concat(path, prop)

      if (tree.status !== STATUS.TRACKING_MUTATIONS) {
        throw new Error(
          `proxy-state-tree - You are mutating the path "${nestedPath}", but it is not allowed`
        )
      }
      if (value && value[IS_PROXY] === true) {
        throw new Error(
          `proxy-state-tree - You are trying to insert a value that already exists in the state tree on path "${
            value[PATH]
          }"`
        )
      }
      tree.currentMutations.push({
        method: 'set',
        path: nestedPath,
        args: [value],
      })
      return Reflect.set(target, prop, value)
    },
  })
}

function createObjectProxy(tree, value, path) {
  return new Proxy(value, {
    get(target, prop) {
      if (prop === IS_PROXY) return true
      if (prop === PATH) return path
      if (prop === VALUE) return value

      if (typeof prop === 'symbol' || prop in Object.prototype)
        return target[prop]

      const targetValue = target[prop]
      const nestedPath = concat(path, prop)
      if (tree.status === STATUS.TRACKING_PATHS) {
        tree.paths[tree.paths.length - 1].add(nestedPath)
      }

      if (typeof targetValue === 'function') {
        return tree.options.dynamicWrapper
          ? tree.options.dynamicWrapper(tree, nestedPath, targetValue)
          : targetValue(tree, nestedPath)
      }

      if (targetValue === undefined) {
        return undefined
      }

      return (target[prop] = proxify(tree, targetValue, nestedPath))
    },
    set(target, prop, value) {
      const nestedPath = concat(path, prop)

      if (tree.status !== STATUS.TRACKING_MUTATIONS) {
        throw new Error(
          `proxy-state-tree - You are mutating the path "${nestedPath}", but it is not allowed`
        )
      }
      if (value && value[IS_PROXY] === true) {
        throw new Error(
          `proxy-state-tree - You are trying to insert a value that already exists in the state tree on path "${
            value[PATH]
          }"`
        )
      }
      if (shouldTrackMutations(tree, nestedPath)) {
        if (!(prop in target)) {
          tree.objectChanges.add(path)
        }

        tree.currentMutations.push({
          method: 'set',
          path: nestedPath,
          args: [value],
        })
      }

      return Reflect.set(target, prop, value)
    },
    deleteProperty(target, prop) {
      const nestedPath = concat(path, prop)

      if (tree.status !== STATUS.TRACKING_MUTATIONS) {
        throw new Error(
          `proxy-state-tree - You are mutating the path "${nestedPath}", but it is not allowed`
        )
      }
      if (shouldTrackMutations(tree, nestedPath)) {
        if (prop in target) {
          tree.objectChanges.add(path)
        }

        tree.currentMutations.push({
          method: 'unset',
          path: nestedPath,
          args: [],
        })
      }

      delete target[prop]

      return true
    },
  })
}

function proxify(tree, value, path?) {
  if (value) {
    if (value[IS_PROXY] && value[PATH] !== path) {
      return proxify(tree, value[VALUE], path)
    } else if (value[IS_PROXY]) {
      return value
    } else if (Array.isArray(value)) {
      return createArrayProxy(tree, value, path)
    } else if (isPlainObject(value)) {
      return createObjectProxy(tree, value, path)
    }
  }
  return value
}

export default proxify