wyreframe 0.7.3 → 0.7.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wyreframe",
-  "version": "0.7.3",
+  "version": "0.7.5",
   "description": "ASCII wireframe + interaction DSL to HTML converter with scene transitions",
   "author": "wickedev",
   "repository": {

package/src/parser/Detector/BoxTracer.mjs

@@ -87,7 +87,24 @@ function findBottomRightCorner(grid, topLeft, topRight) {
       switch (match) {
         case "Corner" :
           lastCorner = pos;
-          row = row + 1 | 0;
+          let nextRow = row + 1 | 0;
+          if (nextRow < grid.height) {
+            let nextPos = Types.Position.make(nextRow, topRight.col);
+            let match$1 = Grid.get(grid, nextPos);
+            if (match$1 === "Corner" && typeof match$1 !== "object") {
+              let nextLeftPos = Types.Position.make(nextRow, topLeft.col);
+              let match$2 = Grid.get(grid, nextLeftPos);
+              if (match$2 === "Corner" && typeof match$2 !== "object") {
+                $$continue = false;
+              } else {
+                row = row + 1 | 0;
+              }
+            } else {
+              row = row + 1 | 0;
+            }
+          } else {
+            row = row + 1 | 0;
+          }
           break;
         case "VLine" :
           row = row + 1 | 0;
@@ -135,6 +152,57 @@ function traceBox(grid, topLeft) {
         })
       };
     }
+    let nextRow = topLeft.row + 1 | 0;
+    let isValidTopEdge;
+    if (nextRow < grid.height) {
+      let nextLeftPos = Types.Position.make(nextRow, topLeft.col);
+      let nextRightPos = Types.Position.make(nextRow, topRightOpt.col);
+      let leftChar = Grid.get(grid, nextLeftPos);
+      let rightChar = Grid.get(grid, nextRightPos);
+      if (leftChar !== undefined && typeof leftChar !== "object") {
+        switch (leftChar) {
+          case "Corner" :
+            if (rightChar !== undefined && typeof rightChar !== "object") {
+              switch (rightChar) {
+                case "Corner" :
+                  isValidTopEdge = false;
+                  break;
+                default:
+                  isValidTopEdge = true;
+              }
+            } else {
+              isValidTopEdge = true;
+            }
+            break;
+          case "VLine" :
+            if (rightChar !== undefined && typeof rightChar !== "object") {
+              switch (rightChar) {
+                default:
+                  isValidTopEdge = true;
+              }
+            } else {
+              isValidTopEdge = true;
+            }
+            break;
+          default:
+            isValidTopEdge = true;
+        }
+      } else {
+        isValidTopEdge = true;
+      }
+    } else {
+      isValidTopEdge = false;
+    }
+    if (!isValidTopEdge) {
+      return {
+        TAG: "Error",
+        _0: ErrorTypes.makeSimple({
+          TAG: "InvalidElement",
+          content: "Not a valid box top-left corner (adjacent box detected)",
+          position: topLeft
+        })
+      };
+    }
     let topEdgeChars = topEdgeScan.map(param => param[1]);
     if (isDividerOnlyEdge(topEdgeChars)) {
       return {

package/src/parser/Detector/BoxTracer.res

@@ -114,6 +114,7 @@ let rowHasVLineInRange = (grid: Grid.t, row: int, leftCol: int, rightCol: int):
  * - Continues through rows with misaligned VLines (records for warnings)
  * - Stops at rows with no VLine at all in the box's column range (box boundary)
  * - Handles internal dividers (+=====+) correctly by finding the last corner
+ * - IMPORTANT: Stops when detecting vertically adjacent boxes (Issue #18)
  *
  * @param grid - The 2D character grid
  * @param topLeft - Position of top-left corner (for determining left boundary)
@@ -132,7 +133,40 @@ let findBottomRightCorner = (grid: Grid.t, topLeft: Position.t, topRight: Positi
     | Some(Corner) => {
         // Found a corner at the expected column - remember it
         lastCorner := Some(pos)
-        row := row.contents + 1
+
+        // Issue #18 fix: Check if the NEXT row also has a Corner at the same column.
+        // If so, we've found the bottom of THIS box and the top of ANOTHER box.
+        // We should stop scanning here to avoid merging adjacent boxes.
+        let nextRow = row.contents + 1
+        if nextRow < grid.height {
+          let nextPos = Position.make(nextRow, topRight.col)
+          switch Grid.get(grid, nextPos) {
+          | Some(Corner) => {
+              // Next row also has a corner - this indicates adjacent boxes
+              // Also check if the next row starts a new box by checking left column
+              let nextLeftPos = Position.make(nextRow, topLeft.col)
+              switch Grid.get(grid, nextLeftPos) {
+              | Some(Corner) => {
+                  // Both corners present in next row = new box starting
+                  // Stop scanning - current corner is our bottom-right
+                  continue := false
+                }
+              | _ => {
+                  // Only right corner in next row - might be internal structure
+                  // Continue scanning
+                  row := row.contents + 1
+                }
+              }
+            }
+          | _ => {
+              // Next row doesn't have a corner - continue normally
+              row := row.contents + 1
+            }
+          }
+        } else {
+          // No more rows - we're done
+          row := row.contents + 1
+        }
       }
     | Some(VLine) => {
         // Found a VLine at the expected column - continue scanning
@@ -198,6 +232,41 @@ let traceBox = (grid: Grid.t, topLeft: Position.t): traceResult => {
           ),
         )
       | Some(topRight) => {
+          // Issue #18 fix: Validate this is a TRUE top edge, not a bottom edge
+          // of another box. A valid top edge should have VLine characters (|)
+          // in the next row at the left and right columns, NOT Corner characters (+).
+          // If the next row has corners at both positions, this is likely the
+          // bottom edge of one box immediately followed by the top edge of another.
+          let nextRow = topLeft.row + 1
+          let isValidTopEdge = if nextRow < grid.height {
+            let nextLeftPos = Position.make(nextRow, topLeft.col)
+            let nextRightPos = Position.make(nextRow, topRight.col)
+            let leftChar = Grid.get(grid, nextLeftPos)
+            let rightChar = Grid.get(grid, nextRightPos)
+            // Valid top edge: next row has VLine on both sides (content row)
+            // Invalid: next row has Corner on both sides (another box edge)
+            switch (leftChar, rightChar) {
+            | (Some(Corner), Some(Corner)) => false  // This is a bottom edge, not a top
+            | (Some(VLine), Some(VLine)) => true     // This is a valid top edge
+            | (Some(VLine), Some(Corner)) => true    // Could be valid with internal structure
+            | (Some(Corner), Some(VLine)) => true    // Could be valid with internal structure
+            | _ => true  // Be permissive for other cases
+            }
+          } else {
+            false  // No next row means this can't be a valid box top
+          }
+
+          if !isValidTopEdge {
+            // This corner is likely a bottom edge of another box, not a valid top-left
+            Error(
+              ErrorTypes.makeSimple(
+                ErrorTypes.InvalidElement({
+                  content: "Not a valid box top-left corner (adjacent box detected)",
+                  position: topLeft,
+                }),
+              ),
+            )
+          } else {
           // Step 3: Extract box name from top edge
           let topEdgeChars = Array.map(topEdgeScan, ((_, cell)) => cell)
 
@@ -427,6 +496,7 @@ let traceBox = (grid: Grid.t, topLeft: Position.t): traceResult => {
           }
         }
       } // Close else block for isDividerOnlyEdge
+      } // Close else block for isValidTopEdge
       }
     }
   | _ =>

package/src/parser/Semantic/SemanticParser.mjs

@@ -642,6 +642,17 @@ function parseContentLine(line, lineIndex, contentStartRow, box, registry) {
   if (trimmed === "") {
     let row = contentStartRow + lineIndex | 0;
     let baseCol = box.bounds.left + 1 | 0;
+    let rowWithinChildBox = box.children.some(child => {
+      let b = child.bounds;
+      if (row >= b.top) {
+        return row <= b.bottom;
+      } else {
+        return false;
+      }
+    });
+    if (rowWithinChildBox) {
+      return;
+    }
     let position = Types.Position.make(row, baseCol);
     return {
       TAG: "Spacer",

package/src/parser/Semantic/SemanticParser.res

@@ -1083,11 +1083,25 @@ let parseContentLine = (
   let trimmed = line->String.trim
 
   // Issue #16: Preserve empty lines as Spacer elements for vertical spacing
+  // Issue #19: But don't create Spacers for rows that are within child box bounds
   if trimmed === "" {
     let row = contentStartRow + lineIndex
     let baseCol = box.bounds.left + 1
-    let position = Position.make(row, baseCol)
-    Some(Spacer({position: position}))
+
+    // Check if this row is within any child box's vertical bounds
+    // If so, skip creating a Spacer (Issue #19: incorrect spacer count)
+    let rowWithinChildBox = box.children->Array.some(child => {
+      let b = child.bounds
+      row >= b.top && row <= b.bottom
+    })
+
+    if rowWithinChildBox {
+      // Skip spacer for rows occupied by child boxes
+      None
+    } else {
+      let position = Position.make(row, baseCol)
+      Some(Spacer({position: position}))
+    }
   } else if isNoiseText(trimmed) {
     // Filter out border/noise text - don't create any element
     None