jqtree 1.6.2 → 1.7.0

package/src/test/jqTree/events.test.ts

@@ -7,16 +7,24 @@ import { titleSpan } from "../support/testUtil";
 
 const context = describe;
 
+const server = setupServer();
+
+beforeAll(() => server.listen());
+
 beforeEach(() => {
     $("body").append('<div id="tree1"></div>');
 });
 
 afterEach(() => {
+    server.resetHandlers();
+
     const $tree = $("#tree1");
     $tree.tree("destroy");
     $tree.remove();
 });
 
+afterAll(() => server.close());
+
 describe("tree.click", () => {
     interface Vars {
         node1: INode;
@@ -131,19 +139,12 @@ describe("tree.init", () => {
     });
 
     context("with data loaded from an url", () => {
-        let server: ReturnType<typeof setupServer> | null = null;
-
-        beforeAll(() => {
-            server = setupServer(
+        beforeEach(() => {
+            server.use(
                 rest.get("/tree/", (_request, response, ctx) =>
                     response(ctx.status(200), ctx.json(exampleData))
                 )
             );
-            server.listen();
-        });
-
-        afterAll(() => {
-            server?.close();
         });
 
         it("is called", () =>

package/src/test/jqTree/loadOnDemand.test.ts

@@ -7,17 +7,25 @@ import { togglerLink } from "../support/testUtil";
 
 const context = describe;
 
+const server = setupServer();
+
+beforeAll(() => server.listen());
+
 beforeEach(() => {
     $("body").append('<div id="tree1"></div>');
 });
 
 afterEach(() => {
+    server.resetHandlers();
+
     const $tree = $("#tree1");
     $tree.tree("destroy");
     $tree.remove();
     localStorage.clear();
 });
 
+afterAll(() => server.close());
+
 context("when a node has load_on_demand in the data", () => {
     interface Vars {
         autoOpen: boolean;
@@ -37,10 +45,8 @@ context("when a node has load_on_demand in the data", () => {
         },
     ];
 
-    let server: ReturnType<typeof setupServer> | null = null;
-
-    beforeAll(() => {
-        server = setupServer(
+    beforeEach(() => {
+        server.use(
             rest.get("/tree/", (request, response, ctx) => {
                 const parentId = request.url.searchParams.get("node");
 
@@ -54,12 +60,6 @@ context("when a node has load_on_demand in the data", () => {
                 }
             })
         );
-
-        server.listen();
-    });
-
-    afterAll(() => {
-        server?.close();
     });
 
     beforeEach(() => {

package/src/test/jqTree/methods.test.ts

@@ -1,5 +1,5 @@
 import getGiven from "givens";
-import { screen } from "@testing-library/dom";
+import { screen, waitFor } from "@testing-library/dom";
 import { rest } from "msw";
 import { setupServer } from "msw/node";
 import "../../tree.jquery";
@@ -9,17 +9,25 @@ import __version__ from "../../version";
 
 const context = describe;
 
+const server = setupServer();
+
+beforeAll(() => server.listen());
+
 beforeEach(() => {
     $("body").append('<div id="tree1"></div>');
 });
 
 afterEach(() => {
+    server.resetHandlers();
+
     const $tree = $("#tree1");
     $tree.tree("destroy");
     $tree.remove();
     localStorage.clear();
 });
 
+afterAll(() => server.close());
+
 describe("addNodeAfter", () => {
     interface Vars {
         node: INode;
@@ -739,22 +747,13 @@ describe("loadDataFromUrl", () => {
     given("serverData", () => exampleData);
     given("$tree", () => $("#tree1"));
 
-    let server: ReturnType<typeof setupServer> | null = null;
-
-    beforeAll(() => {
-        server = setupServer(
-            rest.get("/tree/", (_request, response, ctx) => {
-                return response(ctx.status(200), ctx.json(given.serverData));
-            })
+    beforeEach(() => {
+        server.use(
+            rest.get("/tree/", (_request, response, ctx) =>
+                response(ctx.status(200), ctx.json(given.serverData))
+            )
         );
-        server.listen();
-    });
-
-    afterAll(() => {
-        server?.close();
-    });
 
-    beforeEach(() => {
         given.$tree.tree({ data: given.initialData });
     });
 
@@ -909,12 +908,15 @@ describe("openNode", () => {
     });
 
     context("with onFinished parameter", () => {
-        it("calls the function", () =>
-            new Promise((resolve) =>
-                given.$tree.tree("openNode", given.node1, (node) =>
-                    resolve(expect(node).toBe(given.node1))
-                )
-            ));
+        it("calls the function", async () => {
+            const onFinished = jest.fn();
+
+            given.$tree.tree("openNode", given.node1, onFinished);
+
+            await waitFor(() => {
+                expect(onFinished).toHaveBeenCalledWith(given.node1);
+            });
+        });
     });
 });
 
@@ -1008,23 +1010,14 @@ describe("reload", () => {
     given("node1", () => given.$tree.tree("getNodeByNameMustExist", "node1"));
     given("$tree", () => $("#tree1"));
 
-    let server: ReturnType<typeof setupServer> | null = null;
-
-    beforeAll(() => {
-        server = setupServer(
-            rest.get("/tree/", (_request, response, ctx) =>
+    beforeEach(async () => {
+        server.use(
+            rest.get("/tree2/", (_request, response, ctx) =>
                 response(ctx.status(200), ctx.json(exampleData))
             )
         );
-        server.listen();
-    });
-
-    afterAll(() => {
-        server?.close();
-    });
 
-    beforeEach(async () => {
-        given.$tree.tree({ dataUrl: "/tree/" });
+        given.$tree.tree({ dataUrl: "/tree2/" });
         await screen.findByText("node1");
 
         given.$tree.tree("removeNode", given.node1);
@@ -1045,19 +1038,18 @@ describe("reload", () => {
     });
 
     context("with a onFinished parameter", () => {
-        it("calls onFinished", () =>
-            new Promise<void>((resolve) => {
-                const handleFinished = () => {
-                    expect(given.$tree).toHaveTreeStructure([
-                        expect.objectContaining({ name: "node1" }),
-                        expect.objectContaining({ name: "node2" }),
-                    ]);
+        it("calls onFinished", async () => {
+            const handleFinished = jest.fn();
+
+            given.$tree.tree("reload", handleFinished);
 
-                    resolve();
-                };
+            await waitFor(() => expect(handleFinished).toHaveBeenCalledWith());
 
-                given.$tree.tree("reload", handleFinished);
-            }));
+            expect(given.$tree).toHaveTreeStructure([
+                expect.objectContaining({ name: "node1" }),
+                expect.objectContaining({ name: "node2" }),
+            ]);
+        });
     });
 });
 

package/src/test/jqTree/options.test.ts

@@ -1,5 +1,5 @@
 import getGiven from "givens";
-import { screen } from "@testing-library/dom";
+import { screen, waitFor } from "@testing-library/dom";
 import { rest } from "msw";
 import { setupServer } from "msw/node";
 import "../../tree.jquery";
@@ -8,17 +8,25 @@ import { titleSpan, togglerLink } from "../support/testUtil";
 
 const context = describe;
 
+const server = setupServer();
+
+beforeAll(() => server.listen());
+
 beforeEach(() => {
     $("body").append('<div id="tree1"></div>');
 });
 
 afterEach(() => {
+    server.resetHandlers();
+
     const $tree = $("#tree1");
     $tree.tree("destroy");
     $tree.remove();
     localStorage.clear();
 });
 
+afterAll(() => server.close());
+
 describe("autoEscape", () => {
     interface Vars {
         autoEscape: boolean;
@@ -186,10 +194,8 @@ describe("dataUrl", () => {
         },
     ];
 
-    let server: ReturnType<typeof setupServer> | null = null;
-
-    beforeAll(() => {
-        server = setupServer(
+    beforeEach(() => {
+        server.use(
             rest.get("/tree/", (request, response, ctx) => {
                 const nodeName = request.headers.get("node");
                 const data = nodeName ? [nodeName] : exampleData;
@@ -197,11 +203,6 @@ describe("dataUrl", () => {
                 return response(ctx.status(200), ctx.json(data));
             })
         );
-        server.listen();
-    });
-
-    afterAll(() => {
-        server?.close();
     });
 
     interface Vars {
@@ -347,31 +348,28 @@ describe("onLoadFailed", () => {
     given("$tree", () => $("#tree1"));
 
     context("when the loading fails", () => {
-        let server: ReturnType<typeof setupServer> | null = null;
-
-        beforeAll(() => {
-            server = setupServer(
+        beforeEach(() => {
+            server.use(
                 rest.get("/tree/", (_request, response, ctx) =>
                     response(ctx.status(500), ctx.body("Internal server error"))
                 )
             );
-            server.listen();
         });
 
-        afterAll(() => {
-            server?.close();
-        });
+        it("calls onLoadFailed", async () => {
+            const onLoadFailed = jest.fn();
+
+            given.$tree.tree({
+                dataUrl: "/tree/",
+                onLoadFailed,
+            });
 
-        it("calls onLoadFailed", () =>
-            new Promise<void>((done) => {
-                given.$tree.tree({
-                    dataUrl: "/tree/",
-                    onLoadFailed: (jqXHR) => {
-                        expect(jqXHR.status).toBe(500);
-                        done();
-                    },
-                });
-            }));
+            await waitFor(() => {
+                expect(onLoadFailed).toHaveBeenCalledWith(
+                    expect.objectContaining({ status: 500 })
+                );
+            });
+        });
     });
 });
 

package/src/test/node.test.ts

@@ -568,52 +568,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 +617,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 +814,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/tree.jquery.d.ts

@@ -62,7 +62,7 @@ interface IJQTreeOptions {
     onGetStateFromStorage?: () => string;
     onSetStateFromStorage?: (data: string) => void;
     openedIcon?: string | Element;
-    openFolderDelay?: number;
+    openFolderDelay?: number | false;
     rtl?: boolean;
     selectable?: boolean;
     saveState?: boolean | string;

package/src/tree.jquery.ts

@@ -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.0";
 
 export default version;