wyreframe 0.1.0

package/src/parser/Scanner/__tests__/Grid_manual.res

@@ -0,0 +1,141 @@
+// Grid_manual_test.res
+// Manual test file for Grid data structure (without Jest)
+// Run with: node src/parser/Scanner/__tests__/Grid_manual_test.mjs
+
+open Types
+
+// Test helper
+let check = (condition: bool, message: string): unit => {
+  if condition {
+    Console.log("✓ PASS: " ++ message)
+  } else {
+    Console.error("✗ FAIL: " ++ message)
+  }
+}
+
+let assertEqual = (actual: 'a, expected: 'a, message: string): unit => {
+  if actual == expected {
+    Console.log("✓ PASS: " ++ message)
+  } else {
+    Console.error("✗ FAIL: " ++ message)
+  }
+}
+
+Console.log("\n=== Grid Construction Tests ===\n")
+
+// Test 1: Basic grid construction
+let lines1 = ["abc", "def", "ghi"]
+let grid1 = Grid.fromLines(lines1)
+assertEqual(grid1.width, 3, "Grid width for uniform lines")
+assertEqual(grid1.height, 3, "Grid height for uniform lines")
+
+// Test 2: Normalization of varying length lines
+let lines2 = ["abc", "de", "f"]
+let grid2 = Grid.fromLines(lines2)
+assertEqual(grid2.width, 3, "Grid width after normalization")
+assertEqual(grid2.height, 3, "Grid height after normalization")
+
+// Test 3: Character indices
+let lines3 = ["+--+", "|  |", "+--+"]
+let grid3 = Grid.fromLines(lines3)
+assertEqual(Array.length(grid3.cornerIndex), 4, "Corner index count")
+assertEqual(Array.length(grid3.hLineIndex), 4, "HLine index count")
+// VLines are only at positions (1,0) and (1,3) in the grid
+assertEqual(Array.length(grid3.vLineIndex), 2, "VLine index count")
+
+Console.log("\n=== Character Access Tests ===\n")
+
+// Test 4: Get character at position
+switch Grid.get(grid3, Position.make(0, 0)) {
+| Some(Corner) => Console.log("✓ PASS: Get character at (0,0) returns Corner")
+| _ => Console.error("✗ FAIL: Get character at (0,0) should return Corner")
+}
+
+// Test 5: Get out of bounds
+switch Grid.get(grid3, Position.make(10, 10)) {
+| None => Console.log("✓ PASS: Get character out of bounds returns None")
+| _ => Console.error("✗ FAIL: Get character out of bounds should return None")
+}
+
+// Test 6: Get line
+switch Grid.getLine(grid3, 0) {
+| Some(line) => assertEqual(Array.length(line), 4, "Get line returns correct length")
+| None => Console.error("✗ FAIL: Get line should return Some")
+}
+
+Console.log("\n=== Directional Scanning Tests ===\n")
+
+// Test 7: Scan right
+let scanResults = Grid.scanRight(grid3, Position.make(0, 0), cell => {
+  switch cell {
+  | Corner | HLine => true
+  | _ => false
+  }
+})
+assertEqual(Array.length(scanResults), 4, "Scan right collects correct number of characters")
+
+// Test 8: Scan down
+let scanDownResults = Grid.scanDown(grid3, Position.make(0, 0), cell => {
+  switch cell {
+  | Corner | VLine => true
+  | _ => false
+  }
+})
+assertEqual(Array.length(scanDownResults), 3, "Scan down collects correct number of characters")
+
+Console.log("\n=== Search Operations Tests ===\n")
+
+// Test 9: Find all corners
+let allCorners = Grid.findAll(grid3, Corner)
+assertEqual(Array.length(allCorners), 4, "Find all corners returns 4 positions")
+
+// Test 10: Find in range
+// Grid corners are at (0,0), (0,3), (2,0), (2,3)
+// With bounds top=0, left=0, bottom=1, right=2, only (0,0) is within range
+let bounds = Bounds.make(~top=0, ~left=0, ~bottom=1, ~right=2)
+let cornersInRange = Grid.findInRange(grid3, Corner, bounds)
+assertEqual(
+  Array.length(cornersInRange),
+  1,
+  "Find in range returns corners within bounds",
+)
+
+Console.log("\n=== Performance Tests ===\n")
+
+// Test 11: Large grid performance
+let largeLines = Array.make(~length=1000, "+"->String.repeat(100))
+let startTime = Date.now()
+let largeGrid = Grid.fromLines(largeLines)
+let endTime = Date.now()
+let duration = endTime -. startTime
+
+assertEqual(largeGrid.height, 1000, "Large grid has correct height")
+assertEqual(largeGrid.width, 100, "Large grid has correct width")
+check(duration < 10.0, `Grid construction <10ms (actual: ${Float.toString(duration)}ms)`)
+
+// Test 12: Index lookup performance
+let findStartTime = Date.now()
+let _corners = Grid.findAll(largeGrid, Corner)
+let findEndTime = Date.now()
+let findDuration = findEndTime -. findStartTime
+
+check(
+  findDuration < 5.0,
+  `Finding all corners using index <5ms (actual: ${Float.toString(findDuration)}ms)`,
+)
+
+Console.log("\n=== Edge Cases Tests ===\n")
+
+// Test 15: Single character grid
+let singleCharLines = ["+"]
+let singleCharGrid = Grid.fromLines(singleCharLines)
+assertEqual(singleCharGrid.width, 1, "Single character grid width")
+assertEqual(singleCharGrid.height, 1, "Single character grid height")
+
+// Test 16: Empty lines
+let emptyLines = ["", "", ""]
+let emptyGrid = Grid.fromLines(emptyLines)
+assertEqual(emptyGrid.width, 0, "Empty lines grid width is 0")
+assertEqual(emptyGrid.height, 3, "Empty lines grid height is 3")
+
+Console.log("\n=== All Tests Complete ===\n")

package/src/parser/Semantic/ASTBuilder.mjs

@@ -0,0 +1,197 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Types from "../Core/Types.mjs";
+import * as ErrorTypes from "../Errors/ErrorTypes.mjs";
+import * as Core__Array from "@rescript/core/src/Core__Array.mjs";
+
+function astErrorToParseError(error) {
+  switch (error.TAG) {
+    case "DuplicateSceneId" :
+      return ErrorTypes.make({
+        TAG: "InvalidElement",
+        content: `Duplicate scene ID: "` + error.sceneId + `"`,
+        position: error.firstPosition
+      }, undefined);
+    case "EmptySceneId" :
+      return ErrorTypes.make({
+        TAG: "InvalidElement",
+        content: "Scene ID cannot be empty",
+        position: error.position
+      }, undefined);
+    case "InvalidSceneStructure" :
+      return ErrorTypes.make({
+        TAG: "InvalidElement",
+        content: `Invalid scene structure for "` + error.sceneId + `": ` + error.reason,
+        position: Types.Position.make(0, 0)
+      }, undefined);
+  }
+}
+
+function buildScene(config) {
+  let trimmedId = config.id.trim();
+  if (trimmedId === "") {
+    return {
+      TAG: "Error",
+      _0: {
+        TAG: "EmptySceneId",
+        position: config.position
+      }
+    };
+  }
+  let t = config.title;
+  let title = t !== undefined ? t.trim() : trimmedId.split("-").map(word => word.split("").map((char, i) => {
+      if (i === 0) {
+        return char.toUpperCase();
+      } else {
+        return char;
+      }
+    }).join("")).join(" ");
+  let t$1 = config.transition;
+  let transition = t$1 !== undefined ? t$1.trim() : "none";
+  let elements = config.elements;
+  let d = config.device;
+  let device = d !== undefined ? d : "Desktop";
+  return {
+    TAG: "Ok",
+    _0: {
+      id: trimmedId,
+      title: title,
+      transition: transition,
+      device: device,
+      elements: elements
+    }
+  };
+}
+
+function buildAST(sceneConfigs) {
+  let seenIds = {};
+  let errors = [];
+  let validScenes = [];
+  sceneConfigs.forEach(config => {
+    let firstPosition = seenIds[config.id];
+    if (firstPosition !== undefined) {
+      let error_0 = config.id;
+      let error_2 = config.position;
+      let error = {
+        TAG: "DuplicateSceneId",
+        sceneId: error_0,
+        firstPosition: firstPosition,
+        secondPosition: error_2
+      };
+      errors.push(astErrorToParseError(error));
+      return;
+    }
+    seenIds[config.id] = config.position;
+    let scene = buildScene(config);
+    if (scene.TAG === "Ok") {
+      validScenes.push(scene._0);
+      return;
+    }
+    errors.push(astErrorToParseError(scene._0));
+  });
+  if (errors.length > 0) {
+    return {
+      TAG: "Error",
+      _0: errors
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: {
+        scenes: validScenes
+      }
+    };
+  }
+}
+
+function buildSingleSceneAST(id, title, transition, elements, positionOpt) {
+  let position = positionOpt !== undefined ? positionOpt : Types.Position.make(0, 0);
+  return buildAST([{
+      id: id,
+      title: title,
+      transition: transition,
+      device: undefined,
+      elements: elements,
+      position: position
+    }]);
+}
+
+function mergeASTs(asts) {
+  let allScenes = asts.flatMap(ast => ast.scenes);
+  return buildAST(allScenes.map(scene => ({
+    id: scene.id,
+    title: scene.title,
+    transition: scene.transition,
+    device: scene.device,
+    elements: scene.elements,
+    position: Types.Position.make(0, 0)
+  })));
+}
+
+function validateAST(ast) {
+  let seenIds = {};
+  let errors = [];
+  ast.scenes.forEach(scene => {
+    let match = seenIds[scene.id];
+    if (match !== undefined) {
+      let error = ErrorTypes.make({
+        TAG: "InvalidElement",
+        content: `Duplicate scene ID: "` + scene.id + `"`,
+        position: Types.Position.make(0, 0)
+      }, undefined);
+      errors.push(error);
+    } else {
+      seenIds[scene.id] = Types.Position.make(0, 0);
+    }
+    if (scene.id.trim() !== "") {
+      return;
+    }
+    let error$1 = ErrorTypes.make({
+      TAG: "InvalidElement",
+      content: "Scene ID cannot be empty",
+      position: Types.Position.make(0, 0)
+    }, undefined);
+    errors.push(error$1);
+  });
+  if (errors.length > 0) {
+    return {
+      TAG: "Error",
+      _0: errors
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  }
+}
+
+function getSceneById(ast, sceneId) {
+  return ast.scenes.find(scene => scene.id === sceneId);
+}
+
+function hasScene(ast, sceneId) {
+  return ast.scenes.some(scene => scene.id === sceneId);
+}
+
+function countElements(ast) {
+  return Core__Array.reduce(ast.scenes, 0, (count, scene) => count + scene.elements.length | 0);
+}
+
+function getSceneIds(ast) {
+  return ast.scenes.map(scene => scene.id);
+}
+
+export {
+  astErrorToParseError,
+  buildScene,
+  buildAST,
+  buildSingleSceneAST,
+  mergeASTs,
+  validateAST,
+  getSceneById,
+  hasScene,
+  countElements,
+  getSceneIds,
+}
+/* Types Not a pure module */

package/src/parser/Semantic/ASTBuilder.res

@@ -0,0 +1,288 @@
+// ASTBuilder.res
+// Module for building Abstract Syntax Trees from parsed elements
+// Handles scene construction, validation, and AST assembly
+
+// Import core types
+type element = Types.element
+type scene = Types.scene
+type ast = Types.ast
+type parseError = ErrorTypes.t
+type position = Types.Position.t
+
+/**
+ * Error specific to AST building operations
+ */
+type astError =
+  | DuplicateSceneId({
+      sceneId: string,
+      firstPosition: position,
+      secondPosition: position,
+    })
+  | EmptySceneId({position: position})
+  | InvalidSceneStructure({
+      sceneId: string,
+      reason: string,
+    })
+
+/**
+ * Convert AST-specific errors to ParseError
+ */
+let astErrorToParseError = (error: astError): parseError => {
+  switch error {
+  | DuplicateSceneId({sceneId, firstPosition, secondPosition: _}) =>
+    ErrorTypes.make(
+      InvalidElement({
+        content: `Duplicate scene ID: "${sceneId}"`,
+        position: firstPosition,
+      }),
+      None,
+    )
+  | EmptySceneId({position}) =>
+    ErrorTypes.make(
+      InvalidElement({
+        content: "Scene ID cannot be empty",
+        position: position,
+      }),
+      None,
+    )
+  | InvalidSceneStructure({sceneId, reason}) =>
+    ErrorTypes.make(
+      InvalidElement({
+        content: `Invalid scene structure for "${sceneId}": ${reason}`,
+        position: Types.Position.make(0, 0),
+      }),
+      None,
+    )
+  }
+}
+
+/**
+ * Scene builder configuration with optional fields
+ */
+type sceneConfig = {
+  id: string,
+  title: option<string>,
+  transition: option<string>,
+  device: option<Types.deviceType>,
+  elements: array<element>,
+  position: position, // Position where scene directive was found
+}
+
+/**
+ * Build a single scene from configuration
+ * Handles optional fields by providing sensible defaults
+ *
+ * @param config - Scene configuration with id, title, transition, and elements
+ * @returns Result with scene or error
+ */
+let buildScene = (config: sceneConfig): result<scene, astError> => {
+  // Validate scene ID is not empty
+  let trimmedId = String.trim(config.id)
+  if trimmedId == "" {
+    Error(EmptySceneId({position: config.position}))
+  } else {
+    // Use title from config or derive from ID (capitalize and replace hyphens/underscores)
+    let title = switch config.title {
+    | Some(t) => String.trim(t)
+    | None => {
+        // Derive title from ID: "login-page" -> "Login Page"
+        trimmedId
+        ->String.split("-")
+        ->Array.map(word =>
+          word->String.split("")->Array.mapWithIndex((char, i) => i == 0 ? String.toUpperCase(char) : char)->Array.join("")
+        )
+        ->Array.join(" ")
+      }
+    }
+
+    // Use transition from config or default to "none"
+    let transition = switch config.transition {
+    | Some(t) => String.trim(t)
+    | None => "none"
+    }
+
+    // Validate elements array (could add more validation here)
+    let elements = config.elements
+
+    // Use device from config or default to Desktop
+    let device = switch config.device {
+    | Some(d) => d
+    | None => Types.Desktop
+    }
+
+    Ok({
+      id: trimmedId,
+      title: title,
+      transition: transition,
+      device: device,
+      elements: elements,
+    })
+  }
+}
+
+/**
+ * Build complete AST from scene configurations
+ * Validates unique scene IDs and constructs the final AST
+ *
+ * @param sceneConfigs - Array of scene configurations to build
+ * @returns Result with complete AST or array of errors
+ */
+let buildAST = (sceneConfigs: array<sceneConfig>): result<ast, array<parseError>> => {
+  // Track seen scene IDs to detect duplicates
+  let seenIds = Dict.make()
+  let errors = []
+  let validScenes = []
+
+  // Process each scene configuration
+  sceneConfigs->Array.forEach(config => {
+    // Check for duplicate scene ID
+    switch Dict.get(seenIds, config.id) {
+    | Some(firstPosition) => {
+        // Duplicate found
+        let error = DuplicateSceneId({
+          sceneId: config.id,
+          firstPosition: firstPosition,
+          secondPosition: config.position,
+        })
+        errors->Array.push(astErrorToParseError(error))->ignore
+      }
+    | None => {
+        // Record this ID
+        Dict.set(seenIds, config.id, config.position)
+
+        // Build the scene
+        switch buildScene(config) {
+        | Ok(scene) => validScenes->Array.push(scene)->ignore
+        | Error(error) => errors->Array.push(astErrorToParseError(error))->ignore
+        }
+      }
+    }
+  })
+
+  // Return errors if any, otherwise return AST
+  if Array.length(errors) > 0 {
+    Error(errors)
+  } else {
+    Ok({scenes: validScenes})
+  }
+}
+
+/**
+ * Build AST from a single scene (convenience function)
+ * Useful when parsing simple wireframes with only one scene
+ */
+let buildSingleSceneAST = (
+  ~id: string,
+  ~title: option<string>=?,
+  ~transition: option<string>=?,
+  ~elements: array<element>,
+  ~position: position=Types.Position.make(0, 0),
+): result<ast, array<parseError>> => {
+  buildAST([
+    {
+      id: id,
+      title: title,
+      transition: transition,
+      device: None,
+      elements: elements,
+      position: position,
+    },
+  ])
+}
+
+/**
+ * Merge multiple ASTs into a single AST
+ * Validates that scene IDs remain unique across merged ASTs
+ */
+let mergeASTs = (asts: array<ast>): result<ast, array<parseError>> => {
+  // Extract all scenes from all ASTs
+  let allScenes = asts->Array.flatMap(ast => ast.scenes)
+
+  // Convert scenes back to configs for validation
+  let configs = allScenes->Array.map(scene => {
+    {
+      id: scene.id,
+      title: Some(scene.title),
+      transition: Some(scene.transition),
+      device: Some(scene.device),
+      elements: scene.elements,
+      position: Types.Position.make(0, 0), // Position not available from scene
+    }
+  })
+
+  // Use buildAST to validate and merge
+  buildAST(configs)
+}
+
+/**
+ * Validate an existing AST
+ * Checks for duplicate scene IDs and other structural issues
+ */
+let validateAST = (ast: ast): result<unit, array<parseError>> => {
+  let seenIds = Dict.make()
+  let errors = []
+
+  ast.scenes->Array.forEach(scene => {
+    switch Dict.get(seenIds, scene.id) {
+    | Some(_) => {
+        let error = ErrorTypes.make(
+          InvalidElement({
+            content: `Duplicate scene ID: "${scene.id}"`,
+            position: Types.Position.make(0, 0),
+          }),
+          None,
+        )
+        errors->Array.push(error)->ignore
+      }
+    | None => Dict.set(seenIds, scene.id, Types.Position.make(0, 0))
+    }
+
+    // Validate scene has a non-empty ID
+    if String.trim(scene.id) == "" {
+      let error = ErrorTypes.make(
+        InvalidElement({
+          content: "Scene ID cannot be empty",
+          position: Types.Position.make(0, 0),
+        }),
+        None,
+      )
+      errors->Array.push(error)->ignore
+    }
+  })
+
+  if Array.length(errors) > 0 {
+    Error(errors)
+  } else {
+    Ok()
+  }
+}
+
+/**
+ * Get scene by ID from AST
+ */
+let getSceneById = (ast: ast, sceneId: string): option<scene> => {
+  ast.scenes->Array.find(scene => scene.id == sceneId)
+}
+
+/**
+ * Check if AST contains a scene with given ID
+ */
+let hasScene = (ast: ast, sceneId: string): bool => {
+  ast.scenes->Array.some(scene => scene.id == sceneId)
+}
+
+/**
+ * Count total elements across all scenes
+ */
+let countElements = (ast: ast): int => {
+  ast.scenes->Array.reduce(0, (count, scene) => {
+    count + Array.length(scene.elements)
+  })
+}
+
+/**
+ * Get all scene IDs from AST
+ */
+let getSceneIds = (ast: ast): array<string> => {
+  ast.scenes->Array.map(scene => scene.id)
+}

package/src/parser/Semantic/AlignmentCalc.mjs

@@ -0,0 +1,41 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function calculate(content, position, boxBounds) {
+  let trimmed = content.trim();
+  let contentStart = position.col;
+  let contentEnd = contentStart + trimmed.length | 0;
+  let boxLeft = boxBounds.left + 1 | 0;
+  let boxRight = boxBounds.right - 1 | 0;
+  let boxWidth = boxRight - boxLeft | 0;
+  if (boxWidth <= 0) {
+    return "Left";
+  }
+  let leftSpace = contentStart - boxLeft | 0;
+  let rightSpace = boxRight - contentEnd | 0;
+  let leftRatio = leftSpace / boxWidth;
+  let rightRatio = rightSpace / boxWidth;
+  if (leftRatio < 0.2 && rightRatio > 0.3) {
+    return "Left";
+  } else if (rightRatio < 0.2 && leftRatio > 0.3) {
+    return "Right";
+  } else if (Math.abs(leftRatio - rightRatio) < 0.15) {
+    return "Center";
+  } else {
+    return "Left";
+  }
+}
+
+function calculateWithStrategy(content, position, boxBounds, strategy) {
+  if (strategy === "RespectPosition") {
+    return calculate(content, position, boxBounds);
+  } else {
+    return "Left";
+  }
+}
+
+export {
+  calculate,
+  calculateWithStrategy,
+}
+/* No side effect */