jqtree 1.6.3 → 1.7.1

package/src/test/node.test.ts

@@ -164,7 +164,7 @@ describe("addChild", () => {
     });
 
     it("sets the parent of the child", () => {
-        expect(given.node.children[0].parent).toEqual(given.node);
+        expect(given.node.children[0]?.parent).toEqual(given.node);
     });
 });
 
@@ -538,14 +538,16 @@ describe("getLastChild", () => {
         context("when its last child is open and has children", () => {
             beforeEach(() => {
                 const child2 = given.node.children[1];
-                child2.append("child2a");
-                child2.append("child2b");
+                child2?.append("child2a");
+                child2?.append("child2b");
             });
 
             context("and the last child is open", () => {
                 beforeEach(() => {
                     const child2 = given.node.children[1];
-                    child2.is_open = true;
+                    if (child2) {
+                        child2.is_open = true;
+                    }
                 });
 
                 it("returns the last child of that child", () => {
@@ -568,52 +570,47 @@ describe("getLastChild", () => {
 
 describe("getNextNode", () => {
     interface Vars {
-        includeChildren: boolean;
         fromNode: Node;
-        nextNode: Node | null;
         tree: Node;
     }
     const given = getGiven<Vars>();
     given("tree", () => new Node().loadFromData(exampleData));
-    given("nextNode", () => given.fromNode.getNextNode(given.includeChildren));
 
-    context("with includeChildren is true", () => {
-        given("includeChildren", () => true);
+    context("with a parent node", () => {
+        given("fromNode", () => given.tree.getNodeByNameMustExist("node1"));
 
-        context("with a parent node", () => {
-            given("fromNode", () => given.tree.getNodeByNameMustExist("node1"));
-
-            context("when the parent node is closed", () => {
-                it("returns the next sibling", () => {
-                    expect(given.nextNode).toMatchObject({ name: "node2" });
+        context("when the parent node is closed", () => {
+            it("returns the first child", () => {
+                expect(given.fromNode.getNextNode()).toMatchObject({
+                    name: "child1",
                 });
             });
+        });
 
-            context("when the parent node is open", () => {
-                beforeEach(() => {
-                    given.fromNode.is_open = true;
-                });
+        context("when the parent node is open", () => {
+            beforeEach(() => {
+                given.fromNode.is_open = true;
+            });
 
-                it("returns the first child", () => {
-                    expect(given.nextNode).toMatchObject({ name: "child1" });
+            it("returns the first child", () => {
+                expect(given.fromNode.getNextNode()).toMatchObject({
+                    name: "child1",
                 });
             });
         });
+    });
 
-        context("with the node is the last child", () => {
-            given("fromNode", () =>
-                given.tree.getNodeByNameMustExist("child2")
-            );
+    context("with the node is the last child", () => {
+        given("fromNode", () => given.tree.getNodeByNameMustExist("child2"));
 
-            it("returns the next sibling of the parent", () => {
-                expect(given.nextNode).toMatchObject({ name: "node2" });
+        it("returns the next sibling of the parent", () => {
+            expect(given.fromNode.getNextNode()).toMatchObject({
+                name: "node2",
             });
         });
     });
 
     context("with includeChildren is false", () => {
-        given("includeChildren", () => false);
-
         context("with an open parent node", () => {
             given("fromNode", () => given.tree.getNodeByNameMustExist("node1"));
 
@@ -622,10 +619,63 @@ describe("getNextNode", () => {
             });
 
             it("returns the next sibling", () => {
-                expect(given.nextNode).toMatchObject({ name: "node2" });
+                expect(given.fromNode.getNextNode(false)).toMatchObject({
+                    name: "node2",
+                });
+            });
+        });
+    });
+});
+
+describe("getNextVisibleNode", () => {
+    interface Vars {
+        fromNode: Node;
+        tree: Node;
+    }
+    const given = getGiven<Vars>();
+    given("tree", () => new Node().loadFromData(exampleData));
+
+    context("with a parent node", () => {
+        given("fromNode", () => given.tree.getNodeByNameMustExist("node1"));
+
+        context("when the parent node is closed", () => {
+            it("returns the next sibling", () => {
+                expect(given.fromNode.getNextVisibleNode()).toMatchObject({
+                    name: "node2",
+                });
+            });
+        });
+
+        context("when the parent node is open", () => {
+            beforeEach(() => {
+                given.fromNode.is_open = true;
+            });
+
+            it("returns the first child", () => {
+                expect(given.fromNode.getNextVisibleNode()).toMatchObject({
+                    name: "child1",
+                });
             });
         });
     });
+
+    context("with the node is the last child", () => {
+        given("fromNode", () => given.tree.getNodeByNameMustExist("child2"));
+
+        it("returns the next sibling of the parent", () => {
+            expect(given.fromNode.getNextVisibleNode()).toMatchObject({
+                name: "node2",
+            });
+        });
+    });
+
+    context("with the tree node", () => {
+        given("fromNode", () => given.tree);
+
+        it("returns null", () => {
+            expect(given.fromNode.getNextVisibleNode()).toBeNull();
+        });
+    });
 });
 
 describe("getNextSibling", () => {
@@ -766,48 +816,92 @@ describe("getParent", () => {
 
 describe("getPreviousNode", () => {
     interface Vars {
-        node2: Node;
-        node3: Node;
         tree: Node;
     }
     const given = getGiven<Vars>();
-    given("node2", () => given.tree.getNodeByNameMustExist("node2"));
-    given("node3", () => given.tree.getNodeByNameMustExist("node3"));
     given("tree", () => new Node().loadFromData(exampleData));
 
-    context("with a tree", () => {
-        it("returns null", () => {
-            expect(given.tree.getPreviousNode()).toBeNull();
+    it("returns null with a tree node", () => {
+        expect(given.tree.getPreviousNode()).toBeNull();
+    });
+
+    it("returns the last child of the previous sibling when the previous node is closed and has children", () => {
+        given.tree.getNodeByNameMustExist("node2").is_open = false;
+        const node2 = given.tree.getNodeByNameMustExist("node2");
+
+        expect(node2.getPreviousNode()).toMatchObject({
+            name: "child2",
         });
     });
 
-    context("when the previous sibling has children", () => {
-        context("when the previous node is closed", () => {
-            it("returns the previous sibling", () => {
-                expect(given.node2.getPreviousNode()).toMatchObject({
-                    name: "node1",
-                });
-            });
+    it("returns the last child of the previous sibling when the previous node is open and has children", () => {
+        given.tree.getNodeByNameMustExist("node2").is_open = true;
+        const node2 = given.tree.getNodeByNameMustExist("node2");
+
+        expect(node2.getPreviousNode()).toMatchObject({
+            name: "child2",
         });
+    });
 
-        context("when the previous node is open", () => {
-            beforeEach(() => {
-                given.tree.getNodeByNameMustExist("node1").is_open = true;
-            });
+    it("returns the first child if a node is the second child", () => {
+        const child2 = given.tree.getNodeByNameMustExist("child2");
 
-            it("returns the last child of the previous sibling", () => {
-                expect(given.node2.getPreviousNode()).toMatchObject({
-                    name: "child2",
-                });
-            });
+        expect(child2.getPreviousNode()).toMatchObject({
+            name: "child1",
         });
     });
 
-    context("with a node that is the first child", () => {
-        it("returns the parent", () => {
-            expect(given.node3.getPreviousNode()).toMatchObject({
-                name: "node2",
-            });
+    it("returns the parent with a node that is the first child", () => {
+        const node3 = given.tree.getNodeByNameMustExist("node3");
+
+        expect(node3.getPreviousNode()).toMatchObject({
+            name: "node2",
+        });
+    });
+});
+
+describe("getPreviousVisibleNode", () => {
+    interface Vars {
+        tree: Node;
+    }
+    const given = getGiven<Vars>();
+    given("tree", () => new Node().loadFromData(exampleData));
+
+    it("returns null with a tree node", () => {
+        expect(given.tree.getPreviousVisibleNode()).toBeNull();
+    });
+
+    it("returns the previous sibling when the previous sibling is closed and has children", () => {
+        given.tree.getNodeByNameMustExist("node2").is_open = false;
+        const node2 = given.tree.getNodeByNameMustExist("node2");
+
+        expect(node2.getPreviousVisibleNode()).toMatchObject({
+            name: "node1",
+        });
+    });
+
+    it("returns the last child of the previous sibling when the previous sibling is open and has children", () => {
+        given.tree.getNodeByNameMustExist("node1").is_open = true;
+        const node2 = given.tree.getNodeByNameMustExist("node2");
+
+        expect(node2.getPreviousVisibleNode()).toMatchObject({
+            name: "child2",
+        });
+    });
+
+    it("returns the first child if a node is the second child", () => {
+        const child2 = given.tree.getNodeByNameMustExist("child2");
+
+        expect(child2.getPreviousVisibleNode()).toMatchObject({
+            name: "child1",
+        });
+    });
+
+    it("returns the parent when a node is the first child", () => {
+        const node3 = given.tree.getNodeByNameMustExist("node3");
+
+        expect(node3.getPreviousVisibleNode()).toMatchObject({
+            name: "node2",
         });
     });
 });

package/src/test/nodeUtil.test.ts

@@ -24,7 +24,7 @@ describe("getPositionName", () => {
 
     context("with an unknown position", () => {
         it("returns an empty string", () => {
-            expect(getPositionName(10)).toBe("");
+            expect(getPositionName(10 as Position)).toBe("");
         });
     });
 });

package/src/tree.jquery.ts

@@ -777,7 +777,7 @@ export class JqTreeWidget extends MouseWidget<JQTreeOptions> {
     // Set initial state, either by restoring the state or auto-opening nodes
     // result: must load nodes on demand?
     private setInitialState(): boolean {
-        const restoreState = (): boolean[] => {
+        const restoreState = (): [boolean, boolean] => {
             // result: is state restored, must load on demand?
             if (!this.options.saveState) {
                 return [false, false];
@@ -1118,11 +1118,7 @@ export class JqTreeWidget extends MouseWidget<JQTreeOptions> {
     }
 
     private doLoadData(data: NodeData[] | null, parentNode: Node | null): void {
-        if (!data) {
-            return;
-        } else {
-            this._triggerEvent("tree.load_data", { tree_data: data });
-
+        if (data) {
             if (parentNode) {
                 this.deselectNodes(parentNode);
                 this.loadSubtree(data, parentNode);
@@ -1134,6 +1130,11 @@ export class JqTreeWidget extends MouseWidget<JQTreeOptions> {
                 this.dndHandler.refresh();
             }
         }
+
+        this._triggerEvent("tree.load_data", {
+            tree_data: data,
+            parent_node: parentNode,
+        });
     }
 
     private deselectNodes(parentNode: Node): void {

package/src/version.ts

@@ -1,3 +1,3 @@
-const version = "1.6.2";
+const version = "1.7.1";
 
 export default version;