Add layout tree validation and improve error handling

src/App.tsx

@@ -13,7 +13,6 @@ export function App() {
     getDropIndicatorProps,
     getDragHandleProps,
   } = useDockLayout<HTMLDivElement>(() => {
-    console.info("working");
     const root = localStorage.getItem("layout");
     if (root === null) {
       return null;

src/index.ts

@@ -1,3 +1,9 @@
 export * from "./strategies";
 export * from "./types";
 export * from "./useDockLayout";
+export {
+  validateLayoutTree,
+  assertValidLayoutTree,
+  type ValidationError,
+  type ValidationResult,
+} from "./internal/LayoutManager/validateLayoutTree";

src/internal/LayoutManager/LayoutManager.test.ts

@@ -8,7 +8,7 @@ describe("LayoutManager", () => {
       const root = null;
       const layoutManager = new LayoutManager(root);
       expect(() => layoutManager.resizePanel("root", { x: 0, y: 0 })).toThrow(
-        "Root node is null",
+        /resizePanel.*Cannot resize.*empty layout/,
       );
     });
 
@@ -20,7 +20,7 @@ describe("LayoutManager", () => {
       const layoutManager = new LayoutManager(root);
       expect(() =>
         layoutManager.resizePanel("non-existent-id", { x: 0, y: 0 }),
-      ).toThrow("Rect with id non-existent-id not found");
+      ).toThrow(/resizePanel.*non-existent-id.*not found/);
     });
 
     it("should throw an error when the rect is not a split node", () => {
@@ -30,7 +30,7 @@ describe("LayoutManager", () => {
       };
       const layoutManager = new LayoutManager(root);
       expect(() => layoutManager.resizePanel("root", { x: 0, y: 0 })).toThrow(
-        "Rect with id root is not a split node",
+        /resizePanel.*Expected split.*got panel/,
       );
     });
 
@@ -190,7 +190,7 @@ describe("LayoutManager", () => {
     it("should throw an error if the root is null", () => {
       const layoutManager = new LayoutManager(null);
       expect(() => layoutManager.removePanel("root")).toThrowError(
-        "Root node is null",
+        /removePanel.*Cannot remove.*empty layout/,
       );
     });
 
@@ -200,7 +200,7 @@ describe("LayoutManager", () => {
         type: "panel",
       });
       expect(() => layoutManager.removePanel("nonexistent")).toThrowError(
-        "Node with id nonexistent not found",
+        /removePanel.*nonexistent.*not found/,
       );
     });
 
@@ -220,7 +220,7 @@ describe("LayoutManager", () => {
         },
       });
       expect(() => layoutManager.removePanel("root")).toThrowError(
-        "Node with id root is not a panel",
+        /removePanel.*root.*is a split.*expected panel/,
       );
     });
 
@@ -312,7 +312,7 @@ describe("LayoutManager", () => {
           targetId: "target",
           point: { x: 0, y: 0 },
         }),
-      ).toThrowError("Root node is null");
+      ).toThrowError(/movePanel.*Cannot move.*empty layout/);
     });
 
     it("should throw an error if the root is not a split node", () => {
@@ -326,7 +326,7 @@ describe("LayoutManager", () => {
           targetId: "target",
           point: { x: 0, y: 0 },
         }),
-      ).toThrowError("Root node is not a split node");
+      ).toThrowError(/movePanel.*Cannot move.*only one panel/);
     });
 
     it("should throw an error if the source node is not found", () => {
@@ -350,7 +350,7 @@ describe("LayoutManager", () => {
           targetId: "target",
           point: { x: 0, y: 0 },
         }),
-      ).toThrowError("Node with id nonexistent not found");
+      ).toThrowError(/movePanel.*Source panel "nonexistent" not found/);
     });
 
     it("should throw an error if the source node is not a panel node", () => {
@@ -384,7 +384,7 @@ describe("LayoutManager", () => {
           targetId: "target",
           point: { x: 0, y: 0 },
         }),
-      ).toThrowError("Node with id left is not a panel node");
+      ).toThrowError(/movePanel.*Source "left" is a split.*expected panel/);
     });
 
     it("should throw an error if the target node is not found", () => {
@@ -408,7 +408,7 @@ describe("LayoutManager", () => {
           targetId: "nonexistent",
           point: { x: 0, y: 0 },
         }),
-      ).toThrowError("Node with id nonexistent not found");
+      ).toThrowError(/movePanel.*Target panel "nonexistent" not found/);
     });
 
     it("should throw an error if the target node is not a panel node", () => {
@@ -442,7 +442,7 @@ describe("LayoutManager", () => {
           targetId: "right",
           point: { x: 0, y: 0 },
         }),
-      ).toThrowError("Node with id right is not a panel node");
+      ).toThrowError(/movePanel.*Target "right" is a split.*expected panel/);
     });
 
     it("should move the panel when the source node is the sibling of the target node", () => {

src/internal/LayoutManager/LayoutManager.ts

@@ -16,6 +16,7 @@ import { calculateMinSize } from "./calculateMinSize";
 import { findClosestDirection } from "./findClosestDirection";
 import { LayoutTree } from "./LayoutTree";
 import type { Direction, Point, Rect, Size } from "./types";
+import { assertValidLayoutTree } from "./validateLayoutTree";
 
 export class LayoutManager {
   private readonly MIN_RESIZE_RATIO = 0.1;
@@ -27,6 +28,9 @@ export class LayoutManager {
   private _layoutRects: LayoutRect[] = [];
 
   constructor(root: LayoutNode | null, options?: LayoutManagerOptions) {
+    // Validate the initial layout tree to catch errors early
+    assertValidLayoutTree(root);
+
     this._tree = new LayoutTree(root);
     this._options = {
       gap: options?.gap ?? 10,
@@ -42,6 +46,8 @@ export class LayoutManager {
   }
 
   set root(root: LayoutNode | null) {
+    // Validate before setting to catch errors early
+    assertValidLayoutTree(root);
     this._tree.root = root;
     this.syncLayoutRects();
   }
@@ -65,17 +71,23 @@ export class LayoutManager {
 
   removePanel(id: string) {
     if (this._tree.root === null) {
-      throw new Error("Root node is null");
+      throw new Error(
+        `removePanel("${id}"): Cannot remove panel from empty layout`,
+      );
     }
 
     const node = this._tree.findNode(id);
 
     if (node === null) {
-      throw new Error(`Node with id ${id} not found`);
+      throw new Error(
+        `removePanel("${id}"): Panel not found in layout tree`,
+      );
     }
 
     if (node.type !== "panel") {
-      throw new Error(`Node with id ${id} is not a panel`);
+      throw new Error(
+        `removePanel("${id}"): Node is a ${node.type}, expected panel`,
+      );
     }
 
     if (node.id === this._tree.root.id) {
@@ -117,19 +129,27 @@ export class LayoutManager {
     point: Point;
   }) {
     if (this._tree.root === null) {
-      throw new Error("Root node is null");
+      throw new Error(
+        `movePanel("${sourceId}" → "${targetId}"): Cannot move panel in empty layout`,
+      );
     }
     if (this._tree.root.type !== "split") {
-      throw new Error("Root node is not a split node");
+      throw new Error(
+        `movePanel("${sourceId}" → "${targetId}"): Cannot move panel when layout has only one panel`,
+      );
     }
 
     const sourceNode = this._tree.findNode(sourceId);
 
     if (sourceNode === null) {
-      throw new Error(`Node with id ${sourceId} not found`);
+      throw new Error(
+        `movePanel("${sourceId}" → "${targetId}"): Source panel "${sourceId}" not found`,
+      );
     }
     if (sourceNode.type !== "panel") {
-      throw new Error(`Node with id ${sourceId} is not a panel node`);
+      throw new Error(
+        `movePanel("${sourceId}" → "${targetId}"): Source "${sourceId}" is a ${sourceNode.type}, expected panel`,
+      );
     }
 
     const sourceNodeParent = this._tree.findParentNode(sourceId);
@@ -138,10 +158,14 @@ export class LayoutManager {
     const targetNode = this._tree.findNode(targetId);
 
     if (targetNode === null) {
-      throw new Error(`Node with id ${targetId} not found`);
+      throw new Error(
+        `movePanel("${sourceId}" → "${targetId}"): Target panel "${targetId}" not found`,
+      );
     }
     if (targetNode.type !== "panel") {
-      throw new Error(`Node with id ${targetId} is not a panel node`);
+      throw new Error(
+        `movePanel("${sourceId}" → "${targetId}"): Target "${targetId}" is a ${targetNode.type}, expected panel`,
+      );
     }
 
     const sourceNodeSibling =
@@ -210,17 +234,23 @@ export class LayoutManager {
 
   resizePanel(id: string, point: Point) {
     if (this._tree.root === null) {
-      throw new Error("Root node is null");
+      throw new Error(
+        `resizePanel("${id}"): Cannot resize in empty layout`,
+      );
     }
 
     const resizingRect = this.findRect(id);
 
     if (resizingRect === null) {
-      throw new Error(`Rect with id ${id} not found`);
+      throw new Error(
+        `resizePanel("${id}"): Split bar not found in layout`,
+      );
     }
 
     if (resizingRect.type !== "split") {
-      throw new Error(`Rect with id ${id} is not a split node`);
+      throw new Error(
+        `resizePanel("${id}"): Expected split bar, got ${resizingRect.type}`,
+      );
     }
 
     const splitNode = this._tree.findNode(id);
@@ -266,7 +296,9 @@ export class LayoutManager {
     const targetNode = this._tree.findNode(targetId);
 
     if (targetNode === null) {
-      throw new Error(`Node with id ${targetId} not found`);
+      throw new Error(
+        `addPanel("${id}"): Placement strategy returned target "${targetId}" which was not found in layout tree`,
+      );
     }
 
     const targetNodeParent = this._tree.findParentNode(targetId);