Added test script + simple test for flattenTree()

Author: marchaos

package.json

@@ -24,7 +24,8 @@
     "build:es": "npm run clean:es && cross-env NODE_ENV=production cross-env BABEL_ENV=es babel src --out-dir dist/es --ignore *.spec.js",
     "prepublish": "npm run build",
     "clean:commonjs": "rimraf dist/commonjs",
-    "clean:es": "rimraf dist/es"
+    "clean:es": "rimraf dist/es",
+    "test": "mocha \"test/**/*spec.js*\" --compilers js:babel-register --reporter=dot"
   },
   "files": [
     "dist"

src/StickyTree.jsx

@@ -205,7 +205,7 @@ export default class StickyTree extends React.PureComponent {
     }
 
     /**
-     * Returns the parent path for the specified index within nodePosCache.
+     * Returns the parent path from nodePosCache for the specified index within nodePosCache.
      * @param nodeIndex
      * @returns {Array<Node>}
      */
@@ -221,6 +221,12 @@ export default class StickyTree extends React.PureComponent {
         return path.reverse();
     }
 
+    /**
+     * Searches from the current node position downwards to see if the top of nodes above are greater
+     * than or equal to the current scrollTop
+     * @param scrollTop
+     * @returns {number}
+     */
     forwardSearch(scrollTop) {
         const nodePosCache = this.nodePosCache;
         for (let i = this.state.currNodePos; i < nodePosCache.length; i++) {
@@ -231,6 +237,12 @@ export default class StickyTree extends React.PureComponent {
         return nodePosCache.length - 1;
     }
 
+    /**
+     * Searches from the current node position upwards to see if the top of nodes above are less than
+     * or equal the current scrollTop.
+     * @param scrollTop
+     * @returns {number}
+     */
     backwardSearch(scrollTop) {
         const nodePosCache = this.nodePosCache;
         for (let i = this.state.currNodePos; i >= 0; i--) {

test/StickyTree.spec.js

@@ -0,0 +1,58 @@
+import { expect } from 'chai';
+
+import { StickyTree } from '../src/index';
+
+describe('StickyTree test', () => {
+    let tree;
+    let props;
+
+    it('flattenTree returns a cache of all required info', () => {
+        const treeNodes = [
+            { name: 'root', children: [1, 4] },
+            { name: 'node1', children: [2, 3] },
+            { name: 'node1-1' },
+            { name: 'node1-2' },
+            { name: 'node2', children: [5, 6, 7] },
+            { name: 'node2-1' },
+            { name: 'node2-2' },
+            { name: 'node2-3' }
+        ];
+
+        props = {
+            getChildren: pos => treeNodes[pos].children,
+            getHeight: pos => 10
+
+        };
+        tree = new StickyTree(props);
+        const nodePosCache = tree.flattenTree(0);
+
+        expect(nodePosCache[0]).to.deep.equal({
+            node: 0,
+            top: 0,
+            parentIndex: undefined,
+            index: 0,
+            children: [1, 4],
+            height: 80
+        });
+
+        expect(nodePosCache[1]).to.deep.equal({
+            node: 1,
+            top: 10,
+            parentIndex: 0,
+            index: 1,
+            children: [2, 3],
+            height: 30
+        });
+
+        expect(nodePosCache[2]).to.deep.equal({ node: 2, top: 20, parentIndex: 1, index: 2, height: 10 });
+
+        expect(nodePosCache[4]).to.deep.equal({
+            node: 4,
+            top: 40,
+            parentIndex: 0,
+            index: 4,
+            children: [5, 6, 7],
+            height: 40
+        });
+    });
+});