wyreframe 0.1.0

package/src/parser/Detector/__tests__/HierarchyBuilder_test.mjs

@@ -0,0 +1,489 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Types from "../../Core/Types.mjs";
+import * as Vitest from "rescript-vitest/src/Vitest.mjs";
+import * as HierarchyBuilder from "../HierarchyBuilder.mjs";
+
+Vitest.describe("HierarchyBuilder - Containment Detection", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, () => {
+  Vitest.test("contains returns true when outer completely contains inner", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let outer = Types.Bounds.make(0, 0, 10, 10);
+    let inner = Types.Bounds.make(2, 2, 8, 8);
+    t.expect(HierarchyBuilder.contains(outer, inner)).toBe(true);
+  });
+  Vitest.test("contains returns false when boxes are equal", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let bounds = Types.Bounds.make(0, 0, 10, 10);
+    t.expect(HierarchyBuilder.contains(bounds, bounds)).toBe(false);
+  });
+  Vitest.test("contains returns false when boxes are disjoint", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let box1 = Types.Bounds.make(0, 0, 5, 5);
+    let box2 = Types.Bounds.make(10, 10, 15, 15);
+    t.expect(HierarchyBuilder.contains(box1, box2)).toBe(false);
+  });
+  Vitest.test("contains returns false when boxes partially overlap", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let box1 = Types.Bounds.make(0, 0, 10, 10);
+    let box2 = Types.Bounds.make(5, 5, 15, 15);
+    t.expect(HierarchyBuilder.contains(box1, box2)).toBe(false);
+  });
+  Vitest.test("contains returns false when inner touches outer's edge", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let outer = Types.Bounds.make(0, 0, 10, 10);
+    let inner = Types.Bounds.make(0, 0, 5, 5);
+    t.expect(HierarchyBuilder.contains(outer, inner)).toBe(false);
+  });
+});
+
+Vitest.describe("HierarchyBuilder - findParent", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, () => {
+  Vitest.test("findParent returns None for root box (no container)", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let box = HierarchyBuilder.makeBox("Root", Types.Bounds.make(0, 0, 10, 10));
+    let candidates = [box];
+    t.expect(HierarchyBuilder.findParent(box, candidates)).toEqual(undefined);
+  });
+  Vitest.test("findParent returns immediate parent (smallest containing box)", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let grandparent = HierarchyBuilder.makeBox("Grandparent", Types.Bounds.make(0, 0, 20, 20));
+    let parent = HierarchyBuilder.makeBox("Parent", Types.Bounds.make(2, 2, 18, 18));
+    let child = HierarchyBuilder.makeBox("Child", Types.Bounds.make(4, 4, 16, 16));
+    let candidates = [
+      grandparent,
+      parent,
+      child
+    ];
+    t.expect(HierarchyBuilder.findParent(child, candidates)).toEqual(parent);
+  });
+  Vitest.test("findParent ignores boxes that don't contain the target", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let box1 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(0, 0, 5, 5));
+    let box2 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(10, 10, 15, 15));
+    let candidates = [
+      box1,
+      box2
+    ];
+    t.expect(HierarchyBuilder.findParent(box2, candidates)).toEqual(undefined);
+  });
+});
+
+Vitest.describe("HierarchyBuilder - buildHierarchy - 2-level nesting", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, () => {
+  Vitest.test("builds hierarchy with one root and one child", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let parent = HierarchyBuilder.makeBox("Parent", Types.Bounds.make(0, 0, 10, 10));
+    let child = HierarchyBuilder.makeBox("Child", Types.Bounds.make(2, 2, 8, 8));
+    let boxes = [
+      parent,
+      child
+    ];
+    let result = HierarchyBuilder.buildHierarchy(boxes);
+    if (result.TAG !== "Ok") {
+      return t.expect(true).toBe(false);
+    }
+    let roots = result._0;
+    t.expect(roots.length).toBe(1);
+    let root = roots[0];
+    if (root === undefined) {
+      return t.expect(true).toBe(false);
+    }
+    t.expect(root.name).toEqual("Parent");
+    t.expect(root.children.length).toBe(1);
+    let childBox = root.children[0];
+    if (childBox !== undefined) {
+      return t.expect(childBox.name).toEqual("Child");
+    } else {
+      return t.expect(true).toBe(false);
+    }
+  });
+  Vitest.test("builds hierarchy with one root and multiple children", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let parent = HierarchyBuilder.makeBox("Parent", Types.Bounds.make(0, 0, 20, 20));
+    let child1 = HierarchyBuilder.makeBox("Child1", Types.Bounds.make(2, 2, 8, 8));
+    let child2 = HierarchyBuilder.makeBox("Child2", Types.Bounds.make(12, 12, 18, 18));
+    let boxes = [
+      parent,
+      child1,
+      child2
+    ];
+    let result = HierarchyBuilder.buildHierarchy(boxes);
+    if (result.TAG !== "Ok") {
+      return t.expect(true).toBe(false);
+    }
+    let roots = result._0;
+    t.expect(roots.length).toBe(1);
+    let root = roots[0];
+    if (root !== undefined) {
+      t.expect(root.name).toEqual("Parent");
+      return t.expect(root.children.length).toBe(2);
+    } else {
+      return t.expect(true).toBe(false);
+    }
+  });
+});
+
+Vitest.describe("HierarchyBuilder - buildHierarchy - 3-level nesting", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, () => {
+  Vitest.test("builds hierarchy with 3 levels: root -> child -> grandchild", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let root = HierarchyBuilder.makeBox("Root", Types.Bounds.make(0, 0, 30, 30));
+    let child = HierarchyBuilder.makeBox("Child", Types.Bounds.make(5, 5, 25, 25));
+    let grandchild = HierarchyBuilder.makeBox("Grandchild", Types.Bounds.make(10, 10, 20, 20));
+    let boxes = [
+      root,
+      child,
+      grandchild
+    ];
+    let result = HierarchyBuilder.buildHierarchy(boxes);
+    if (result.TAG !== "Ok") {
+      return t.expect(true).toBe(false);
+    }
+    let roots = result._0;
+    t.expect(roots.length).toBe(1);
+    let rootBox = roots[0];
+    if (rootBox === undefined) {
+      return t.expect(true).toBe(false);
+    }
+    t.expect(rootBox.name).toEqual("Root");
+    t.expect(rootBox.children.length).toBe(1);
+    let childBox = rootBox.children[0];
+    if (childBox === undefined) {
+      return t.expect(true).toBe(false);
+    }
+    t.expect(childBox.name).toEqual("Child");
+    t.expect(childBox.children.length).toBe(1);
+    let grandchildBox = childBox.children[0];
+    if (grandchildBox !== undefined) {
+      return t.expect(grandchildBox.name).toEqual("Grandchild");
+    } else {
+      return t.expect(true).toBe(false);
+    }
+  });
+  Vitest.test("getDepth correctly calculates depth for 3-level hierarchy", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let root = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(0, 0, 30, 30));
+    let child = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(5, 5, 25, 25));
+    let grandchild = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(10, 10, 20, 20));
+    let allBoxes = [
+      root,
+      child,
+      grandchild
+    ];
+    t.expect(HierarchyBuilder.getDepth(root, allBoxes)).toBe(0);
+    t.expect(HierarchyBuilder.getDepth(child, allBoxes)).toBe(1);
+    t.expect(HierarchyBuilder.getDepth(grandchild, allBoxes)).toBe(2);
+  });
+});
+
+Vitest.describe("HierarchyBuilder - buildHierarchy - 4-level nesting", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, () => {
+  Vitest.test("builds hierarchy with 4 levels: root -> child -> grandchild -> great-grandchild", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let root = HierarchyBuilder.makeBox("Root", Types.Bounds.make(0, 0, 40, 40));
+    let child = HierarchyBuilder.makeBox("Child", Types.Bounds.make(5, 5, 35, 35));
+    let grandchild = HierarchyBuilder.makeBox("Grandchild", Types.Bounds.make(10, 10, 30, 30));
+    let greatGrandchild = HierarchyBuilder.makeBox("GreatGrandchild", Types.Bounds.make(15, 15, 25, 25));
+    let boxes = [
+      root,
+      child,
+      grandchild,
+      greatGrandchild
+    ];
+    let result = HierarchyBuilder.buildHierarchy(boxes);
+    if (result.TAG !== "Ok") {
+      return t.expect(true).toBe(false);
+    }
+    let roots = result._0;
+    t.expect(roots.length).toBe(1);
+    let rootBox = roots[0];
+    if (rootBox === undefined) {
+      return t.expect(true).toBe(false);
+    }
+    t.expect(rootBox.name).toEqual("Root");
+    t.expect(rootBox.children.length).toBe(1);
+    let childBox = rootBox.children[0];
+    if (childBox === undefined) {
+      return t.expect(true).toBe(false);
+    }
+    t.expect(childBox.name).toEqual("Child");
+    t.expect(childBox.children.length).toBe(1);
+    let grandchildBox = childBox.children[0];
+    if (grandchildBox === undefined) {
+      return t.expect(true).toBe(false);
+    }
+    t.expect(grandchildBox.name).toEqual("Grandchild");
+    t.expect(grandchildBox.children.length).toBe(1);
+    let greatGrandchildBox = grandchildBox.children[0];
+    if (greatGrandchildBox !== undefined) {
+      return t.expect(greatGrandchildBox.name).toEqual("GreatGrandchild");
+    } else {
+      return t.expect(true).toBe(false);
+    }
+  });
+  Vitest.test("getDepth correctly calculates depth for 4-level hierarchy", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let root = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(0, 0, 40, 40));
+    let child = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(5, 5, 35, 35));
+    let grandchild = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(10, 10, 30, 30));
+    let greatGrandchild = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(15, 15, 25, 25));
+    let allBoxes = [
+      root,
+      child,
+      grandchild,
+      greatGrandchild
+    ];
+    t.expect(HierarchyBuilder.getDepth(root, allBoxes)).toBe(0);
+    t.expect(HierarchyBuilder.getDepth(child, allBoxes)).toBe(1);
+    t.expect(HierarchyBuilder.getDepth(grandchild, allBoxes)).toBe(2);
+    t.expect(HierarchyBuilder.getDepth(greatGrandchild, allBoxes)).toBe(3);
+  });
+});
+
+Vitest.describe("HierarchyBuilder - buildHierarchy - Multiple roots", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, () => Vitest.test("handles multiple root boxes with children", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+  let root1 = HierarchyBuilder.makeBox("Root1", Types.Bounds.make(0, 0, 10, 10));
+  let root1Child = HierarchyBuilder.makeBox("Root1Child", Types.Bounds.make(2, 2, 8, 8));
+  let root2 = HierarchyBuilder.makeBox("Root2", Types.Bounds.make(20, 20, 30, 30));
+  let root2Child = HierarchyBuilder.makeBox("Root2Child", Types.Bounds.make(22, 22, 28, 28));
+  let boxes = [
+    root1,
+    root1Child,
+    root2,
+    root2Child
+  ];
+  let result = HierarchyBuilder.buildHierarchy(boxes);
+  if (result.TAG !== "Ok") {
+    return t.expect(true).toBe(false);
+  }
+  let roots = result._0;
+  t.expect(roots.length).toBe(2);
+  roots.forEach(root => t.expect(root.children.length).toBe(1));
+}));
+
+Vitest.describe("HierarchyBuilder - buildHierarchy - Error cases", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, () => {
+  Vitest.test("detects overlapping boxes (invalid partial overlap)", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let box1 = HierarchyBuilder.makeBox("Box1", Types.Bounds.make(0, 0, 10, 10));
+    let box2 = HierarchyBuilder.makeBox("Box2", Types.Bounds.make(5, 5, 15, 15));
+    let boxes = [
+      box1,
+      box2
+    ];
+    let result = HierarchyBuilder.buildHierarchy(boxes);
+    if (result.TAG === "Ok") {
+      return t.expect(true).toBe(false);
+    }
+    let match = result._0;
+    if (typeof match !== "object") {
+      return t.expect(true).toBe(false);
+    }
+    let b2 = match.box2;
+    let b1 = match.box1;
+    t.expect(b1 === box1 || b1 === box2).toBe(true);
+    t.expect(b2 === box1 || b2 === box2).toBe(true);
+    t.expect(b1 !== b2).toBe(true);
+  });
+  Vitest.test("allows disjoint boxes (no overlap)", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let box1 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(0, 0, 5, 5));
+    let box2 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(10, 10, 15, 15));
+    let boxes = [
+      box1,
+      box2
+    ];
+    let result = HierarchyBuilder.buildHierarchy(boxes);
+    if (result.TAG === "Ok") {
+      return t.expect(result._0.length).toBe(2);
+    } else {
+      return t.expect(true).toBe(false);
+    }
+  });
+  Vitest.test("allows nested boxes (one contains the other)", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let outer = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(0, 0, 10, 10));
+    let inner = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(2, 2, 8, 8));
+    let boxes = [
+      outer,
+      inner
+    ];
+    let result = HierarchyBuilder.buildHierarchy(boxes);
+    if (result.TAG !== "Ok") {
+      return t.expect(true).toBe(false);
+    }
+    let roots = result._0;
+    t.expect(roots.length).toBe(1);
+    let root = roots[0];
+    if (root !== undefined) {
+      return t.expect(root.children.length).toBe(1);
+    } else {
+      return t.expect(true).toBe(false);
+    }
+  });
+});
+
+Vitest.describe("HierarchyBuilder - Deep Nesting Detection", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, () => {
+  Vitest.describe("collectDeepNestingWarnings", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, () => {
+    Vitest.test("should not warn for boxes at or below threshold (depth 0-4)", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+      let root = HierarchyBuilder.makeBox("Root", Types.Bounds.make(0, 0, 10, 10));
+      let warnings0 = HierarchyBuilder.collectDeepNestingWarnings(root, 0, 4);
+      t.expect(warnings0.length).toBe(0);
+      let warnings4 = HierarchyBuilder.collectDeepNestingWarnings(root, 4, 4);
+      t.expect(warnings4.length).toBe(0);
+    });
+    Vitest.test("should warn when depth exceeds threshold of 4", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+      let deepBox = HierarchyBuilder.makeBox("DeepBox", Types.Bounds.make(5, 5, 8, 8));
+      let warnings = HierarchyBuilder.collectDeepNestingWarnings(deepBox, 5, 4);
+      t.expect(warnings.length).toBe(1);
+      let warning = warnings[0];
+      t.expect(warning.severity).toEqual("Warning");
+      let match = warning.code;
+      if (match.TAG !== "DeepNesting") {
+        return t.expect(true).toBe(false);
+      }
+      let position = match.position;
+      t.expect(match.depth).toBe(5);
+      t.expect(position.row).toBe(5);
+      t.expect(position.col).toBe(5);
+    });
+    Vitest.test("should collect warnings from all children recursively", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+      let parent = HierarchyBuilder.makeBox("Parent", Types.Bounds.make(0, 0, 20, 20));
+      let child1 = HierarchyBuilder.makeBox("Child1", Types.Bounds.make(2, 2, 8, 8));
+      let child2 = HierarchyBuilder.makeBox("Child2", Types.Bounds.make(12, 12, 18, 18));
+      parent.children.push(child1);
+      parent.children.push(child2);
+      let warnings = HierarchyBuilder.collectDeepNestingWarnings(parent, 4, 4);
+      t.expect(warnings.length).toBe(2);
+    });
+    Vitest.test("should handle custom threshold", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+      let box = HierarchyBuilder.makeBox("Box", Types.Bounds.make(0, 0, 5, 5));
+      let warnings = HierarchyBuilder.collectDeepNestingWarnings(box, 3, 2);
+      t.expect(warnings.length).toBe(1);
+      let warnings2 = HierarchyBuilder.collectDeepNestingWarnings(box, 3, 5);
+      t.expect(warnings2.length).toBe(0);
+    });
+  });
+  Vitest.describe("detectDeepNesting", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, () => {
+    Vitest.test("should detect deep nesting in complete hierarchy", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+      let root = HierarchyBuilder.makeBox("Root", Types.Bounds.make(0, 0, 50, 50));
+      let level1 = HierarchyBuilder.makeBox("Level1", Types.Bounds.make(2, 2, 48, 48));
+      let level2 = HierarchyBuilder.makeBox("Level2", Types.Bounds.make(4, 4, 46, 46));
+      let level3 = HierarchyBuilder.makeBox("Level3", Types.Bounds.make(6, 6, 44, 44));
+      let level4 = HierarchyBuilder.makeBox("Level4", Types.Bounds.make(8, 8, 42, 42));
+      let level5 = HierarchyBuilder.makeBox("Level5", Types.Bounds.make(10, 10, 40, 40));
+      root.children.push(level1);
+      level1.children.push(level2);
+      level2.children.push(level3);
+      level3.children.push(level4);
+      level4.children.push(level5);
+      let warnings = HierarchyBuilder.detectDeepNesting([root], 4);
+      t.expect(warnings.length).toBe(1);
+      let warning = warnings[0];
+      if (warning === undefined) {
+        return t.expect(true).toBe(false);
+      }
+      let match = warning.code;
+      if (match.TAG !== "DeepNesting") {
+        return t.expect(true).toBe(false);
+      }
+      let position = match.position;
+      t.expect(match.depth).toBe(5);
+      t.expect(position.row).toBe(10);
+      t.expect(position.col).toBe(10);
+    });
+    Vitest.test("should detect multiple deep boxes in different branches", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+      let root = HierarchyBuilder.makeBox("Root", Types.Bounds.make(0, 0, 100, 100));
+      let b1_l1 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(2, 2, 48, 48));
+      let b1_l2 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(4, 4, 46, 46));
+      let b1_l3 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(6, 6, 44, 44));
+      let b1_l4 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(8, 8, 42, 42));
+      let b1_l5 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(10, 10, 40, 40));
+      let b2_l1 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(52, 52, 98, 98));
+      let b2_l2 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(54, 54, 96, 96));
+      let b2_l3 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(56, 56, 94, 94));
+      let b2_l4 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(58, 58, 92, 92));
+      let b2_l5 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(60, 60, 90, 90));
+      let b2_l6 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(62, 62, 88, 88));
+      root.children.push(b1_l1);
+      root.children.push(b2_l1);
+      b1_l1.children.push(b1_l2);
+      b1_l2.children.push(b1_l3);
+      b1_l3.children.push(b1_l4);
+      b1_l4.children.push(b1_l5);
+      b2_l1.children.push(b2_l2);
+      b2_l2.children.push(b2_l3);
+      b2_l3.children.push(b2_l4);
+      b2_l4.children.push(b2_l5);
+      b2_l5.children.push(b2_l6);
+      let warnings = HierarchyBuilder.detectDeepNesting([root], 4);
+      t.expect(warnings.length).toBe(3);
+    });
+    Vitest.test("should handle multiple root boxes", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+      let root1 = HierarchyBuilder.makeBox("Root1", Types.Bounds.make(0, 0, 30, 30));
+      let root1_child = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(2, 2, 28, 28));
+      let root2 = HierarchyBuilder.makeBox("Root2", Types.Bounds.make(40, 40, 90, 90));
+      let root2_l1 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(42, 42, 88, 88));
+      let root2_l2 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(44, 44, 86, 86));
+      let root2_l3 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(46, 46, 84, 84));
+      let root2_l4 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(48, 48, 82, 82));
+      let root2_l5 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(50, 50, 80, 80));
+      root1.children.push(root1_child);
+      root2.children.push(root2_l1);
+      root2_l1.children.push(root2_l2);
+      root2_l2.children.push(root2_l3);
+      root2_l3.children.push(root2_l4);
+      root2_l4.children.push(root2_l5);
+      let warnings = HierarchyBuilder.detectDeepNesting([
+        root1,
+        root2
+      ], 4);
+      t.expect(warnings.length).toBe(1);
+    });
+    Vitest.test("should return empty array when no deep nesting", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+      let root = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(0, 0, 30, 30));
+      let child1 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(2, 2, 14, 14));
+      let child2 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(16, 16, 28, 28));
+      root.children.push(child1);
+      root.children.push(child2);
+      let warnings = HierarchyBuilder.detectDeepNesting([root], 4);
+      t.expect(warnings.length).toBe(0);
+    });
+  });
+  Vitest.describe("getMaxDepth", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, () => {
+    Vitest.test("should return 0 for empty array", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+      let maxDepth = HierarchyBuilder.getMaxDepth([]);
+      t.expect(maxDepth).toBe(0);
+    });
+    Vitest.test("should return 0 for single root box with no children", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+      let root = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(0, 0, 10, 10));
+      let maxDepth = HierarchyBuilder.getMaxDepth([root]);
+      t.expect(maxDepth).toBe(0);
+    });
+    Vitest.test("should calculate max depth for single branch", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+      let root = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(0, 0, 30, 30));
+      let level1 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(2, 2, 28, 28));
+      let level2 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(4, 4, 26, 26));
+      root.children.push(level1);
+      level1.children.push(level2);
+      let maxDepth = HierarchyBuilder.getMaxDepth([root]);
+      t.expect(maxDepth).toBe(2);
+    });
+    Vitest.test("should find max depth across multiple branches", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+      let root = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(0, 0, 100, 100));
+      let b1_l1 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(2, 2, 20, 20));
+      let b1_l2 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(4, 4, 18, 18));
+      let b2_l1 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(30, 30, 98, 98));
+      let b2_l2 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(32, 32, 96, 96));
+      let b2_l3 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(34, 34, 94, 94));
+      let b2_l4 = HierarchyBuilder.makeBox(undefined, Types.Bounds.make(36, 36, 92, 92));
+      root.children.push(b1_l1);
+      root.children.push(b2_l1);
+      b1_l1.children.push(b1_l2);
+      b2_l1.children.push(b2_l2);
+      b2_l2.children.push(b2_l3);
+      b2_l3.children.push(b2_l4);
+      let maxDepth = HierarchyBuilder.getMaxDepth([root]);
+      t.expect(maxDepth).toBe(4);
+    });
+  });
+  Vitest.describe("Integration with buildHierarchy", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, () => Vitest.test("should detect deep nesting after building hierarchy from flat array", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let boxes = [
+      HierarchyBuilder.makeBox("Root", Types.Bounds.make(0, 0, 50, 50)),
+      HierarchyBuilder.makeBox("L1", Types.Bounds.make(2, 2, 48, 48)),
+      HierarchyBuilder.makeBox("L2", Types.Bounds.make(4, 4, 46, 46)),
+      HierarchyBuilder.makeBox("L3", Types.Bounds.make(6, 6, 44, 44)),
+      HierarchyBuilder.makeBox("L4", Types.Bounds.make(8, 8, 42, 42)),
+      HierarchyBuilder.makeBox("L5", Types.Bounds.make(10, 10, 40, 40))
+    ];
+    let result = HierarchyBuilder.buildHierarchy(boxes);
+    if (result.TAG !== "Ok") {
+      return t.expect(true).toBe(false);
+    }
+    let roots = result._0;
+    t.expect(roots.length).toBe(1);
+    let warnings = HierarchyBuilder.detectDeepNesting(roots, 4);
+    t.expect(warnings.length).toBe(1);
+    let maxDepth = HierarchyBuilder.getMaxDepth(roots);
+    t.expect(maxDepth).toBe(5);
+  }));
+});
+
+/*  Not a pure module */