树结构重组 根据code与parentCode拼装树结构

/**
 * 拼装树结构
 * @param {*} data
 * @param {string} sortField 排序字段
 * @param {string} order 顺序  positive = 正序  inverted = 倒序
 * @returns
 */
export const AssemblyTreeData = (data, sortField = "sortNo", order = "inverted") => {
 
  const tree = {}
  for (const element of data) {
    const {code} = element
    tree[code] = {...element, children: []};
  }
  for (const element of data) {
    const {code, parentCode} = element
    // 有可能tree[parentCode]不存在
    if (parentCode !== null && parentCode !== '' && tree[parentCode]) {
      tree[parentCode].children.push(tree[code]);
    }
  }
  //排序
  for (const code in tree) {
    const node = tree[code]
    if (order === 'positive') {
      node.children.sort((a, b) => a[sortField] - b[sortField]);
    } else {
      node.children.sort((a, b) => b[sortField] - a[sortField]);
    }
  }
  const collectTreeCode = (codeList,node) => {
    if (!node){
        return codeList;
    }
    codeList.push(node.code)
    if (node?.children?.length){
        for (const child of node.children){
            collectTreeCode(codeList,child)
        }
    }
};
  //删除能在子级找到的父级
  const deleteList = [];
  for (const code in tree) {
      const node = tree[code];
      if (tree[node.parentCode]) {
          collectTreeCode(deleteList, node);
      }
  }
 
  deleteList.forEach(code => {
      delete tree[code];
  });
  let treeArr = []
  for (const code in tree) {
    treeArr.push(tree[code])
  }
 
  if (order === 'positive') {
    treeArr.sort((a, b) => a[sortField] - b[sortField]);
  } else {
    treeArr.sort((a, b) => b[sortField] - a[sortField]);
  }
  return treeArr
}