回调式用法

const onDropNodeUpdateCallback = (
    dragNode,
    dropNode,
    callback: callbackType
  ) => {
    const name =
      dragNode.type === 'blob'
        ? dragNode?.name || dragNode?.title
        : String(dragNode?.path).split('/').pop()
    return callback(
      dragNode?.hasId,
      dropNode?.path,
      name,
      dragNode.type === 'blob'
    )
  }

  const onDropNodeCallback = (dragNode, dropNode, callback: callbackType) => {
    if (isEmpty(dragNode?.children)) {
      return onDropNodeUpdateCallback(dragNode, dropNode, callback)
    } else {
      onDropNodeUpdateCallback(dragNode, dropNode, callback)?.then(res => {
        if (res?.success) {
          return dragNode?.children?.map(node => {
            return onDropNodeCallback(
              node,
              {
                ...dropNode,
                path: `${dropNode?.path}/${String(dragNode?.path).split('/').pop()}`
              },
              callback
            )
          })
        }
      })
    }
  }

  const onDropNode = (
    info,
    treeDataClone,
    dragKey,
    dropKey,
    dropPosition,
    callback: callbackType
  ) => {
    let dragNode
    let dropNode
    loop(treeDataClone, dragKey, (node, key, data) => {
      data?.splice(key as number, 1)
      dragNode = node
    })

    if (!info.dropToGap) {
      loop(treeDataClone, dropKey, (node, key, data) => {
        node.children = node.children || []
        dropNode = node
        node.children.unshift(dragNode)
      })
    } else {
      let ar: FileNode[] = []
      let i: number
      loop(treeDataClone, dropKey, (node, key, data) => {
        ar = data as FileNode[]
        i = key as number
        dropNode = node
      })
      if (dropPosition === -1) {
        ar.splice(i!, 0, dragNode!)
      } else {
        ar.splice(i! + 1, 0, dragNode!)
      }
    }

    onDropNodeCallback(dragNode, dropNode, callback)?.finally(() =>
      mutateTreeFun()
    )
  }
复制