wyreframe 0.1.0

package/src/parser/Core/Bounds.mjs

@@ -0,0 +1,61 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function make(top, left, bottom, right) {
+  if (top < bottom && left < right) {
+    return {
+      top: top,
+      left: left,
+      bottom: bottom,
+      right: right
+    };
+  }
+}
+
+function width(bounds) {
+  return bounds.right - bounds.left | 0;
+}
+
+function height(bounds) {
+  return bounds.bottom - bounds.top | 0;
+}
+
+function area(bounds) {
+  return width(bounds) * height(bounds) | 0;
+}
+
+function contains(outer, inner) {
+  if (outer.top < inner.top && outer.left < inner.left && outer.bottom > inner.bottom) {
+    return outer.right > inner.right;
+  } else {
+    return false;
+  }
+}
+
+function overlaps(a, b) {
+  return !(a.right <= b.left || a.left >= b.right || a.bottom <= b.top || a.top >= b.bottom);
+}
+
+function toString(bounds) {
+  return `Bounds{top: ` + bounds.top.toString() + `, left: ` + bounds.left.toString() + `, bottom: ` + bounds.bottom.toString() + `, right: ` + bounds.right.toString() + `}`;
+}
+
+function equals(a, b) {
+  if (a.top === b.top && a.left === b.left && a.bottom === b.bottom) {
+    return a.right === b.right;
+  } else {
+    return false;
+  }
+}
+
+export {
+  make,
+  width,
+  height,
+  area,
+  contains,
+  overlaps,
+  toString,
+  equals,
+}
+/* No side effect */

package/src/parser/Core/Bounds.res

@@ -0,0 +1,65 @@
+// Bounds.res
+// Bounding box representation for rectangular regions
+
+type t = {
+  top: int,
+  left: int,
+  bottom: int,
+  right: int,
+}
+
+// Create a bounding box with validation
+// Validates that top < bottom and left < right
+let make = (~top: int, ~left: int, ~bottom: int, ~right: int): option<t> => {
+  if top < bottom && left < right {
+    Some({top, left, bottom, right})
+  } else {
+    None
+  }
+}
+
+// Calculate width of the bounding box
+let width = (bounds: t): int => {
+  bounds.right - bounds.left
+}
+
+// Calculate height of the bounding box
+let height = (bounds: t): int => {
+  bounds.bottom - bounds.top
+}
+
+// Calculate area of the bounding box
+let area = (bounds: t): int => {
+  width(bounds) * height(bounds)
+}
+
+// Check if outer completely contains inner
+// Returns true if outer's bounds completely enclose inner's bounds
+let contains = (outer: t, inner: t): bool => {
+  outer.top < inner.top &&
+  outer.left < inner.left &&
+  outer.bottom > inner.bottom &&
+  outer.right > inner.right
+}
+
+// Check if two bounding boxes overlap (partially or completely)
+// Returns true if there is any intersection between the two boxes
+let overlaps = (a: t, b: t): bool => {
+  // No overlap if:
+  // - a is completely to the left of b (a.right <= b.left)
+  // - a is completely to the right of b (a.left >= b.right)
+  // - a is completely above b (a.bottom <= b.top)
+  // - a is completely below b (a.top >= b.bottom)
+  // Overlap exists if none of the above conditions are true
+  !(a.right <= b.left || a.left >= b.right || a.bottom <= b.top || a.top >= b.bottom)
+}
+
+// Convert bounds to string for debugging
+let toString = (bounds: t): string => {
+  `Bounds{top: ${Int.toString(bounds.top)}, left: ${Int.toString(bounds.left)}, bottom: ${Int.toString(bounds.bottom)}, right: ${Int.toString(bounds.right)}}`
+}
+
+// Check if two bounds are equal
+let equals = (a: t, b: t): bool => {
+  a.top == b.top && a.left == b.left && a.bottom == b.bottom && a.right == b.right
+}

package/src/parser/Core/Grid.mjs

@@ -0,0 +1,268 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Types from "./Types.mjs";
+import * as Core__Array from "@rescript/core/src/Core__Array.mjs";
+import * as Core__Option from "@rescript/core/src/Core__Option.mjs";
+
+function charToCellChar(char) {
+  switch (char) {
+    case " " :
+      return "Space";
+    case "+" :
+      return "Corner";
+    case "-" :
+      return "HLine";
+    case "=" :
+      return "Divider";
+    case "|" :
+      return "VLine";
+    default:
+      return {
+        TAG: "Char",
+        _0: char
+      };
+  }
+}
+
+function cellCharToString(cell) {
+  if (typeof cell === "object") {
+    return cell._0;
+  }
+  switch (cell) {
+    case "Corner" :
+      return "+";
+    case "HLine" :
+      return "-";
+    case "VLine" :
+      return "|";
+    case "Divider" :
+      return "=";
+    case "Space" :
+      return " ";
+  }
+}
+
+function fromLines(lines) {
+  let maxWidth = Core__Array.reduce(lines, 0, (acc, line) => {
+    let len = line.length;
+    if (acc > len) {
+      return acc;
+    } else {
+      return len;
+    }
+  });
+  let cells = lines.map(line => {
+    let chars = line.split("");
+    let cellRow = chars.map(charToCellChar);
+    let paddingNeeded = maxWidth - cellRow.length | 0;
+    if (paddingNeeded <= 0) {
+      return cellRow;
+    }
+    let padding = Core__Array.make(paddingNeeded, "Space");
+    return cellRow.concat(padding);
+  });
+  let cornerIndex = [];
+  let hLineIndex = [];
+  let vLineIndex = [];
+  let dividerIndex = [];
+  cells.forEach((row, rowIdx) => {
+    row.forEach((cell, colIdx) => {
+      let pos = Types.Position.make(rowIdx, colIdx);
+      if (typeof cell === "object") {
+        return;
+      }
+      switch (cell) {
+        case "Corner" :
+          cornerIndex.push(pos);
+          return;
+        case "HLine" :
+          hLineIndex.push(pos);
+          return;
+        case "VLine" :
+          vLineIndex.push(pos);
+          return;
+        case "Divider" :
+          dividerIndex.push(pos);
+          return;
+        case "Space" :
+          return;
+      }
+    });
+  });
+  return {
+    cells: cells,
+    width: maxWidth,
+    height: cells.length,
+    cornerIndex: cornerIndex,
+    hLineIndex: hLineIndex,
+    vLineIndex: vLineIndex,
+    dividerIndex: dividerIndex
+  };
+}
+
+function get(grid, pos) {
+  if (pos.row >= 0 && pos.row < grid.height && pos.col >= 0 && pos.col < grid.width) {
+    return Core__Option.flatMap(grid.cells[pos.row], row => row[pos.col]);
+  }
+}
+
+function getLine(grid, row) {
+  if (row >= 0 && row < grid.height) {
+    return grid.cells[row];
+  }
+}
+
+function getRange(grid, row, startCol, endCol) {
+  return Core__Option.map(getLine(grid, row), line => {
+    let start = startCol < 0 ? 0 : startCol;
+    let end = endCol >= line.length ? line.length - 1 | 0 : endCol;
+    return line.slice(start, end + 1 | 0);
+  });
+}
+
+function scanRight(grid, pos, predicate) {
+  let results = [];
+  let currentPos = pos;
+  let $$continue = true;
+  while (currentPos.col < grid.width && $$continue) {
+    let cell = get(grid, currentPos);
+    if (cell !== undefined && predicate(cell)) {
+      results.push([
+        currentPos,
+        cell
+      ]);
+      currentPos = Types.Position.right(currentPos, undefined);
+    } else {
+      $$continue = false;
+    }
+  };
+  return results;
+}
+
+function scanDown(grid, pos, predicate) {
+  let results = [];
+  let currentPos = pos;
+  let $$continue = true;
+  while (currentPos.row < grid.height && $$continue) {
+    let cell = get(grid, currentPos);
+    if (cell !== undefined && predicate(cell)) {
+      results.push([
+        currentPos,
+        cell
+      ]);
+      currentPos = Types.Position.down(currentPos, undefined);
+    } else {
+      $$continue = false;
+    }
+  };
+  return results;
+}
+
+function scanLeft(grid, pos, predicate) {
+  let results = [];
+  let currentPos = pos;
+  let $$continue = true;
+  while (currentPos.col >= 0 && $$continue) {
+    let cell = get(grid, currentPos);
+    if (cell !== undefined && predicate(cell)) {
+      results.push([
+        currentPos,
+        cell
+      ]);
+      currentPos = Types.Position.left(currentPos, undefined);
+    } else {
+      $$continue = false;
+    }
+  };
+  return results;
+}
+
+function scanUp(grid, pos, predicate) {
+  let results = [];
+  let currentPos = pos;
+  let $$continue = true;
+  while (currentPos.row >= 0 && $$continue) {
+    let cell = get(grid, currentPos);
+    if (cell !== undefined && predicate(cell)) {
+      results.push([
+        currentPos,
+        cell
+      ]);
+      currentPos = Types.Position.up(currentPos, undefined);
+    } else {
+      $$continue = false;
+    }
+  };
+  return results;
+}
+
+function findAll(grid, cellType) {
+  if (typeof cellType !== "object") {
+    switch (cellType) {
+      case "Corner" :
+        return grid.cornerIndex;
+      case "HLine" :
+        return grid.hLineIndex;
+      case "VLine" :
+        return grid.vLineIndex;
+      case "Divider" :
+        return grid.dividerIndex;
+      case "Space" :
+        break;
+    }
+  }
+  let positions = [];
+  grid.cells.forEach((row, rowIdx) => {
+    row.forEach((cell, colIdx) => {
+      if (typeof cellType === "object") {
+        if (typeof cell !== "object" || cellType._0 !== cell._0) {
+          return;
+        } else {
+          positions.push(Types.Position.make(rowIdx, colIdx));
+          return;
+        }
+      }
+      if (cellType !== "Space") {
+        return;
+      }
+      if (typeof cell === "object") {
+        return;
+      }
+      if (cell !== "Space") {
+        return;
+      }
+      positions.push(Types.Position.make(rowIdx, colIdx));
+    });
+  });
+  return positions;
+}
+
+function findInRange(grid, cellType, bounds) {
+  let allPositions = findAll(grid, cellType);
+  return allPositions.filter(pos => Types.Position.isWithin(pos, bounds));
+}
+
+function isValidPosition(grid, pos) {
+  if (pos.row >= 0 && pos.row < grid.height && pos.col >= 0) {
+    return pos.col < grid.width;
+  } else {
+    return false;
+  }
+}
+
+export {
+  charToCellChar,
+  cellCharToString,
+  fromLines,
+  get,
+  getLine,
+  getRange,
+  scanRight,
+  scanDown,
+  scanLeft,
+  scanUp,
+  findAll,
+  findInRange,
+  isValidPosition,
+}
+/* Types Not a pure module */

package/src/parser/Core/Grid.res

@@ -0,0 +1,265 @@
+// Grid.res
+// 2D character grid data structure with efficient position-based operations
+// Provides the foundation for spatial parsing of ASCII wireframes
+
+open Types
+
+type t = {
+  cells: array<array<cellChar>>,
+  width: int,
+  height: int,
+  cornerIndex: array<Position.t>,
+  hLineIndex: array<Position.t>,
+  vLineIndex: array<Position.t>,
+  dividerIndex: array<Position.t>,
+}
+
+// Helper function to convert a string character to cellChar
+let charToCellChar = (char: string): cellChar => {
+  switch char {
+  | "+" => Corner
+  | "-" => HLine
+  | "|" => VLine
+  | "=" => Divider
+  | " " => Space
+  | c => Char(c)
+  }
+}
+
+// Helper function to convert cellChar back to string
+let cellCharToString = (cell: cellChar): string => {
+  switch cell {
+  | Corner => "+"
+  | HLine => "-"
+  | VLine => "|"
+  | Divider => "="
+  | Space => " "
+  | Char(c) => c
+  }
+}
+
+// Create grid from lines with normalization
+// Normalizes line lengths by padding shorter lines with spaces
+let fromLines = (lines: array<string>): t => {
+  // Find maximum line width
+  let maxWidth = Array.reduce(lines, 0, (acc, line) => {
+    let len = String.length(line)
+    acc > len ? acc : len
+  })
+
+  // Build 2D cell array with normalization
+  let cells = Array.map(lines, line => {
+    let chars = String.split(line, "")
+    let cellRow = Array.map(chars, charToCellChar)
+
+    // Pad to max width with spaces
+    let paddingNeeded = maxWidth - Array.length(cellRow)
+    if paddingNeeded > 0 {
+      let padding = Array.make(~length=paddingNeeded, Space)
+      Array.concat(cellRow, padding)
+    } else {
+      cellRow
+    }
+  })
+
+  // Build special character indices for O(1) lookup
+  let cornerIndex = []
+  let hLineIndex = []
+  let vLineIndex = []
+  let dividerIndex = []
+
+  Array.forEachWithIndex(cells, (row, rowIdx) => {
+    Array.forEachWithIndex(row, (cell, colIdx) => {
+      let pos = Position.make(rowIdx, colIdx)
+      switch cell {
+      | Corner => {
+          let _ = Array.push(cornerIndex, pos)
+        }
+      | HLine => {
+          let _ = Array.push(hLineIndex, pos)
+        }
+      | VLine => {
+          let _ = Array.push(vLineIndex, pos)
+        }
+      | Divider => {
+          let _ = Array.push(dividerIndex, pos)
+        }
+      | _ => ()
+      }
+    })
+  })
+
+  {
+    cells,
+    width: maxWidth,
+    height: Array.length(cells),
+    cornerIndex,
+    hLineIndex,
+    vLineIndex,
+    dividerIndex,
+  }
+}
+
+// Get character at position, returns None if out of bounds
+let get = (grid: t, pos: Position.t): option<cellChar> => {
+  if pos.row >= 0 && pos.row < grid.height && pos.col >= 0 && pos.col < grid.width {
+    Array.get(grid.cells, pos.row)->Option.flatMap(row => Array.get(row, pos.col))
+  } else {
+    None
+  }
+}
+
+// Get entire line at row index
+let getLine = (grid: t, row: int): option<array<cellChar>> => {
+  if row >= 0 && row < grid.height {
+    Array.get(grid.cells, row)
+  } else {
+    None
+  }
+}
+
+// Get range of characters from a line (inclusive)
+let getRange = (grid: t, row: int, ~startCol: int, ~endCol: int): option<array<cellChar>> => {
+  getLine(grid, row)->Option.map(line => {
+    let start = startCol < 0 ? 0 : startCol
+    let end = endCol >= Array.length(line) ? Array.length(line) - 1 : endCol
+    Array.slice(line, ~start, ~end=end + 1)
+  })
+}
+
+// Scan right from position while predicate is true
+// Returns array of (position, cellChar) tuples
+let scanRight = (grid: t, pos: Position.t, predicate: cellChar => bool): array<(
+  Position.t,
+  cellChar,
+)> => {
+  let results = []
+  let currentPos = ref(pos)
+  let continue = ref(true)
+
+  while currentPos.contents.col < grid.width && continue.contents {
+    switch get(grid, currentPos.contents) {
+    | Some(cell) =>
+      if predicate(cell) {
+        let _ = Array.push(results, (currentPos.contents, cell))
+        currentPos := Position.right(currentPos.contents)
+      } else {
+        continue := false
+      }
+    | None => continue := false
+    }
+  }
+
+  results
+}
+
+// Scan down from position while predicate is true
+let scanDown = (grid: t, pos: Position.t, predicate: cellChar => bool): array<(
+  Position.t,
+  cellChar,
+)> => {
+  let results = []
+  let currentPos = ref(pos)
+  let continue = ref(true)
+
+  while currentPos.contents.row < grid.height && continue.contents {
+    switch get(grid, currentPos.contents) {
+    | Some(cell) =>
+      if predicate(cell) {
+        let _ = Array.push(results, (currentPos.contents, cell))
+        currentPos := Position.down(currentPos.contents)
+      } else {
+        continue := false
+      }
+    | None => continue := false
+    }
+  }
+
+  results
+}
+
+// Scan left from position while predicate is true
+let scanLeft = (grid: t, pos: Position.t, predicate: cellChar => bool): array<(
+  Position.t,
+  cellChar,
+)> => {
+  let results = []
+  let currentPos = ref(pos)
+  let continue = ref(true)
+
+  while currentPos.contents.col >= 0 && continue.contents {
+    switch get(grid, currentPos.contents) {
+    | Some(cell) =>
+      if predicate(cell) {
+        let _ = Array.push(results, (currentPos.contents, cell))
+        currentPos := Position.left(currentPos.contents)
+      } else {
+        continue := false
+      }
+    | None => continue := false
+    }
+  }
+
+  results
+}
+
+// Scan up from position while predicate is true
+let scanUp = (grid: t, pos: Position.t, predicate: cellChar => bool): array<(Position.t, cellChar)> => {
+  let results = []
+  let currentPos = ref(pos)
+  let continue = ref(true)
+
+  while currentPos.contents.row >= 0 && continue.contents {
+    switch get(grid, currentPos.contents) {
+    | Some(cell) =>
+      if predicate(cell) {
+        let _ = Array.push(results, (currentPos.contents, cell))
+        currentPos := Position.up(currentPos.contents)
+      } else {
+        continue := false
+      }
+    | None => continue := false
+    }
+  }
+
+  results
+}
+
+// Find all positions of a specific cellChar type using prebuilt index
+let findAll = (grid: t, cellType: cellChar): array<Position.t> => {
+  switch cellType {
+  | Corner => grid.cornerIndex
+  | HLine => grid.hLineIndex
+  | VLine => grid.vLineIndex
+  | Divider => grid.dividerIndex
+  | Space | Char(_) => {
+      // For Space and Char types, we need to scan the entire grid
+      let positions = []
+      Array.forEachWithIndex(grid.cells, (row, rowIdx) => {
+        Array.forEachWithIndex(row, (cell, colIdx) => {
+          switch (cellType, cell) {
+          | (Space, Space) => {
+              let _ = Array.push(positions, Position.make(rowIdx, colIdx))
+            }
+          | (Char(expected), Char(actual)) if expected === actual => {
+              let _ = Array.push(positions, Position.make(rowIdx, colIdx))
+            }
+          | _ => ()
+          }
+        })
+      })
+      positions
+    }
+  }
+}
+
+// Find all positions of a cellChar within bounds
+let findInRange = (grid: t, cellType: cellChar, bounds: Bounds.t): array<Position.t> => {
+  let allPositions = findAll(grid, cellType)
+  Array.filter(allPositions, pos => Position.isWithin(pos, bounds))
+}
+
+// Check if position is valid (within grid bounds)
+let isValidPosition = (grid: t, pos: Position.t): bool => {
+  pos.row >= 0 && pos.row < grid.height && pos.col >= 0 && pos.col < grid.width
+}