jqtree 1.7.4 → 1.8.0

package/src/test/node.test.ts

@@ -159,7 +159,7 @@ describe("addChild", () => {
         expect(given.node.children).toEqual(
             expect.arrayContaining([
                 expect.objectContaining({ id: 100, name: "child1" }),
-            ])
+            ]),
         );
     });
 
@@ -330,7 +330,7 @@ describe("constructor", () => {
     const given = getGiven<Vars>();
 
     given("node", () =>
-        given.params === undefined ? new Node() : new Node(given.params)
+        given.params === undefined ? new Node() : new Node(given.params),
     );
 
     context("without parameters", () => {
@@ -349,7 +349,11 @@ describe("constructor", () => {
                 children: [],
                 parent: null,
             });
-            expect(given.node).not.toHaveProperty("id");
+            expect(given.node.id).toBeUndefined();
+        });
+
+        it("sets isEmptyFolder to false", () => {
+            expect(given.node.isEmptyFolder).toBe(false);
         });
     });
 
@@ -408,7 +412,6 @@ describe("constructor", () => {
                 name: "n1",
                 url: "/",
             });
-            // todo: match object?
             expect(given.node).not.toHaveProperty("label");
             expect(given.node.children).toHaveLength(0);
             expect(given.node.parent).toBeNull();
@@ -434,10 +437,24 @@ describe("constructor", () => {
         }));
 
         it("doesn't set the children", () => {
-            // todo: match object?
             expect(given.node.name).toBe("n1");
             expect(given.node.children).toHaveLength(0);
         });
+
+        it("sets isEmptyFolder to false", () => {
+            expect(given.node.isEmptyFolder).toBe(false);
+        });
+    });
+
+    context("when the data contains an empty children attribute", () => {
+        given("params", () => ({
+            name: "n1",
+            children: [],
+        }));
+
+        it("sets isEmptyFolder to true", () => {
+            expect(given.node.isEmptyFolder).toBe(true);
+        });
     });
 });
 
@@ -719,8 +736,8 @@ describe("getNodeByCallback", () => {
         it("returns the node", () => {
             expect(
                 given.tree.getNodeByCallback((node) =>
-                    node.name.startsWith("chi")
-                )
+                    node.name.startsWith("chi"),
+                ),
             ).toMatchObject({
                 name: "child1",
             });
@@ -776,7 +793,7 @@ describe("getNodeByNameMustExist", () => {
     context("when the node doesn't exist", () => {
         it("throws an exception", () => {
             expect(() =>
-                given.tree.getNodeByNameMustExist("non-existing")
+                given.tree.getNodeByNameMustExist("non-existing"),
             ).toThrow("Node with name non-existing not found");
         });
     });
@@ -1074,16 +1091,10 @@ describe("iterate", () => {
 });
 
 describe("loadFromData", () => {
-    interface Vars {
-        tree: Node;
-    }
-
-    const given = getGiven<Vars>();
-
-    given("tree", () => new Node().loadFromData(exampleData));
-
     it("creates a tree", () => {
-        expect(given.tree.children).toEqual([
+        const tree = new Node().loadFromData(exampleData);
+
+        expect(tree.children).toEqual([
             expect.objectContaining({
                 id: 123,
                 intProperty: 1,
@@ -1103,6 +1114,41 @@ describe("loadFromData", () => {
             }),
         ]);
     });
+
+    it("sets isEmptyFolder to true for a node when it is has an empty children attribute", () => {
+        const data = [
+            {
+                name: "test1",
+                children: [],
+            },
+        ];
+
+        const tree = new Node().loadFromData(data);
+        expect((tree.children[0] as Node).isEmptyFolder).toBe(true);
+    });
+
+    it("sets isEmptyFolder to false for a node when it doesn't have a children attribute", () => {
+        const data = [
+            {
+                name: "test1",
+            },
+        ];
+
+        const tree = new Node().loadFromData(data);
+        expect((tree.children[0] as Node).isEmptyFolder).toBe(false);
+    });
+
+    it("sets isEmptyFolder to false for a node when it has a children attribute that is not empty", () => {
+        const data = [
+            {
+                name: "test1",
+                children: ["child1"],
+            },
+        ];
+
+        const tree = new Node().loadFromData(data);
+        expect((tree.children[0] as Node).isEmptyFolder).toBe(false);
+    });
 });
 
 describe("moveNode", () => {
@@ -1125,7 +1171,7 @@ describe("moveNode", () => {
     context("when moving after a node", () => {
         it("moves the node", () => {
             expect(
-                given.tree.moveNode(given.child2, given.node2, Position.After)
+                given.tree.moveNode(given.child2, given.node2, Position.After),
             ).toBe(true);
 
             expect(given.tree).toMatchObject({
@@ -1147,8 +1193,8 @@ describe("moveNode", () => {
                     given.tree.moveNode(
                         given.child2,
                         given.tree,
-                        Position.After
-                    )
+                        Position.After,
+                    ),
                 ).toBe(false);
             });
         });
@@ -1157,7 +1203,7 @@ describe("moveNode", () => {
     context("when moving inside a node", () => {
         it("moves the node", () => {
             expect(
-                given.tree.moveNode(given.child1, given.node2, Position.Inside)
+                given.tree.moveNode(given.child1, given.node2, Position.Inside),
             ).toBe(true);
 
             expect(given.tree).toMatchObject({
@@ -1182,7 +1228,11 @@ describe("moveNode", () => {
     context("when moving before a node", () => {
         it("moves the node", () => {
             expect(
-                given.tree.moveNode(given.child2, given.child1, Position.Before)
+                given.tree.moveNode(
+                    given.child2,
+                    given.child1,
+                    Position.Before,
+                ),
             ).toBe(true);
 
             expect(given.tree).toMatchObject({
@@ -1206,8 +1256,8 @@ describe("moveNode", () => {
                     given.tree.moveNode(
                         given.child2,
                         given.tree,
-                        Position.Before
-                    )
+                        Position.Before,
+                    ),
                 ).toBe(false);
             });
         });
@@ -1216,7 +1266,7 @@ describe("moveNode", () => {
     context("when the moved node is a parent of the target node", () => {
         it("doesn't move the node", () => {
             expect(
-                given.tree.moveNode(given.node1, given.child1, Position.Before)
+                given.tree.moveNode(given.node1, given.child1, Position.Before),
             ).toBe(false);
 
             expect(given.tree).toMatchObject({
@@ -1237,7 +1287,7 @@ describe("moveNode", () => {
     context("with position None", () => {
         it("returns false", () => {
             expect(
-                given.tree.moveNode(given.child2, given.node2, Position.None)
+                given.tree.moveNode(given.child2, given.node2, Position.None),
             ).toBe(false);
         });
     });
@@ -1283,6 +1333,15 @@ describe("prepend", () => {
             });
         });
     });
+
+    it("sets the isEmptyFolder attribute to true when the node data has empty children", () => {
+        given.node.prepend({
+            name: "test1",
+            children: [],
+        });
+
+        expect((given.node.children[0] as Node).isEmptyFolder).toBe(true);
+    });
 });
 
 describe("remove", () => {

package/src/test/nodeUtils.test.ts

@@ -0,0 +1,21 @@
+import { isNodeRecordWithChildren } from "../nodeUtils";
+
+describe("isNodeRecordWithChildren", () => {
+    it("returns true when the data is an object with the children attribute of type array", () => {
+        const data = {
+            children: [],
+        };
+
+        expect(isNodeRecordWithChildren(data)).toBe(true);
+    });
+
+    it("returns when the data is an object without the children attribute", () => {
+        const data = { name: "test" };
+
+        expect(isNodeRecordWithChildren(data)).toBe(false);
+    });
+
+    it("returns when the data is a string", () => {
+        expect(isNodeRecordWithChildren("test")).toBe(false);
+    });
+});