How to use @uform/types - 10 common examples

export function getPathSegments(path: Path): ArrayPath {
  if (isArr(path)) {
    return path as string[]
  }
  if (isStr(path) && path) {
    const cached = PathCache.get(path)
    if (cached) {
      return cached
    }
    const pathArr = (path as string).split('.')
    const parts = []

    for (let i = 0; i < pathArr.length; i++) {
      let p = pathArr[i]

      while (p[p.length - 1] === '\\' && pathArr[i + 1] !== undefined) {
        p = p.slice(0, -1) + '.'
        p += pathArr[++i]

export function getPathSegments(path: Path): ArrayPath {
  if (isArr(path)) {
    return path as string[]
  }
  if (isStr(path) && path) {
    const cached = PathCache.get(path)
    if (cached) {
      return cached
    }
    const pathArr = (path as string).split('.')
    const parts = []

    for (let i = 0; i < pathArr.length; i++) {
      let p = pathArr[i]

      while (p[p.length - 1] === '\\' && pathArr[i + 1] !== undefined) {
        p = p.slice(0, -1) + '.'
        p += pathArr[++i]
      }

      parts.push(p)

if (!isObj(obj) || !path) {
    return
  }

  path = toString(path)

  if (path in obj) {
    obj[path as string] = value
    return
  }

  const pathArr = getPathSegments(path)

  for (let i = 0; i < pathArr.length; i++) {
    const p = pathArr[i]
    if (!isObj(obj[p])) {
      if (obj[p] === undefined && value === undefined) {
        return
      }
      if (/^\d+$/.test(pathArr[i + 1 + ''])) {
        if (getSchema) {
          const schema = getSchema(pathArr.slice(0, i) as string[])

          if (!schema || schema.type === 'array') {
            obj[p] = []
          } else {
            obj[p] = {}
          }
        } else {
          obj[p] = []
        }
      } else {

function toString(val: Path | null) {
  if (!val) {
    return ''
  }
  if (isArr(val)) {
    return (val as string[]).join('.')
  }
  return isStr(val) ? val : ''
}

destructKey(key, readyReplace) {
      if (!key) {
        return
      }
      token = key
      if (readyReplace) {
        realKey = key
        lastDestruct = destruct
        return
      }
      if (isArr(destruct)) {
        ;(destruct as string[]).push(key)
      } else if (isPlainObj(destruct)) {
        destruct[realKey && lastDestruct === destruct ? realKey : key] = key
      }
      realKey = ''
      lastDestruct = destruct
    },
    destructArrayStart() {

return (
    obj: any,
    path: Path,
    value?: any,
    getSchema?: (path: string[] | number[]) => any
  ) => {
    let paths: any = []
    if (!cache.get(path)) {
      paths = parsePaths(path)
      cache.set(path, paths)
    } else {
      paths = cache.get(path)
    }
    if (!isArr(paths)) {
      return update(obj, path, value, getSchema)
    }
    if (paths && paths.length) {
      each(paths, ({ mapPath, key, startPath, endPath }) => {
        update(
          obj,
          startPath.concat(key),
          internalGetIn(value, endPath),
          getSchema
        )
      })
    }
    return obj
  }
}

return (obj: any, path: Path, value?: any): any => {
    let ast = null

    if (!cache.get(path)) {
      ast = parseDesturctPath(path)
      cache.set(path, ast)
    } else {
      ast = cache.get(path)
    }
    if (!isArr(ast.destruct) && !isPlainObj(ast.destruct)) {
      return get(obj, path, value)
    }
    return mapReduce(ast.destruct, (mapPath, key) => {
      return get(obj, ast.startPath.concat(key[key.length - 1]))
    })
  }
}

destructObjectStart() {
      if (!destruct) {
        root = {}
        destruct = root
      } else {
        destruct = {}
      }
      const tail = stack[stack.length - 1]
      if (isPlainObj(tail)) {
        tail[token] = destruct
      } else if (isArr(tail)) {
        tail.push(destruct)
      }
      stack.push(destruct)
    },
    destructArrayEnd() {

function toString(val: Path | null) {
  if (!val) {
    return ''
  }
  if (isArr(val)) {
    return (val as string[]).join('.')
  }
  return isStr(val) ? val : ''
}

const internalTraverse = (internalObj: any, path: string[]) => {
    if (isStr(internalObj)) {
      return callback(internalObj, internalObj)
    }
    each(internalObj, (item: any, key: string) => {
      const newPath = path.concat(key)
      if (isArr(item) || isPlainObj(item)) {
        internalTraverse(item, newPath)
      } else {
        callback(newPath, item)
      }
    })
  }