wyreframe 0.2.0 → 0.2.1

package/package.json

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

package/src/parser/Errors/ErrorTypes.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Types from "../Core/Types.mjs";
+import * as Core__Option from "@rescript/core/src/Core__Option.mjs";
 import * as ErrorContext from "./ErrorContext.mjs";
 
 function getSeverity(code) {
@@ -95,6 +96,99 @@ function getCodeName(code) {
   }
 }
 
+function adjustCodeLineOffset(code, offset) {
+  let adjustPos = pos => Types.Position.make(pos.row + offset | 0, pos.col);
+  switch (code.TAG) {
+    case "InvalidInput" :
+      return code;
+    case "InvalidStartPosition" :
+      return {
+        TAG: "InvalidStartPosition",
+        _0: adjustPos(code._0)
+      };
+    case "UncloseBox" :
+      return {
+        TAG: "UncloseBox",
+        corner: adjustPos(code.corner),
+        direction: code.direction
+      };
+    case "MismatchedWidth" :
+      return {
+        TAG: "MismatchedWidth",
+        topLeft: adjustPos(code.topLeft),
+        topWidth: code.topWidth,
+        bottomWidth: code.bottomWidth
+      };
+    case "MisalignedPipe" :
+      return {
+        TAG: "MisalignedPipe",
+        position: adjustPos(code.position),
+        expectedCol: code.expectedCol,
+        actualCol: code.actualCol
+      };
+    case "OverlappingBoxes" :
+      return {
+        TAG: "OverlappingBoxes",
+        box1Name: code.box1Name,
+        box2Name: code.box2Name,
+        position: adjustPos(code.position)
+      };
+    case "InvalidElement" :
+      return {
+        TAG: "InvalidElement",
+        content: code.content,
+        position: adjustPos(code.position)
+      };
+    case "UnclosedBracket" :
+      return {
+        TAG: "UnclosedBracket",
+        opening: adjustPos(code.opening)
+      };
+    case "EmptyButton" :
+      return {
+        TAG: "EmptyButton",
+        position: adjustPos(code.position)
+      };
+    case "InvalidInteractionDSL" :
+      return {
+        TAG: "InvalidInteractionDSL",
+        message: code.message,
+        position: Core__Option.map(code.position, adjustPos)
+      };
+    case "UnusualSpacing" :
+      return {
+        TAG: "UnusualSpacing",
+        position: adjustPos(code.position),
+        issue: code.issue
+      };
+    case "DeepNesting" :
+      return {
+        TAG: "DeepNesting",
+        depth: code.depth,
+        position: adjustPos(code.position)
+      };
+    case "MisalignedClosingBorder" :
+      return {
+        TAG: "MisalignedClosingBorder",
+        position: adjustPos(code.position),
+        expectedCol: code.expectedCol,
+        actualCol: code.actualCol
+      };
+  }
+}
+
+function adjustLineOffset(error, offset) {
+  if (offset === 0) {
+    return error;
+  } else {
+    return {
+      code: adjustCodeLineOffset(error.code, offset),
+      severity: error.severity,
+      context: error.context
+    };
+  }
+}
+
 export {
   getSeverity,
   make,
@@ -104,5 +198,7 @@ export {
   isWarning,
   isError,
   getCodeName,
+  adjustCodeLineOffset,
+  adjustLineOffset,
 }
 /* Types Not a pure module */

package/src/parser/Errors/ErrorTypes.res

@@ -174,3 +174,61 @@ let getCodeName = (code: errorCode): string => {
   | MisalignedClosingBorder(_) => "MisalignedClosingBorder"
   }
 }
+
+/**
+ * Adjust the line offset in an error code's position.
+ * This is used to correct line numbers when scene directive lines
+ * are stripped before grid processing.
+ *
+ * @param code - The error code to adjust
+ * @param offset - The number of lines to add to the row (e.g., number of directive lines stripped)
+ * @returns A new error code with adjusted position
+ */
+let adjustCodeLineOffset = (code: errorCode, offset: int): errorCode => {
+  let adjustPos = (pos: Position.t): Position.t => {
+    Position.make(pos.row + offset, pos.col)
+  }
+
+  switch code {
+  | InvalidInput(_) as c => c
+  | InvalidStartPosition(pos) => InvalidStartPosition(adjustPos(pos))
+  | UncloseBox({corner, direction}) => UncloseBox({corner: adjustPos(corner), direction})
+  | MismatchedWidth({topLeft, topWidth, bottomWidth}) =>
+    MismatchedWidth({topLeft: adjustPos(topLeft), topWidth, bottomWidth})
+  | MisalignedPipe({position, expectedCol, actualCol}) =>
+    MisalignedPipe({position: adjustPos(position), expectedCol, actualCol})
+  | OverlappingBoxes({box1Name, box2Name, position}) =>
+    OverlappingBoxes({box1Name, box2Name, position: adjustPos(position)})
+  | InvalidElement({content, position}) =>
+    InvalidElement({content, position: adjustPos(position)})
+  | UnclosedBracket({opening}) => UnclosedBracket({opening: adjustPos(opening)})
+  | EmptyButton({position}) => EmptyButton({position: adjustPos(position)})
+  | InvalidInteractionDSL({message, position}) =>
+    InvalidInteractionDSL({message, position: position->Option.map(adjustPos)})
+  | UnusualSpacing({position, issue}) =>
+    UnusualSpacing({position: adjustPos(position), issue})
+  | DeepNesting({depth, position}) => DeepNesting({depth, position: adjustPos(position)})
+  | MisalignedClosingBorder({position, expectedCol, actualCol}) =>
+    MisalignedClosingBorder({position: adjustPos(position), expectedCol, actualCol})
+  }
+}
+
+/**
+ * Adjust the line offset in an error's position.
+ * Creates a new error with the position adjusted by the given offset.
+ *
+ * @param error - The error to adjust
+ * @param offset - The number of lines to add to the row
+ * @returns A new error with adjusted position
+ */
+let adjustLineOffset = (error: t, offset: int): t => {
+  if offset === 0 {
+    error
+  } else {
+    {
+      code: adjustCodeLineOffset(error.code, offset),
+      severity: error.severity,
+      context: error.context,
+    }
+  }
+}

package/src/parser/Parser.mjs

@@ -69,7 +69,7 @@ function mergeInteractionsIntoAST(ast, sceneInteractions) {
   }
 }
 
-function parseSingleScene(sceneContent, sceneMetadata, errors) {
+function parseSingleScene(sceneContent, sceneMetadata, lineOffset, errors) {
   let gridResult = scanGrid(sceneContent);
   if (gridResult.TAG === "Ok") {
     let grid = gridResult._0;
@@ -78,12 +78,14 @@ function parseSingleScene(sceneContent, sceneMetadata, errors) {
     if (shapesResult.TAG === "Ok") {
       let match = shapesResult._0;
       match[1].forEach(w => {
-        errors.push(w);
+        let adjusted = ErrorTypes.adjustLineOffset(w, lineOffset);
+        errors.push(adjusted);
       });
       shapes = match[0];
     } else {
       shapesResult._0.forEach(err => {
-        errors.push(err);
+        let adjusted = ErrorTypes.adjustLineOffset(err, lineOffset);
+        errors.push(adjusted);
       });
       shapes = [];
     }
@@ -110,7 +112,8 @@ function parseSingleScene(sceneContent, sceneMetadata, errors) {
     };
   }
   gridResult._0.forEach(err => {
-    errors.push(err);
+    let adjusted = ErrorTypes.adjustLineOffset(err, lineOffset);
+    errors.push(adjusted);
   });
 }
 
@@ -132,9 +135,9 @@ function parseInternal(wireframe, interactions) {
   let scenes = [];
   sceneBlocks.forEach(block => {
     let lines = block.split("\n");
-    let match = SemanticParser.parseSceneDirectives(lines);
-    let sceneContent = match[1].join("\n");
-    let scene = parseSingleScene(sceneContent, match[0], allIssues);
+    let match = SemanticParser.parseSceneDirectivesWithOffset(lines);
+    let sceneContent = match.contentLines.join("\n");
+    let scene = parseSingleScene(sceneContent, match.metadata, match.lineOffset, allIssues);
     if (scene !== undefined) {
       scenes.push(scene);
       return;

package/src/parser/Parser.res

@@ -191,12 +191,14 @@ let mergeInteractionsIntoAST = (
  *
  * @param sceneContent ASCII wireframe content for one scene (without directives)
  * @param sceneMetadata Scene metadata from directives
+ * @param lineOffset Number of directive lines stripped (for adjusting error line numbers)
  * @param errors Accumulator for errors
  * @returns Parsed scene or None if parsing failed
  */
 let parseSingleScene = (
   sceneContent: string,
   sceneMetadata: SemanticParser.sceneMetadata,
+  lineOffset: int,
   errors: array<ErrorTypes.t>,
 ): option<Types.scene> => {
   // Stage 1: Grid Scanner
@@ -204,7 +206,11 @@ let parseSingleScene = (
 
   switch gridResult {
   | Error(gridErrors) => {
-      gridErrors->Array.forEach(err => errors->Array.push(err)->ignore)
+      // Adjust line numbers by offset before adding to errors
+      gridErrors->Array.forEach(err => {
+        let adjusted = ErrorTypes.adjustLineOffset(err, lineOffset)
+        errors->Array.push(adjusted)->ignore
+      })
       None
     }
   | Ok(grid) => {
@@ -213,12 +219,20 @@ let parseSingleScene = (
 
       let shapes = switch shapesResult {
       | Error(shapeErrors) => {
-          shapeErrors->Array.forEach(err => errors->Array.push(err)->ignore)
+          // Adjust line numbers by offset before adding to errors
+          shapeErrors->Array.forEach(err => {
+            let adjusted = ErrorTypes.adjustLineOffset(err, lineOffset)
+            errors->Array.push(adjusted)->ignore
+          })
           []
         }
       | Ok((boxes, warnings)) => {
           // Collect warnings (non-fatal issues like misaligned borders)
-          warnings->Array.forEach(w => errors->Array.push(w)->ignore)
+          // Adjust line numbers by offset before adding to errors
+          warnings->Array.forEach(w => {
+            let adjusted = ErrorTypes.adjustLineOffset(w, lineOffset)
+            errors->Array.push(adjusted)->ignore
+          })
           boxes
         }
       }
@@ -294,15 +308,16 @@ let parseInternal = (wireframe: string, interactions: option<string>): parseResu
     let scenes = []
 
     sceneBlocks->Array.forEach(block => {
-      // Parse scene directives
+      // Parse scene directives and get line offset
       let lines = block->String.split("\n")
-      let (metadata, contentLines) = SemanticParser.parseSceneDirectives(lines)
+      let {metadata, contentLines, lineOffset} = SemanticParser.parseSceneDirectivesWithOffset(lines)
 
       // Rejoin content lines (without directives)
       let sceneContent = contentLines->Array.join("\n")
 
       // Parse this scene through 3-stage pipeline
-      switch parseSingleScene(sceneContent, metadata, allIssues) {
+      // Pass lineOffset to adjust error/warning line numbers
+      switch parseSingleScene(sceneContent, metadata, lineOffset, allIssues) {
       | Some(scene) => scenes->Array.push(scene)->ignore
       | None => () // Scene parsing failed, errors already collected
       }

package/src/parser/Semantic/SemanticParser.mjs

@@ -141,7 +141,7 @@ function defaultSceneMetadata() {
   };
 }
 
-function parseSceneDirectives(lines) {
+function parseSceneDirectivesWithOffset(lines) {
   let sceneId = {
     contents: undefined
   };
@@ -155,7 +155,10 @@ function parseSceneDirectives(lines) {
     contents: undefined
   };
   let contentLines = [];
-  lines.forEach(line => {
+  let firstContentLineIndex = {
+    contents: undefined
+  };
+  lines.forEach((line, lineIndex) => {
     let trimmed = line.trim();
     if (trimmed.startsWith("@scene:")) {
       let id = trimmed.replace("@scene:", "").trim();
@@ -176,6 +179,9 @@ function parseSceneDirectives(lines) {
       if (trimmed.startsWith("@")) {
         return;
       } else {
+        if (firstContentLineIndex.contents === undefined) {
+          firstContentLineIndex.contents = lineIndex;
+        }
         contentLines.push(line);
         return;
       }
@@ -204,9 +210,20 @@ function parseSceneDirectives(lines) {
     transition: finalTransition,
     device: finalDevice
   };
+  let idx = firstContentLineIndex.contents;
+  let lineOffset = idx !== undefined ? idx : 0;
+  return {
+    metadata: metadata,
+    contentLines: contentLines,
+    lineOffset: lineOffset
+  };
+}
+
+function parseSceneDirectives(lines) {
+  let result = parseSceneDirectivesWithOffset(lines);
   return [
-    metadata,
-    contentLines
+    result.metadata,
+    result.contentLines
   ];
 }
 
@@ -824,6 +841,7 @@ export {
   hasContent,
   getContentLineCount,
   defaultSceneMetadata,
+  parseSceneDirectivesWithOffset,
   parseSceneDirectives,
   splitSceneBlocks,
   groupContentByScenes,

package/src/parser/Semantic/SemanticParser.res

@@ -261,7 +261,32 @@ let defaultSceneMetadata = (): sceneMetadata => {
  * ```
  * Returns: ({id: "login", title: "Login Page", transition: "slide"}, ["+--Login--+", ...])
  */
-let parseSceneDirectives = (lines: array<string>): (sceneMetadata, array<string>) => {
+/**
+ * Result type for parseSceneDirectives that includes line offset information.
+ * The lineOffset indicates how many lines were removed from the beginning
+ * before the first content line, which is needed to correctly report
+ * line numbers in warnings and errors.
+ */
+type directiveParseResult = {
+  metadata: sceneMetadata,
+  contentLines: array<string>,
+  lineOffset: int,  // Number of directive lines stripped from the beginning
+}
+
+/**
+ * Parse scene directives and track line offset.
+ * Returns metadata, content lines, and the number of lines stripped from the beginning.
+ *
+ * The lineOffset is calculated as the index of the first content line in the original
+ * input. This offset is needed to convert grid row numbers back to original file line numbers.
+ *
+ * Example:
+ * - Input: ["@scene: login", "", "+---+", ...]
+ * - Output: contentLines = ["", "+---+", ...], lineOffset = 1
+ *
+ * Grid row 0 corresponds to original line (0 + lineOffset + 1) = line 2 (1-indexed)
+ */
+let parseSceneDirectivesWithOffset = (lines: array<string>): directiveParseResult => {
   // Use mutable refs to accumulate directive values
   let sceneId = ref(None)
   let title = ref(None)
@@ -269,7 +294,10 @@ let parseSceneDirectives = (lines: array<string>): (sceneMetadata, array<string>
   let device = ref(None)
   let contentLines = []
 
-  lines->Array.forEach(line => {
+  // Track the index of the first content line (for line offset calculation)
+  let firstContentLineIndex = ref(None)
+
+  lines->Array.forEachWithIndex((line, lineIndex) => {
     let trimmed = line->String.trim
 
     if trimmed->String.startsWith("@scene:") {
@@ -301,6 +329,10 @@ let parseSceneDirectives = (lines: array<string>): (sceneMetadata, array<string>
       ()
     } else {
       // Non-directive line - add to content
+      // Track the index of the first content line
+      if firstContentLineIndex.contents === None {
+        firstContentLineIndex := Some(lineIndex)
+      }
       contentLines->Array.push(line)
     }
   })
@@ -334,7 +366,27 @@ let parseSceneDirectives = (lines: array<string>): (sceneMetadata, array<string>
     device: finalDevice,
   }
 
-  (metadata, contentLines)
+  // Calculate line offset: index of first content line
+  // If no content lines, offset is 0
+  let lineOffset = switch firstContentLineIndex.contents {
+  | Some(idx) => idx
+  | None => 0
+  }
+
+  {
+    metadata,
+    contentLines,
+    lineOffset,
+  }
+}
+
+/**
+ * Parse scene directives from an array of lines.
+ * This is the original API that returns just (metadata, contentLines) for backward compatibility.
+ */
+let parseSceneDirectives = (lines: array<string>): (sceneMetadata, array<string>) => {
+  let result = parseSceneDirectivesWithOffset(lines)
+  (result.metadata, result.contentLines)
 }
 
 /**