初始化

src/views/system/shared/menu-tree.ts

@@ -0,0 +1,92 @@
+type TreeNode = {
+  id: number;
+  parentId: number;
+  sort?: number | null;
+  children?: TreeNode[] | null;
+};
+
+export function buildMenuTree<T extends TreeNode>(list: T[]) {
+  const nodeMap = new Map<number, T>();
+  const roots: T[] = [];
+
+  list.forEach(item => {
+    nodeMap.set(item.id, {
+      ...item,
+      children: []
+    });
+  });
+
+  nodeMap.forEach(node => {
+    if (node.parentId === 0) {
+      roots.push(node);
+      return;
+    }
+
+    const parent = nodeMap.get(node.parentId);
+
+    if (!parent) {
+      roots.push(node);
+      return;
+    }
+
+    parent.children = [...(parent.children ?? []), node];
+  });
+
+  return sortMenuTree(roots);
+}
+
+export function collectDescendantIds<T extends Pick<TreeNode, 'id' | 'children'>>(nodes: T[], targetId: number) {
+  const target = findTreeNode(nodes, targetId);
+
+  if (!target?.children?.length) {
+    return [];
+  }
+
+  const ids: number[] = [];
+
+  walkTree(target.children, item => {
+    ids.push(item.id);
+  });
+
+  return ids;
+}
+
+function sortMenuTree<T extends TreeNode>(nodes: T[]) {
+  const sortedNodes = [...nodes].sort((prev, next) => Number(prev.sort ?? 0) - Number(next.sort ?? 0));
+
+  sortedNodes.forEach(node => {
+    if (node.children?.length) {
+      node.children = sortMenuTree(node.children as T[]);
+    }
+  });
+
+  return sortedNodes;
+}
+
+function findTreeNode<T extends Pick<TreeNode, 'id' | 'children'>>(nodes: T[], targetId: number): T | null {
+  for (const node of nodes) {
+    if (node.id === targetId) {
+      return node;
+    }
+
+    if (node.children?.length) {
+      const target = findTreeNode(node.children as unknown as T[], targetId);
+
+      if (target) {
+        return target;
+      }
+    }
+  }
+
+  return null;
+}
+
+function walkTree<T extends Pick<TreeNode, 'id' | 'children'>>(nodes: T[], callback: (node: T) => void) {
+  for (const node of nodes) {
+    callback(node);
+
+    if (node.children?.length) {
+      walkTree(node.children as unknown as T[], callback);
+    }
+  }
+}