refactor: refactored flattenData and findAllParents methods and added tests (#418)

Author: simonguo

src/@types/common.ts

@@ -20,9 +20,9 @@ export type TableSizeChangeEventName =
   | 'widthChanged'
   | 'heightChanged';
 
-export interface RowDataType {
+export interface RowDataType<T = never> {
   dataKey?: string;
-  children?: RowDataType[];
+  children?: T[];
   [key: string]: any;
 }
 

src/utils/findAllParents.ts

@@ -1,29 +1,20 @@
 import { PARENT_KEY } from '../constants';
-import type { RowKeyType, RowDataType } from '../@types/common';
+import type { RowDataType, RowKeyType } from '../@types/common';
 
 /**
- * Find all parent nodes of a node
+ * Get all parent nodes of the given node in the flattened data
+ * @param node target node
  */
-export default function findAllParents<Row extends RowDataType, Key>(
-  rowData: Row,
-  rowKey: RowKeyType
-): Key[] {
+function findAllParents<Row extends RowDataType, Key>(node: Row, rowKey: RowKeyType): Key[] {
   const parents: Key[] = [];
+  let current = node[PARENT_KEY];
 
-  if (!rowData) {
-    return parents;
+  // Iterate up through the parent chain and add each parent to the result array
+  while (current) {
+    parents.push(current[rowKey]);
+    current = current[PARENT_KEY];
   }
-
-  function findParent(data) {
-    if (data) {
-      parents.push(data[rowKey]);
-
-      if (data[PARENT_KEY]) {
-        findParent(data[PARENT_KEY]);
-      }
-    }
-  }
-  findParent(rowData[PARENT_KEY]);
-
   return parents;
 }
+
+export default findAllParents;

src/utils/flattenData.ts

@@ -2,31 +2,21 @@ import { PARENT_KEY } from '../constants';
 import type { RowDataType } from '../@types/common';
 
 /**
- * Flatten the data of a tree structure into a one-dimensional array.
- * @param treeData
- * @returns
+ * Flatten the tree data with parent association recorded on each node
+ * @param tree tree data
  */
-function flattenData<Row extends RowDataType>(treeData: readonly Row[]) {
-  const flattenItems: Row[] = [];
+function flattenData<Row extends RowDataType<Row>>(tree: readonly Row[], parent?: Row): Row[] {
+  return tree.reduce<Row[]>((acc, node) => {
+    // Create a new flattened node with parent association
+    const flattened = {
+      ...node,
+      [PARENT_KEY]: parent
+    };
 
-  function loop(treeData, parentNode) {
-    if (!Array.isArray(treeData)) {
-      return;
-    }
-
-    treeData.forEach(rowData => {
-      rowData[PARENT_KEY] = parentNode;
-      flattenItems.push({
-        ...rowData
-      });
-      if (rowData.children) {
-        loop(rowData.children, rowData);
-      }
-    });
-  }
-
-  loop(treeData, null);
-  return flattenItems;
+    // Add the flattened node and its flattened children (if any) to the result array
+    acc.push(flattened, ...(node.children ? flattenData(node.children, flattened) : []));
+    return acc;
+  }, []);
 }
 
 export default flattenData;

test/findAllParentsSpec.js

@@ -0,0 +1,32 @@
+import findAllParents from '../src/utils/findAllParents';
+import { PARENT_KEY } from '../src/constants';
+
+describe('findAllParents', () => {
+  it('should find all parents of a node', () => {
+    const tree = {
+      id: 1,
+      name: 'A',
+      [PARENT_KEY]: {
+        id: 2,
+        name: 'B',
+        [PARENT_KEY]: {
+          id: 3,
+          name: 'C',
+          [PARENT_KEY]: undefined
+        }
+      }
+    };
+
+    const result = findAllParents(tree, 'id');
+
+    expect(result).to.deep.equal([2, 3]);
+  });
+
+  it('should return an empty array if the node has no parents', () => {
+    const node = { id: 1, name: 'A', [PARENT_KEY]: undefined };
+
+    const result = findAllParents(node, 'id');
+
+    expect(result).to.deep.equal([]);
+  });
+});

test/flattenDataSpec.js

@@ -0,0 +1,91 @@
+import flattenData from '../src/utils/flattenData';
+import { PARENT_KEY } from '../src/constants';
+
+describe('flattenData', () => {
+  it('should flatten a single-level tree', () => {
+    const tree = [
+      { id: '1', name: 'A' },
+      { id: '2', name: 'B' },
+      { id: '3', name: 'C' }
+    ];
+
+    const result = flattenData(tree);
+
+    expect(result).to.deep.equal(tree.map(node => ({ ...node, [PARENT_KEY]: undefined })));
+  });
+
+  it('should flatten a multi-level tree', () => {
+    const tree = [
+      {
+        id: '1',
+        name: 'A',
+        children: [
+          { id: '2', name: 'B' },
+          {
+            id: '3',
+            name: 'C',
+            children: [
+              { id: '4', name: 'D' },
+              { id: '5', name: 'E' }
+            ]
+          },
+          { id: '6', name: 'F' }
+        ]
+      },
+      {
+        id: '7',
+        name: 'G',
+        children: [
+          { id: '8', name: 'H' },
+          { id: '9', name: 'I' }
+        ]
+      },
+      { id: '10', name: 'J' }
+    ];
+
+    const result = flattenData(tree);
+
+    expect(result).to.have.lengthOf(10);
+    expect(result).to.deep.equal([
+      {
+        id: '1',
+        name: 'A',
+        children: [
+          { id: '2', name: 'B' },
+          {
+            id: '3',
+            name: 'C',
+            children: [
+              { id: '4', name: 'D' },
+              { id: '5', name: 'E' }
+            ]
+          },
+          { id: '6', name: 'F' }
+        ]
+      },
+      { id: '2', name: 'B' },
+      {
+        id: '3',
+        name: 'C',
+        children: [
+          { id: '4', name: 'D' },
+          { id: '5', name: 'E' }
+        ]
+      },
+      { id: '4', name: 'D' },
+      { id: '5', name: 'E' },
+      { id: '6', name: 'F' },
+      {
+        id: '7',
+        name: 'G',
+        children: [
+          { id: '8', name: 'H' },
+          { id: '9', name: 'I' }
+        ]
+      },
+      { id: '8', name: 'H' },
+      { id: '9', name: 'I' },
+      { id: '10', name: 'J' }
+    ]);
+  });
+});