Create function to flatten tree data into a list of visible nodes

Author: fritz-c

src/utils/tree-data-utils.js

@@ -104,6 +104,69 @@ export function getVisibleNodeInfoAtIndex(data, targetIndex, getNodeKey) {
     return null;
 }
 
+/**
+ * Get visible node data flattened.
+ *
+ * @param {!Object[]} data - Tree data
+ * @param {!number} targetIndex - The index of the node to search for
+ * @param {function} getNodeKey - Function to get the key from the nodeData and tree index
+ *
+ * @return {{
+ *      node: Object,
+ *      parentPath: []string|[]number,
+ *      lowerSiblingCounts: []number
+ *  }}[] nodes - The node array
+ */
+export function getVisibleNodeInfoFlattened(treeData, getNodeKey) {
+    if (!treeData || treeData.length < 1) {
+        return [];
+    }
+
+    const trav = ({
+        node,
+        currentIndex,
+        parentPath = [],
+        lowerSiblingCounts = [],
+        isPseudoRoot = false,
+    }) => {
+        const selfInfo = !isPseudoRoot ? [{ node, parentPath, lowerSiblingCounts }] : [];
+
+        // Add one and continue for nodes with no children or hidden children
+        if (!node.children || (node.expanded !== true && !isPseudoRoot)) {
+            return selfInfo;
+        }
+
+        // Iterate over each child and their ancestors and return the
+        // target node if childIndex reaches the targetIndex
+        let childIndex   = currentIndex + 1;
+        const childCount = node.children.length;
+        const results = [];
+        const selfKey = !isPseudoRoot ? getNodeKey(node, currentIndex) : null;
+        for (let i = 0; i < childCount; i++) {
+            results[i] = trav({
+                node: node.children[i],
+                currentIndex: childIndex,
+                lowerSiblingCounts: [ ...lowerSiblingCounts, childCount - i - 1 ],
+
+                // The pseudo-root, with a null parent path, is not considered in the parent path
+                parentPath: !isPseudoRoot ? [ ...parentPath, selfKey ] : [],
+            });
+
+            childIndex += results[i].length;
+        }
+
+        return selfInfo.concat(...results);
+    };
+
+    return trav({
+        node: { children: treeData },
+        currentIndex: -1,
+        parentPath: [],
+        isPseudoRoot: true,
+        lowerSiblingCounts: [],
+    });
+}
+
 /**
  * Replaces node at path with object, or callback-defined object
  *

src/utils/tree-data-utils.test.js

@@ -2,6 +2,7 @@ import {
     getVisibleNodeCount,
     getVisibleNodeInfoAtIndex,
     changeNodeAtPath,
+    getVisibleNodeInfoFlattened,
 } from './tree-data-utils';
 
 const keyFromTreeIndex = (node, treeIndex) => treeIndex;
@@ -213,6 +214,125 @@ describe('getVisibleNodeInfoAtIndex', () => {
     });
 });
 
+
+describe('getVisibleNodeInfoAtIndex', () => {
+    it('should handle empty data', () => {
+        expect(getVisibleNodeInfoFlattened([], keyFromTreeIndex)).toEqual([]);
+        expect(getVisibleNodeInfoFlattened(null, keyFromTreeIndex)).toEqual([]);
+        expect(getVisibleNodeInfoFlattened(undefined, keyFromTreeIndex)).toEqual([]);
+    });
+
+    it('should handle flat data', () => {
+        expect(getVisibleNodeInfoFlattened([ { key: 0 } ], keyFromTreeIndex)).toEqual([
+            { node: { key: 0 }, parentPath: [], lowerSiblingCounts: [ 0 ] },
+        ]);
+        expect(getVisibleNodeInfoFlattened([ { key: 0 }, { key: 1 } ], keyFromTreeIndex)).toEqual([
+            { node: { key: 0 }, parentPath: [], lowerSiblingCounts: [ 1 ] },
+            { node: { key: 1 }, parentPath: [], lowerSiblingCounts: [ 0 ] }
+        ]);
+    });
+
+    it('should handle hidden nested data', () => {
+        const treeData = [
+            {
+                key: 0,
+                children: [
+                    {
+                        key: 1,
+                        children: [
+                            { key: 2 },
+                            { key: 3 },
+                        ],
+                    },
+                    {
+                        key: 4,
+                        children: [
+                            { key: 5 },
+                        ],
+                    },
+                ],
+            },
+            { key: 6 },
+        ];
+
+        expect(getVisibleNodeInfoFlattened(treeData, keyFromTreeIndex)).toEqual([
+            { node: treeData[0], parentPath: [], lowerSiblingCounts: [ 1 ] },
+            { node: treeData[1], parentPath: [], lowerSiblingCounts: [ 0 ] }
+        ]);
+    });
+
+    it('should handle partially expanded nested data', () => {
+        const treeData = [
+            {
+                expanded: true,
+                key: 0,
+                children: [
+                    {
+                        key: 1,
+                        children: [
+                            { key: 2 },
+                            { key: 3 },
+                        ],
+                    },
+                    {
+                        expanded: true,
+                        key: 4,
+                        children: [
+                            { key: 5 },
+                        ],
+                    },
+                ],
+            },
+            { key: 6 },
+        ];
+
+        expect(getVisibleNodeInfoFlattened(treeData, keyFromKey)).toEqual([
+            { node: treeData[0], parentPath: [], lowerSiblingCounts: [ 1 ] },
+            { node: treeData[0].children[0], parentPath: [0], lowerSiblingCounts: [ 1, 1 ] },
+            { node: treeData[0].children[1], parentPath: [0], lowerSiblingCounts: [ 1, 0 ] },
+            { node: treeData[0].children[1].children[0], parentPath: [0, 4], lowerSiblingCounts: [ 1, 0, 0 ] },
+            { node: treeData[1], parentPath: [], lowerSiblingCounts: [ 0 ] },
+        ]);
+    });
+
+    it('should handle fully expanded nested data', () => {
+        const treeData = [
+            {
+                expanded: true,
+                key: 0,
+                children: [
+                    {
+                        expanded: true,
+                        key: 1,
+                        children: [
+                            { key: 2 },
+                            { key: 3 },
+                        ],
+                    },
+                    {
+                        expanded: true,
+                        key: 4,
+                        children: [
+                            { key: 5 },
+                        ],
+                    },
+                ],
+            },
+            { key: 6 },
+        ];
+
+        expect(getVisibleNodeInfoFlattened(treeData, keyFromTreeIndex)).toEqual([
+            { node: treeData[0],                         parentPath: [],     lowerSiblingCounts: [1] },
+            { node: treeData[0].children[0],             parentPath: [0],    lowerSiblingCounts: [1, 1] },
+            { node: treeData[0].children[0].children[0], parentPath: [0, 1], lowerSiblingCounts: [1, 1, 1] },
+            { node: treeData[0].children[0].children[1], parentPath: [0, 1], lowerSiblingCounts: [1, 1, 0] },
+            { node: treeData[0].children[1],             parentPath: [0],    lowerSiblingCounts: [1, 0] },
+            { node: treeData[0].children[1].children[0], parentPath: [0, 4], lowerSiblingCounts: [1, 0, 0] },
+            { node: treeData[1],                         parentPath: [],     lowerSiblingCounts: [0] },
+        ]);
+    });
+});
+
 describe('changeNodeAtPath', () => {
     it('should handle empty data', () => {
         expect(() => changeNodeAtPath([], [1], {}, keyFromTreeIndex)).toThrow();