jqtree 1.6.3 → 1.7.0

package/lib/util.js

@@ -4,21 +4,15 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.isInt = exports.isFunction = exports.getBoolString = void 0;
-
 var isInt = function isInt(n) {
   return typeof n === "number" && n % 1 === 0;
 };
-
 exports.isInt = isInt;
-
 var isFunction = function isFunction(v) {
   return typeof v === "function";
 };
-
 exports.isFunction = isFunction;
-
 var getBoolString = function getBoolString(value) {
   return value ? "true" : "false";
 };
-
 exports.getBoolString = getBoolString;

package/lib/version.js

@@ -4,6 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports["default"] = void 0;
-var version = "1.6.2";
+var version = "1.7.0";
 var _default = version;
 exports["default"] = _default;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jqtree",
-    "version": "1.6.3",
+    "version": "1.7.0",
     "description": "Tree widget for jQuery",
     "keywords": [
         "jquery-plugin",
@@ -16,14 +16,14 @@
     "scripts": {
         "ci": "pnpm lint && pnpm tsc && pnpm test",
         "jest": "jest --coverage --no-cache --verbose --config ./config/jest.config.js",
-        "jest-watch": "jest --watch",
+        "jest-watch": "jest --watch --config ./config/jest.config.js",
         "lint": "eslint src/ --ext .ts,.tsx",
         "production": "./config/production",
-        "devserver": "SERVE=true rollup --config config/rollup.config.js --watch",
-        "devserver-with-coverage": "COVERAGE=true SERVE=true rollup --config config/rollup.config.js",
-        "build-with-coverage": "COVERAGE=true rollup --config config/rollup.config.js",
+        "devserver": "SERVE=true rollup --config config/rollup.config.mjs --watch",
+        "devserver-with-coverage": "COVERAGE=true SERVE=true rollup --config config/rollup.config.mjs",
+        "build-with-coverage": "COVERAGE=true rollup --config config/rollup.config.mjs",
         "prettier": "prettier src/*.ts --write --tab-width 4",
-        "coveralls": "nyc report --reporter=text-lcov | coveralls",
+        "write-coverage": "nyc report --reporter=text-lcov > lcov.info",
         "tsc": "tsc --noEmit --project tsconfig.json",
         "merge-coverage": "cp jest-coverage/coverage-final.json .nyc_output/coverage_jsdom.json",
         "clean-coverage": "rm -rf .nyc_output && jest --clearCache",
@@ -32,50 +32,51 @@
         "test": "pnpm jest && pnpm playwright"
     },
     "dependencies": {
-        "jquery": "^3.6.0"
+        "jquery": "^3.6.3"
     },
     "devDependencies": {
-        "@babel/cli": "^7.18.10",
-        "@babel/core": "^7.18.10",
-        "@babel/preset-env": "^7.18.10",
+        "@babel/cli": "^7.20.7",
+        "@babel/core": "^7.20.7",
+        "@babel/preset-env": "^7.20.2",
         "@babel/preset-typescript": "^7.18.6",
-        "@playwright/test": "^1.24.2",
-        "@rollup/plugin-babel": "^5.3.1",
-        "@rollup/plugin-node-resolve": "^13.3.0",
-        "@testing-library/dom": "^8.16.1",
+        "@playwright/test": "^1.29.1",
+        "@rollup/plugin-babel": "^6.0.3",
+        "@rollup/plugin-node-resolve": "^15.0.1",
+        "@rollup/plugin-terser": "^0.1.0",
+        "@testing-library/dom": "^8.19.0",
         "@types/debug": "^4.1.7",
-        "@types/jest": "^28.1.6",
+        "@types/jest": "^29.2.4",
         "@types/jquery": "^3.5.14",
-        "@typescript-eslint/eslint-plugin": "^5.32.0",
-        "@typescript-eslint/parser": "^5.32.0",
-        "autoprefixer": "^10.4.8",
-        "babel-jest": "^28.1.3",
+        "@types/node": "^18.11.17",
+        "@typescript-eslint/eslint-plugin": "^5.47.0",
+        "@typescript-eslint/parser": "^5.47.0",
+        "autoprefixer": "^10.4.13",
+        "babel-jest": "^29.3.1",
         "babel-plugin-istanbul": "^6.1.1",
-        "coveralls": "^3.1.1",
-        "eslint": "^8.21.0",
+        "eslint": "^8.30.0",
         "eslint-plugin-import": "^2.26.0",
-        "eslint-plugin-jest": "^26.7.0",
-        "eslint-plugin-playwright": "^0.10.0",
-        "eslint-plugin-testing-library": "^5.6.0",
+        "eslint-plugin-jest": "^27.1.7",
+        "eslint-plugin-playwright": "^0.11.2",
+        "eslint-plugin-testing-library": "^5.9.1",
         "givens": "^1.3.9",
-        "jest": "^28.1.3",
-        "jest-environment-jsdom": "^28.1.3",
-        "jest-extended": "^3.0.2",
+        "graphql": "^16.6.0",
+        "jest": "^29.3.1",
+        "jest-environment-jsdom": "^29.3.1",
+        "jest-extended": "^3.2.0",
         "jsonfile": "^6.1.0",
         "lodash.template": "^4.5.0",
-        "msw": "^0.44.2",
+        "msw": "^0.49.2",
         "nyc": "^15.1.0",
-        "playwright": "^1.24.2",
-        "postcss": "^8.4.16",
-        "postcss-cli": "^10.0.0",
-        "postcss-import": "^14.1.0",
+        "playwright": "^1.29.1",
+        "postcss": "^8.4.20",
+        "postcss-cli": "^10.1.0",
+        "postcss-import": "^15.1.0",
         "postcss-load-config": "^4.0.1",
-        "postcss-nested": "^5.0.6",
-        "prettier": "^2.7.1",
-        "rollup": "^2.77.2",
-        "rollup-plugin-serve": "^2.0.0",
-        "rollup-plugin-terser": "^7.0.2",
-        "tslib": "^2.4.0",
-        "typescript": "^4.7.4"
+        "postcss-nested": "^6.0.0",
+        "prettier": "^2.8.1",
+        "rollup": "^3.8.1",
+        "rollup-plugin-serve": "^2.0.2",
+        "tslib": "^2.4.1",
+        "typescript": "~4.9.4"
     }
 }

package/src/keyHandler.ts

@@ -22,11 +22,11 @@ export default class KeyHandler {
     }
 
     public moveDown(selectedNode: Node): boolean {
-        return this.selectNode(selectedNode.getNextNode());
+        return this.selectNode(selectedNode.getNextVisibleNode());
     }
 
     public moveUp(selectedNode: Node): boolean {
-        return this.selectNode(selectedNode.getPreviousNode());
+        return this.selectNode(selectedNode.getPreviousVisibleNode());
     }
 
     public moveRight(selectedNode: Node): boolean {
@@ -36,7 +36,7 @@ export default class KeyHandler {
             // folder node
             if (selectedNode.is_open) {
                 // Right moves to the first child of an open node
-                return this.selectNode(selectedNode.getNextNode());
+                return this.selectNode(selectedNode.getNextVisibleNode());
             } else {
                 // Right expands a closed node
                 this.treeWidget.openNode(selectedNode);

package/src/node.ts

@@ -557,7 +557,23 @@ export class Node implements INode {
     }
 
     public getNextNode(includeChildren = true): Node | null {
-        if (includeChildren && this.hasChildren() && this.is_open) {
+        if (includeChildren && this.hasChildren()) {
+            return this.children[0];
+        } else if (!this.parent) {
+            return null;
+        } else {
+            const nextSibling = this.getNextSibling();
+
+            if (nextSibling) {
+                return nextSibling;
+            } else {
+                return this.parent.getNextNode(false);
+            }
+        }
+    }
+
+    public getNextVisibleNode(): Node | null {
+        if (this.hasChildren() && this.is_open) {
             // First child
             return this.children[0];
         } else {
@@ -581,19 +597,34 @@ export class Node implements INode {
             return null;
         } else {
             const previousSibling = this.getPreviousSibling();
-            if (previousSibling) {
-                if (
-                    !previousSibling.hasChildren() ||
-                    !previousSibling.is_open
-                ) {
-                    // Previous sibling
-                    return previousSibling;
-                } else {
-                    // Last child of previous sibling
-                    return previousSibling.getLastChild();
-                }
+
+            if (!previousSibling) {
+                return this.getParent();
+            } else if (previousSibling.hasChildren()) {
+                return previousSibling.getLastChild();
             } else {
+                return previousSibling;
+            }
+        }
+    }
+
+    public getPreviousVisibleNode(): Node | null {
+        if (!this.parent) {
+            return null;
+        } else {
+            const previousSibling = this.getPreviousSibling();
+
+            if (!previousSibling) {
                 return this.getParent();
+            } else if (
+                !previousSibling.hasChildren() ||
+                !previousSibling.is_open
+            ) {
+                // Previous sibling
+                return previousSibling;
+            } else {
+                // Last child of previous sibling
+                return previousSibling.getLastChild();
             }
         }
     }

package/src/test/.eslintrc

@@ -3,10 +3,12 @@
   "extends": ["plugin:jest/all", "plugin:testing-library/dom"],
   "rules": {
     "jest/consistent-test-it": "off",
-    "jest/prefer-expect-assertions": "off",
+    "jest/max-expects": ["off"],
     "jest/no-duplicate-hooks": "off",
     "jest/no-hooks": "off",
     "jest/no-identical-title": "off",
+    "jest/no-standalone-expect": "off",
+    "jest/prefer-expect-assertions": "off",
     "jest/prefer-strict-equal": "off",
     "jest/require-hook": "off",
     "jest/require-top-level-describe": "off"

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.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;