wyreframe 0.1.0

package/src/parser/Core/Types.res

@@ -0,0 +1,331 @@
+// Core type definitions for Wyreframe parser
+// These types represent the parsed AST structure
+
+// Position in the grid (row, col)
+module rec Position: {
+  type t = {
+    row: int,
+    col: int,
+  }
+
+  let make: (int, int) => t
+  let right: (t, ~n: int=?) => t
+  let down: (t, ~n: int=?) => t
+  let left: (t, ~n: int=?) => t
+  let up: (t, ~n: int=?) => t
+  let equals: (t, t) => bool
+  let isWithin: (t, Bounds.t) => bool
+  let toString: t => string
+} = {
+  type t = {
+    row: int,
+    col: int,
+  }
+
+  let make = (row: int, col: int): t => {row, col}
+
+  // Move right by n columns (default: 1)
+  let right = (pos: t, ~n: int=1): t => {
+    {row: pos.row, col: pos.col + n}
+  }
+
+  // Move down by n rows (default: 1)
+  let down = (pos: t, ~n: int=1): t => {
+    {row: pos.row + n, col: pos.col}
+  }
+
+  // Move left by n columns (default: 1)
+  let left = (pos: t, ~n: int=1): t => {
+    {row: pos.row, col: pos.col - n}
+  }
+
+  // Move up by n rows (default: 1)
+  let up = (pos: t, ~n: int=1): t => {
+    {row: pos.row - n, col: pos.col}
+  }
+
+  let equals = (a: t, b: t): bool => a.row == b.row && a.col == b.col
+
+  // Check if position is within given bounds (inclusive)
+  let isWithin = (pos: t, bounds: Bounds.t): bool => {
+    pos.row >= bounds.top &&
+    pos.row <= bounds.bottom &&
+    pos.col >= bounds.left &&
+    pos.col <= bounds.right
+  }
+
+  let toString = (pos: t): string => `(${Int.toString(pos.row)}, ${Int.toString(pos.col)})`
+}
+
+// Bounding box
+and Bounds: {
+  type t = {
+    top: int,
+    left: int,
+    bottom: int,
+    right: int,
+  }
+
+  let make: (~top: int, ~left: int, ~bottom: int, ~right: int) => t
+  let width: t => int
+  let height: t => int
+  let area: t => int
+  let contains: (t, t) => bool
+  let overlaps: (t, t) => bool
+  let equals: (t, t) => bool
+} = {
+  type t = {
+    top: int,
+    left: int,
+    bottom: int,
+    right: int,
+  }
+
+  let make = (~top: int, ~left: int, ~bottom: int, ~right: int): t => {
+    top,
+    left,
+    bottom,
+    right,
+  }
+
+  let width = (bounds: t): int => bounds.right - bounds.left
+  let height = (bounds: t): int => bounds.bottom - bounds.top
+  let area = (bounds: t): int => width(bounds) * height(bounds)
+
+  // Strict containment - inner must be strictly inside outer (not touching edges)
+  let contains = (outer: t, inner: t): bool => {
+    outer.top < inner.top &&
+    outer.left < inner.left &&
+    outer.bottom > inner.bottom &&
+    outer.right > inner.right
+  }
+
+  let overlaps = (a: t, b: t): bool => {
+    !(a.right < b.left || b.right < a.left || a.bottom < b.top || b.bottom < a.top)
+  }
+
+  let equals = (a: t, b: t): bool => {
+    a.top == b.top && a.left == b.left && a.bottom == b.bottom && a.right == b.right
+  }
+}
+
+// Cell character types for grid representation
+type cellChar =
+  | Corner // '+'
+  | HLine  // '-'
+  | VLine  // '|'
+  | Divider // '='
+  | Space  // ' '
+  | Char(string) // Any other character
+
+// Alignment type
+type alignment =
+  | Left
+  | Center
+  | Right
+
+// Forward declaration of action type for use in elements
+type rec interactionAction =
+  | Goto({
+      target: string,
+      transition: string,
+      condition: option<string>,
+    })
+  | Back
+  | Forward
+  | Validate({fields: array<string>})
+  | Call({
+      function: string,
+      args: array<string>,
+      condition: option<string>,
+    })
+
+// Element types
+and element =
+  | Box({
+      name: option<string>,
+      bounds: Bounds.t,
+      children: array<element>,
+    })
+  | Button({
+      id: string,
+      text: string,
+      position: Position.t,
+      align: alignment,
+      actions: array<interactionAction>,
+    })
+  | Input({
+      id: string,
+      placeholder: option<string>,
+      position: Position.t,
+    })
+  | Link({
+      id: string,
+      text: string,
+      position: Position.t,
+      align: alignment,
+      actions: array<interactionAction>,
+    })
+  | Checkbox({
+      checked: bool,
+      label: string,
+      position: Position.t,
+    })
+  | Text({
+      content: string,
+      emphasis: bool,
+      position: Position.t,
+      align: alignment,
+    })
+  | Divider({
+      position: Position.t,
+    })
+  | Row({
+      children: array<element>,
+      align: alignment,
+    })
+  | Section({
+      name: string,
+      children: array<element>,
+    })
+
+// Device type for responsive wireframes
+type deviceType =
+  | Desktop      // 1440x900 (16:10)
+  | Laptop       // 1280x800 (16:10)
+  | Tablet       // 768x1024 (3:4)
+  | TabletLandscape // 1024x768 (4:3)
+  | Mobile       // 375x812 (iPhone X ratio)
+  | MobileLandscape // 812x375
+  | Custom(int, int) // width, height
+
+// Device dimensions record
+type deviceDimensions = {
+  width: int,
+  height: int,
+  ratio: float,
+  name: string,
+}
+
+// Get dimensions for a device type
+let getDeviceDimensions = (device: deviceType): deviceDimensions => {
+  switch device {
+  | Desktop => {width: 1440, height: 900, ratio: 16.0 /. 10.0, name: "desktop"}
+  | Laptop => {width: 1280, height: 800, ratio: 16.0 /. 10.0, name: "laptop"}
+  | Tablet => {width: 768, height: 1024, ratio: 3.0 /. 4.0, name: "tablet"}
+  | TabletLandscape => {width: 1024, height: 768, ratio: 4.0 /. 3.0, name: "tablet-landscape"}
+  | Mobile => {width: 375, height: 812, ratio: 375.0 /. 812.0, name: "mobile"}
+  | MobileLandscape => {width: 812, height: 375, ratio: 812.0 /. 375.0, name: "mobile-landscape"}
+  | Custom(w, h) => {
+      width: w,
+      height: h,
+      ratio: Int.toFloat(w) /. Int.toFloat(h),
+      name: "custom-" ++ Int.toString(w) ++ "x" ++ Int.toString(h),
+    }
+  }
+}
+
+// Parse device type from string
+let parseDeviceType = (str: string): option<deviceType> => {
+  let normalized = str->String.trim->String.toLowerCase
+  switch normalized {
+  | "desktop" => Some(Desktop)
+  | "laptop" => Some(Laptop)
+  | "tablet" => Some(Tablet)
+  | "tablet-landscape" | "tabletlandscape" => Some(TabletLandscape)
+  | "mobile" | "phone" => Some(Mobile)
+  | "mobile-landscape" | "mobilelandscape" | "phone-landscape" => Some(MobileLandscape)
+  | _ => {
+      // Try to parse custom format: "WxH" or "W x H"
+      let customPattern = %re("/^(\d+)\s*x\s*(\d+)$/i")
+      switch Js.Re.exec_(customPattern, normalized) {
+      | Some(result) => {
+          let captures = Js.Re.captures(result)
+          switch (captures->Array.get(1), captures->Array.get(2)) {
+          | (Some(wNullable), Some(hNullable)) =>
+            switch (Js.Nullable.toOption(wNullable), Js.Nullable.toOption(hNullable)) {
+            | (Some(wStr), Some(hStr)) =>
+              switch (Int.fromString(wStr), Int.fromString(hStr)) {
+              | (Some(w), Some(h)) => Some(Custom(w, h))
+              | _ => None
+              }
+            | _ => None
+            }
+          | _ => None
+          }
+        }
+      | None => None
+      }
+    }
+  }
+}
+
+// Scene definition
+type scene = {
+  id: string,
+  title: string,
+  transition: string,
+  device: deviceType,
+  elements: array<element>,
+}
+
+// Complete AST
+type ast = {
+  scenes: array<scene>,
+}
+
+// Helper functions for elements
+let getElementType = (elem: element): string => {
+  switch elem {
+  | Box(_) => "Box"
+  | Button(_) => "Button"
+  | Input(_) => "Input"
+  | Link(_) => "Link"
+  | Checkbox(_) => "Checkbox"
+  | Text(_) => "Text"
+  | Divider(_) => "Divider"
+  | Row(_) => "Row"
+  | Section(_) => "Section"
+  }
+}
+
+let getElementId = (elem: element): option<string> => {
+  switch elem {
+  | Button({id}) => Some(id)
+  | Input({id}) => Some(id)
+  | Link({id}) => Some(id)
+  | Box({name}) => name
+  | Section({name}) => Some(name)
+  | _ => None
+  }
+}
+
+// ============================================================================
+// Interaction DSL Types
+// ============================================================================
+
+/**
+ * Interaction variant types for styling and behavior categorization.
+ */
+type interactionVariant =
+  | Primary // Primary action button
+  | Secondary // Secondary action button
+  | Ghost // Ghost/subtle button style
+
+/**
+ * Represents an interaction definition for a specific element.
+ * Interactions define behavior, properties, and actions for elements.
+ */
+type interaction = {
+  elementId: string, // ID of the element this interaction applies to
+  properties: Js.Dict.t<Js.Json.t>, // Additional properties (variant, disabled, etc.)
+  actions: array<interactionAction>, // Actions triggered by events
+}
+
+/**
+ * Groups all interactions for a specific scene.
+ */
+type sceneInteractions = {
+  sceneId: string, // Scene identifier
+  interactions: array<interaction>, // All interactions in this scene
+}

package/src/parser/Core/__tests__/Bounds_test.mjs

@@ -0,0 +1,326 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Bounds from "../Bounds.mjs";
+import * as Vitest from "rescript-vitest/src/Vitest.mjs";
+import * as Core__Option from "@rescript/core/src/Core__Option.mjs";
+
+Vitest.describe("Bounds.make", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, () => {
+  Vitest.test("creates valid bounds when top < bottom and left < right", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let result = Bounds.make(0, 0, 10, 10);
+    if (result !== undefined) {
+      t.expect(result.top).toBe(0);
+      t.expect(result.left).toBe(0);
+      t.expect(result.bottom).toBe(10);
+      return t.expect(result.right).toBe(10);
+    } else {
+      return t.expect(true).toBe(false);
+    }
+  });
+  Vitest.test("returns None when top >= bottom", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let result = Bounds.make(10, 0, 10, 10);
+    t.expect(result).toBe(undefined);
+  });
+  Vitest.test("returns None when top > bottom", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let result = Bounds.make(15, 0, 10, 10);
+    t.expect(result).toBe(undefined);
+  });
+  Vitest.test("returns None when left >= right", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let result = Bounds.make(0, 10, 10, 10);
+    t.expect(result).toBe(undefined);
+  });
+  Vitest.test("returns None when left > right", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let result = Bounds.make(0, 15, 10, 10);
+    t.expect(result).toBe(undefined);
+  });
+  Vitest.test("handles negative coordinates", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let result = Bounds.make(-10, -10, 0, 0);
+    if (result !== undefined) {
+      t.expect(result.top).toBe(-10);
+      t.expect(result.left).toBe(-10);
+      t.expect(result.bottom).toBe(0);
+      return t.expect(result.right).toBe(0);
+    } else {
+      return t.expect(true).toBe(false);
+    }
+  });
+  Vitest.test("creates minimal 1x1 bounds", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let result = Bounds.make(0, 0, 1, 1);
+    if (result !== undefined) {
+      t.expect(Bounds.width(result)).toBe(1);
+      return t.expect(Bounds.height(result)).toBe(1);
+    } else {
+      return t.expect(true).toBe(false);
+    }
+  });
+});
+
+Vitest.describe("Bounds.width", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, () => {
+  Vitest.test("calculates width correctly", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let bounds = Core__Option.getExn(Bounds.make(0, 0, 10, 20), undefined);
+    t.expect(Bounds.width(bounds)).toBe(20);
+  });
+  Vitest.test("calculates width for single column", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let bounds = Core__Option.getExn(Bounds.make(0, 5, 10, 6), undefined);
+    t.expect(Bounds.width(bounds)).toBe(1);
+  });
+  Vitest.test("handles negative coordinates", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let bounds = Core__Option.getExn(Bounds.make(0, -5, 10, 5), undefined);
+    t.expect(Bounds.width(bounds)).toBe(10);
+  });
+  Vitest.test("calculates width for large bounds", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let bounds = Core__Option.getExn(Bounds.make(0, 0, 10, 1000), undefined);
+    t.expect(Bounds.width(bounds)).toBe(1000);
+  });
+});
+
+Vitest.describe("Bounds.height", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, () => {
+  Vitest.test("calculates height correctly", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let bounds = Core__Option.getExn(Bounds.make(0, 0, 15, 10), undefined);
+    t.expect(Bounds.height(bounds)).toBe(15);
+  });
+  Vitest.test("calculates height for single row", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let bounds = Core__Option.getExn(Bounds.make(5, 0, 6, 10), undefined);
+    t.expect(Bounds.height(bounds)).toBe(1);
+  });
+  Vitest.test("handles negative coordinates", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let bounds = Core__Option.getExn(Bounds.make(-5, 0, 5, 10), undefined);
+    t.expect(Bounds.height(bounds)).toBe(10);
+  });
+  Vitest.test("calculates height for tall bounds", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let bounds = Core__Option.getExn(Bounds.make(0, 0, 1000, 10), undefined);
+    t.expect(Bounds.height(bounds)).toBe(1000);
+  });
+});
+
+Vitest.describe("Bounds.area", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, () => {
+  Vitest.test("calculates area correctly", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let bounds = Core__Option.getExn(Bounds.make(0, 0, 10, 20), undefined);
+    t.expect(Bounds.area(bounds)).toBe(200);
+  });
+  Vitest.test("calculates area for 1x1 box", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let bounds = Core__Option.getExn(Bounds.make(0, 0, 1, 1), undefined);
+    t.expect(Bounds.area(bounds)).toBe(1);
+  });
+  Vitest.test("calculates area for narrow box", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let bounds = Core__Option.getExn(Bounds.make(0, 0, 100, 1), undefined);
+    t.expect(Bounds.area(bounds)).toBe(100);
+  });
+  Vitest.test("calculates area for wide box", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let bounds = Core__Option.getExn(Bounds.make(0, 0, 1, 100), undefined);
+    t.expect(Bounds.area(bounds)).toBe(100);
+  });
+  Vitest.test("calculates area with negative coordinates", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let bounds = Core__Option.getExn(Bounds.make(-10, -20, 10, 20), undefined);
+    t.expect(Bounds.area(bounds)).toBe(800);
+  });
+  Vitest.test("calculates area for very large bounds", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let bounds = Core__Option.getExn(Bounds.make(0, 0, 1000, 1000), undefined);
+    t.expect(Bounds.area(bounds)).toBe(1000000);
+  });
+});
+
+Vitest.describe("Bounds.contains", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, () => {
+  Vitest.test("returns true when outer completely contains inner", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let outer = Core__Option.getExn(Bounds.make(0, 0, 20, 20), undefined);
+    let inner = Core__Option.getExn(Bounds.make(5, 5, 15, 15), undefined);
+    t.expect(Bounds.contains(outer, inner)).toBe(true);
+  });
+  Vitest.test("returns false when boxes are equal", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let a = Core__Option.getExn(Bounds.make(0, 0, 10, 10), undefined);
+    let b = Core__Option.getExn(Bounds.make(0, 0, 10, 10), undefined);
+    t.expect(Bounds.contains(a, b)).toBe(false);
+  });
+  Vitest.test("returns false when inner top edge touches outer top edge", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let outer = Core__Option.getExn(Bounds.make(0, 0, 20, 20), undefined);
+    let inner = Core__Option.getExn(Bounds.make(0, 5, 15, 15), undefined);
+    t.expect(Bounds.contains(outer, inner)).toBe(false);
+  });
+  Vitest.test("returns false when inner left edge touches outer left edge", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let outer = Core__Option.getExn(Bounds.make(0, 0, 20, 20), undefined);
+    let inner = Core__Option.getExn(Bounds.make(5, 0, 15, 15), undefined);
+    t.expect(Bounds.contains(outer, inner)).toBe(false);
+  });
+  Vitest.test("returns false when inner bottom edge touches outer bottom edge", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let outer = Core__Option.getExn(Bounds.make(0, 0, 20, 20), undefined);
+    let inner = Core__Option.getExn(Bounds.make(5, 5, 20, 15), undefined);
+    t.expect(Bounds.contains(outer, inner)).toBe(false);
+  });
+  Vitest.test("returns false when inner right edge touches outer right edge", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let outer = Core__Option.getExn(Bounds.make(0, 0, 20, 20), undefined);
+    let inner = Core__Option.getExn(Bounds.make(5, 5, 15, 20), undefined);
+    t.expect(Bounds.contains(outer, inner)).toBe(false);
+  });
+  Vitest.test("returns false when boxes are disjoint", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let a = Core__Option.getExn(Bounds.make(0, 0, 10, 10), undefined);
+    let b = Core__Option.getExn(Bounds.make(20, 20, 30, 30), undefined);
+    t.expect(Bounds.contains(a, b)).toBe(false);
+  });
+  Vitest.test("returns false when inner is larger than outer", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let outer = Core__Option.getExn(Bounds.make(5, 5, 15, 15), undefined);
+    let inner = Core__Option.getExn(Bounds.make(0, 0, 20, 20), undefined);
+    t.expect(Bounds.contains(outer, inner)).toBe(false);
+  });
+  Vitest.test("returns false when boxes partially overlap", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let a = Core__Option.getExn(Bounds.make(0, 0, 15, 15), undefined);
+    let b = Core__Option.getExn(Bounds.make(10, 10, 20, 20), undefined);
+    t.expect(Bounds.contains(a, b)).toBe(false);
+  });
+  Vitest.test("handles negative coordinates correctly", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let outer = Core__Option.getExn(Bounds.make(-20, -20, 20, 20), undefined);
+    let inner = Core__Option.getExn(Bounds.make(-5, -5, 5, 5), undefined);
+    t.expect(Bounds.contains(outer, inner)).toBe(true);
+  });
+  Vitest.test("returns true when inner is minimal 1-pixel margin inside outer", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let outer = Core__Option.getExn(Bounds.make(0, 0, 10, 10), undefined);
+    let inner = Core__Option.getExn(Bounds.make(1, 1, 9, 9), undefined);
+    t.expect(Bounds.contains(outer, inner)).toBe(true);
+  });
+});
+
+Vitest.describe("Bounds.overlaps", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, () => {
+  Vitest.test("returns true when boxes partially overlap", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let a = Core__Option.getExn(Bounds.make(0, 0, 15, 15), undefined);
+    let b = Core__Option.getExn(Bounds.make(10, 10, 20, 20), undefined);
+    t.expect(Bounds.overlaps(a, b)).toBe(true);
+  });
+  Vitest.test("returns true when one box completely contains another", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let outer = Core__Option.getExn(Bounds.make(0, 0, 20, 20), undefined);
+    let inner = Core__Option.getExn(Bounds.make(5, 5, 15, 15), undefined);
+    t.expect(Bounds.overlaps(outer, inner)).toBe(true);
+    t.expect(Bounds.overlaps(inner, outer)).toBe(true);
+  });
+  Vitest.test("returns true when boxes are equal", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let a = Core__Option.getExn(Bounds.make(0, 0, 10, 10), undefined);
+    let b = Core__Option.getExn(Bounds.make(0, 0, 10, 10), undefined);
+    t.expect(Bounds.overlaps(a, b)).toBe(true);
+  });
+  Vitest.test("returns false when boxes are disjoint horizontally", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let a = Core__Option.getExn(Bounds.make(0, 0, 10, 10), undefined);
+    let b = Core__Option.getExn(Bounds.make(0, 20, 10, 30), undefined);
+    t.expect(Bounds.overlaps(a, b)).toBe(false);
+  });
+  Vitest.test("returns false when boxes are disjoint vertically", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let a = Core__Option.getExn(Bounds.make(0, 0, 10, 10), undefined);
+    let b = Core__Option.getExn(Bounds.make(20, 0, 30, 10), undefined);
+    t.expect(Bounds.overlaps(a, b)).toBe(false);
+  });
+  Vitest.test("returns false when boxes touch at edges horizontally", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let a = Core__Option.getExn(Bounds.make(0, 0, 10, 10), undefined);
+    let b = Core__Option.getExn(Bounds.make(0, 10, 10, 20), undefined);
+    t.expect(Bounds.overlaps(a, b)).toBe(false);
+  });
+  Vitest.test("returns false when boxes touch at edges vertically", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let a = Core__Option.getExn(Bounds.make(0, 0, 10, 10), undefined);
+    let b = Core__Option.getExn(Bounds.make(10, 0, 20, 10), undefined);
+    t.expect(Bounds.overlaps(a, b)).toBe(false);
+  });
+  Vitest.test("returns false when boxes are completely separated", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let a = Core__Option.getExn(Bounds.make(0, 0, 5, 5), undefined);
+    let b = Core__Option.getExn(Bounds.make(10, 10, 15, 15), undefined);
+    t.expect(Bounds.overlaps(a, b)).toBe(false);
+  });
+  Vitest.test("returns true when boxes overlap at corner", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let a = Core__Option.getExn(Bounds.make(0, 0, 11, 11), undefined);
+    let b = Core__Option.getExn(Bounds.make(10, 10, 20, 20), undefined);
+    t.expect(Bounds.overlaps(a, b)).toBe(true);
+  });
+  Vitest.test("returns true for L-shaped overlap", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let a = Core__Option.getExn(Bounds.make(0, 0, 15, 10), undefined);
+    let b = Core__Option.getExn(Bounds.make(5, 5, 10, 20), undefined);
+    t.expect(Bounds.overlaps(a, b)).toBe(true);
+  });
+  Vitest.test("returns true for T-shaped overlap", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let a = Core__Option.getExn(Bounds.make(0, 5, 10, 15), undefined);
+    let b = Core__Option.getExn(Bounds.make(5, 0, 15, 20), undefined);
+    t.expect(Bounds.overlaps(a, b)).toBe(true);
+  });
+  Vitest.test("handles negative coordinates correctly", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let a = Core__Option.getExn(Bounds.make(-10, -10, 0, 0), undefined);
+    let b = Core__Option.getExn(Bounds.make(-5, -5, 5, 5), undefined);
+    t.expect(Bounds.overlaps(a, b)).toBe(true);
+  });
+  Vitest.test("returns false for disjoint bounds with negative coordinates", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let a = Core__Option.getExn(Bounds.make(-20, -20, -10, -10), undefined);
+    let b = Core__Option.getExn(Bounds.make(10, 10, 20, 20), undefined);
+    t.expect(Bounds.overlaps(a, b)).toBe(false);
+  });
+  Vitest.test("is symmetric (order doesn't matter)", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let a = Core__Option.getExn(Bounds.make(0, 0, 10, 10), undefined);
+    let b = Core__Option.getExn(Bounds.make(5, 5, 15, 15), undefined);
+    t.expect(Bounds.overlaps(a, b)).toBe(Bounds.overlaps(b, a));
+  });
+});
+
+Vitest.describe("Bounds.toString", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, () => {
+  Vitest.test("formats bounds as string correctly", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let bounds = Core__Option.getExn(Bounds.make(1, 2, 10, 20), undefined);
+    let str = Bounds.toString(bounds);
+    t.expect(str).toBe("Bounds{top: 1, left: 2, bottom: 10, right: 20}");
+  });
+  Vitest.test("handles negative coordinates in string", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let bounds = Core__Option.getExn(Bounds.make(-5, -10, 5, 10), undefined);
+    let str = Bounds.toString(bounds);
+    t.expect(str).toBe("Bounds{top: -5, left: -10, bottom: 5, right: 10}");
+  });
+});
+
+Vitest.describe("Bounds.equals", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, () => {
+  Vitest.test("returns true for equal bounds", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let a = Core__Option.getExn(Bounds.make(0, 0, 10, 10), undefined);
+    let b = Core__Option.getExn(Bounds.make(0, 0, 10, 10), undefined);
+    t.expect(Bounds.equals(a, b)).toBe(true);
+  });
+  Vitest.test("returns false for different bounds", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let a = Core__Option.getExn(Bounds.make(0, 0, 10, 10), undefined);
+    let b = Core__Option.getExn(Bounds.make(0, 0, 10, 11), undefined);
+    t.expect(Bounds.equals(a, b)).toBe(false);
+  });
+  Vitest.test("returns false when only one field differs", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let base = Core__Option.getExn(Bounds.make(0, 0, 10, 10), undefined);
+    let diffTop = Core__Option.getExn(Bounds.make(1, 0, 10, 10), undefined);
+    t.expect(Bounds.equals(base, diffTop)).toBe(false);
+    let diffLeft = Core__Option.getExn(Bounds.make(0, 1, 10, 10), undefined);
+    t.expect(Bounds.equals(base, diffLeft)).toBe(false);
+    let diffBottom = Core__Option.getExn(Bounds.make(0, 0, 11, 10), undefined);
+    t.expect(Bounds.equals(base, diffBottom)).toBe(false);
+    let diffRight = Core__Option.getExn(Bounds.make(0, 0, 10, 11), undefined);
+    t.expect(Bounds.equals(base, diffRight)).toBe(false);
+  });
+});
+
+Vitest.describe("Bounds edge cases", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, () => {
+  Vitest.test("handles zero-width bounds validation", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let result = Bounds.make(0, 5, 10, 5);
+    t.expect(result).toBe(undefined);
+  });
+  Vitest.test("handles zero-height bounds validation", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let result = Bounds.make(5, 0, 5, 10);
+    t.expect(result).toBe(undefined);
+  });
+  Vitest.test("handles inverted bounds", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let result = Bounds.make(10, 0, 5, 10);
+    t.expect(result).toBe(undefined);
+  });
+  Vitest.test("handles very large coordinate values", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let bounds = Core__Option.getExn(Bounds.make(0, 0, 1000000, 1000000), undefined);
+    t.expect(Bounds.area(bounds)).toBe(-727379968);
+  });
+  Vitest.test("handles single pixel bounds", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let bounds = Core__Option.getExn(Bounds.make(0, 0, 1, 1), undefined);
+    t.expect(Bounds.width(bounds)).toBe(1);
+    t.expect(Bounds.height(bounds)).toBe(1);
+    t.expect(Bounds.area(bounds)).toBe(1);
+  });
+  Vitest.test("handles thin horizontal line", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let bounds = Core__Option.getExn(Bounds.make(0, 0, 1, 100), undefined);
+    t.expect(Bounds.height(bounds)).toBe(1);
+    t.expect(Bounds.area(bounds)).toBe(100);
+  });
+  Vitest.test("handles thin vertical line", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let bounds = Core__Option.getExn(Bounds.make(0, 0, 100, 1), undefined);
+    t.expect(Bounds.width(bounds)).toBe(1);
+    t.expect(Bounds.area(bounds)).toBe(100);
+  });
+});
+
+/*  Not a pure module */