wyreframe 0.1.1 → 0.2.0

package/src/parser/Parser.res

@@ -8,10 +8,11 @@
 // ============================================================================
 
 /**
- * Parse result type - either a successful AST or an array of parse errors.
+ * Parse result type - either a successful (AST, warnings) tuple or an array of parse errors.
+ * Warnings are non-fatal issues like misaligned borders that don't prevent parsing.
  * This Result type is compatible with TypeScript through GenType.
  */
-type parseResult = result<Types.ast, array<ErrorTypes.t>>
+type parseResult = result<(Types.ast, array<ErrorTypes.t>), array<ErrorTypes.t>>
 
 /**
  * Interaction parse result type.
@@ -65,11 +66,11 @@ let scanGrid = (wireframe: string): result<Grid.t, array<ErrorTypes.t>> => {
  * and builds parent-child hierarchy.
  *
  * @param grid The 2D grid from Stage 1
- * @returns Result containing root boxes or errors
+ * @returns Result containing (root boxes, warnings) or errors
  *
  * Requirements: REQ-3, REQ-4, REQ-5, REQ-6, REQ-7 (Shape Detection)
  */
-let detectShapes = (grid: Grid.t): result<array<box>, array<ErrorTypes.t>> => {
+let detectShapes = (grid: Grid.t): result<(array<box>, array<ErrorTypes.t>), array<ErrorTypes.t>> => {
   // Use ShapeDetector to detect all shapes in the grid
   ShapeDetector.detect(grid)
 }
@@ -215,7 +216,11 @@ let parseSingleScene = (
           shapeErrors->Array.forEach(err => errors->Array.push(err)->ignore)
           []
         }
-      | Ok(shapes) => shapes
+      | Ok((boxes, warnings)) => {
+          // Collect warnings (non-fatal issues like misaligned borders)
+          warnings->Array.forEach(w => errors->Array.push(w)->ignore)
+          boxes
+        }
       }
 
       // Stage 3: Parse box content into elements
@@ -273,8 +278,8 @@ let parseSingleScene = (
  * @returns Result containing AST or array of parse errors
  */
 let parseInternal = (wireframe: string, interactions: option<string>): parseResult => {
-  // Accumulator for all errors across stages
-  let allErrors = []
+  // Accumulator for all issues (errors and warnings) across stages
+  let allIssues = []
 
   // Split wireframe into scene blocks
   let sceneBlocks = SemanticParser.splitSceneBlocks(wireframe)
@@ -282,8 +287,8 @@ let parseInternal = (wireframe: string, interactions: option<string>): parseResu
   // Check if wireframe is empty
   let trimmed = wireframe->String.trim
   if sceneBlocks->Array.length === 0 && trimmed === "" {
-    // Empty wireframe - return empty AST
-    Ok({scenes: []})
+    // Empty wireframe - return empty AST with no warnings
+    Ok(({scenes: []}: Types.ast, []))
   } else {
     // Parse each scene block
     let scenes = []
@@ -297,7 +302,7 @@ let parseInternal = (wireframe: string, interactions: option<string>): parseResu
       let sceneContent = contentLines->Array.join("\n")
 
       // Parse this scene through 3-stage pipeline
-      switch parseSingleScene(sceneContent, metadata, allErrors) {
+      switch parseSingleScene(sceneContent, metadata, allIssues) {
       | Some(scene) => scenes->Array.push(scene)->ignore
       | None => () // Scene parsing failed, errors already collected
       }
@@ -314,7 +319,7 @@ let parseInternal = (wireframe: string, interactions: option<string>): parseResu
 
         switch interactionsResult {
         | Error(errors) => {
-            errors->Array.forEach(err => allErrors->Array.push(err)->ignore)
+            errors->Array.forEach(err => allIssues->Array.push(err)->ignore)
             baseAst // Return AST without interactions on error
           }
         | Ok(sceneInteractions) => {
@@ -325,19 +330,23 @@ let parseInternal = (wireframe: string, interactions: option<string>): parseResu
       }
     }
 
+    // Separate errors from warnings
+    let errors = allIssues->Array.filter(issue => ErrorTypes.isError(issue))
+    let warnings = allIssues->Array.filter(issue => ErrorTypes.isWarning(issue))
+
     // Return final result
-    // Return Error if all boxes failed to parse and we have errors
-    // Return Ok if at least some elements were parsed successfully
+    // Return Error if all boxes failed to parse and we have actual errors
+    // Return Ok with warnings if at least some elements were parsed successfully
     let totalElements = finalAst.scenes->Array.reduce(0, (acc, scene) => {
       acc + Array.length(scene.elements)
     })
 
-    if Array.length(allErrors) > 0 && totalElements === 0 {
-      // No elements parsed and we have errors - return error
-      Error(allErrors)
+    if Array.length(errors) > 0 && totalElements === 0 {
+      // No elements parsed and we have errors - return error (include warnings too)
+      Error(allIssues)
     } else {
-      // Either no errors, or some elements were parsed - return Ok
-      Ok(finalAst)
+      // Either no errors, or some elements were parsed - return Ok with warnings
+      Ok((finalAst, warnings))
     }
   }
 }

package/src/renderer/Renderer.gen.tsx

@@ -22,6 +22,11 @@ export type renderOptions = {
 /** * Scene management interface returned by render function. */
 export type sceneManager = {
   readonly goto: (_1:string) => void; 
+  readonly back: () => void; 
+  readonly forward: () => void; 
+  readonly refresh: () => void; 
+  readonly canGoBack: () => boolean; 
+  readonly canGoForward: () => boolean; 
   readonly getCurrentScene: () => (undefined | string); 
   readonly getSceneIds: () => string[]
 };
@@ -34,7 +39,8 @@ export type renderResult = { readonly root: DomBindings_element; readonly sceneM
 export type createUISuccessResult = {
   readonly root: DomBindings_element; 
   readonly sceneManager: sceneManager; 
-  readonly ast: Types_ast
+  readonly ast: Types_ast; 
+  readonly warnings: ErrorTypes_t[]
 };
 
 export type createUIResult = 

package/src/renderer/Renderer.mjs

@@ -284,7 +284,13 @@ function createSceneManager(scenes) {
   let currentScene = {
     contents: undefined
   };
-  let goto = id => {
+  let historyStack = {
+    contents: []
+  };
+  let forwardStack = {
+    contents: []
+  };
+  let switchToScene = id => {
     let currentId = currentScene.contents;
     if (currentId !== undefined) {
       let el = scenes.get(currentId);
@@ -299,10 +305,74 @@ function createSceneManager(scenes) {
       return;
     }
   };
+  let goto = id => {
+    let currentId = currentScene.contents;
+    if (currentId !== undefined && currentId !== id) {
+      historyStack.contents = historyStack.contents.concat([currentId]);
+      forwardStack.contents = [];
+    }
+    switchToScene(id);
+  };
+  let back = () => {
+    let history = historyStack.contents;
+    let len = history.length;
+    if (len <= 0) {
+      return;
+    }
+    let prevId = history[len - 1 | 0];
+    if (prevId === undefined) {
+      return;
+    }
+    let currentId = currentScene.contents;
+    if (currentId !== undefined) {
+      forwardStack.contents = forwardStack.contents.concat([currentId]);
+    }
+    historyStack.contents = history.slice(0, len - 1 | 0);
+    switchToScene(prevId);
+  };
+  let forward = () => {
+    let fwdStack = forwardStack.contents;
+    let len = fwdStack.length;
+    if (len <= 0) {
+      return;
+    }
+    let nextId = fwdStack[len - 1 | 0];
+    if (nextId === undefined) {
+      return;
+    }
+    let currentId = currentScene.contents;
+    if (currentId !== undefined) {
+      historyStack.contents = historyStack.contents.concat([currentId]);
+    }
+    forwardStack.contents = fwdStack.slice(0, len - 1 | 0);
+    switchToScene(nextId);
+  };
+  let refresh = () => {
+    let id = currentScene.contents;
+    if (id === undefined) {
+      return;
+    }
+    let el = scenes.get(id);
+    if (el === undefined) {
+      return;
+    }
+    let el$1 = Primitive_option.valFromOption(el);
+    el$1.classList.remove("active");
+    setTimeout(() => {
+      el$1.classList.add("active");
+    }, 0);
+  };
+  let canGoBack = () => historyStack.contents.length > 0;
+  let canGoForward = () => forwardStack.contents.length > 0;
   let getCurrentScene = () => currentScene.contents;
   let getSceneIds = () => Array.from(scenes.keys());
   return {
     goto: goto,
+    back: back,
+    forward: forward,
+    refresh: refresh,
+    canGoBack: canGoBack,
+    canGoForward: canGoForward,
     getCurrentScene: getCurrentScene,
     getSceneIds: getSceneIds
   };
@@ -338,16 +408,41 @@ function render(ast, options) {
   let gotoRef = {
     contents: undefined
   };
+  let backRef = {
+    contents: undefined
+  };
+  let forwardRef = {
+    contents: undefined
+  };
   let handleAction = action => {
     if (typeof action !== "object") {
-      return;
-    }
-    if (action.TAG !== "Goto") {
-      return;
-    }
-    let goto = gotoRef.contents;
-    if (goto !== undefined) {
-      return goto(action.target);
+      if (action === "Back") {
+        let back = backRef.contents;
+        if (back !== undefined) {
+          return back();
+        } else {
+          return;
+        }
+      }
+      let forward = forwardRef.contents;
+      if (forward !== undefined) {
+        return forward();
+      } else {
+        return;
+      }
+    } else {
+      switch (action.TAG) {
+        case "Goto" :
+          let goto = gotoRef.contents;
+          if (goto !== undefined) {
+            return goto(action.target);
+          } else {
+            return;
+          }
+        case "Validate" :
+        case "Call" :
+          return;
+      }
     }
   };
   let sceneMap = new Map();
@@ -358,6 +453,8 @@ function render(ast, options) {
   });
   let manager = createSceneManager(sceneMap);
   gotoRef.contents = manager.goto;
+  backRef.contents = manager.back;
+  forwardRef.contents = manager.forward;
   if (ast.scenes.length > 0) {
     let firstScene$1 = ast.scenes[0];
     if (firstScene$1 !== undefined) {
@@ -375,37 +472,41 @@ function toHTMLString(_ast, _options) {
 }
 
 function createUI(text, options) {
-  let ast = Parser.parse(text);
-  if (ast.TAG !== "Ok") {
+  let errors = Parser.parse(text);
+  if (errors.TAG !== "Ok") {
     return {
       TAG: "Error",
-      _0: ast._0
+      _0: errors._0
     };
   }
-  let ast$1 = ast._0;
-  let match = render(ast$1, options);
+  let match = errors._0;
+  let ast = match[0];
+  let match$1 = render(ast, options);
   return {
     TAG: "Ok",
     _0: {
-      root: match.root,
-      sceneManager: match.sceneManager,
-      ast: ast$1
+      root: match$1.root,
+      sceneManager: match$1.sceneManager,
+      ast: ast,
+      warnings: match[1]
     }
   };
 }
 
 function createUIOrThrow(text, options) {
-  let ast = Parser.parse(text);
-  if (ast.TAG === "Ok") {
-    let ast$1 = ast._0;
-    let match = render(ast$1, options);
+  let errors = Parser.parse(text);
+  if (errors.TAG === "Ok") {
+    let match = errors._0;
+    let ast = match[0];
+    let match$1 = render(ast, options);
     return {
-      root: match.root,
-      sceneManager: match.sceneManager,
-      ast: ast$1
+      root: match$1.root,
+      sceneManager: match$1.sceneManager,
+      ast: ast,
+      warnings: match[1]
     };
   }
-  let messages = ast._0.map(err => ErrorMessages.getTitle(err.code)).join("\n");
+  let messages = errors._0.map(err => ErrorMessages.getTitle(err.code)).join("\n");
   return Stdlib_JsError.throwWithMessage("Parse failed:\n" + messages);
 }
 

package/src/renderer/Renderer.res

@@ -77,6 +77,11 @@ let defaultOptions: renderOptions = {
  */
 type sceneManager = {
   goto: string => unit,
+  back: unit => unit,
+  forward: unit => unit,
+  refresh: unit => unit,
+  canGoBack: unit => bool,
+  canGoForward: unit => bool,
   getCurrentScene: unit => option<string>,
   getSceneIds: unit => array<string>,
 }
@@ -415,8 +420,11 @@ let renderScene = (scene: scene, ~onAction: option<actionHandler>=?): DomBinding
 
 let createSceneManager = (scenes: Map.t<string, DomBindings.element>): sceneManager => {
   let currentScene = ref(None)
+  let historyStack: ref<array<string>> = ref([])
+  let forwardStack: ref<array<string>> = ref([])
 
-  let goto = (id: string): unit => {
+  // Internal function to switch scenes without affecting history
+  let switchToScene = (id: string): unit => {
     switch currentScene.contents {
     | Some(currentId) => {
         switch scenes->Map.get(currentId) {
@@ -436,6 +444,88 @@ let createSceneManager = (scenes: Map.t<string, DomBindings.element>): sceneMana
     }
   }
 
+  let goto = (id: string): unit => {
+    // Add current scene to history before navigating
+    switch currentScene.contents {
+    | Some(currentId) if currentId != id => {
+        historyStack := historyStack.contents->Array.concat([currentId])
+        // Clear forward stack when navigating to new scene
+        forwardStack := []
+      }
+    | _ => ()
+    }
+    switchToScene(id)
+  }
+
+  let back = (): unit => {
+    let history = historyStack.contents
+    let len = history->Array.length
+    if len > 0 {
+      switch history->Array.get(len - 1) {
+      | Some(prevId) => {
+          // Add current scene to forward stack
+          switch currentScene.contents {
+          | Some(currentId) => {
+              forwardStack := forwardStack.contents->Array.concat([currentId])
+            }
+          | None => ()
+          }
+          // Remove last item from history
+          historyStack := history->Array.slice(~start=0, ~end=len - 1)
+          // Navigate to previous scene
+          switchToScene(prevId)
+        }
+      | None => ()
+      }
+    }
+  }
+
+  let forward = (): unit => {
+    let fwdStack = forwardStack.contents
+    let len = fwdStack->Array.length
+    if len > 0 {
+      switch fwdStack->Array.get(len - 1) {
+      | Some(nextId) => {
+          // Add current scene to history
+          switch currentScene.contents {
+          | Some(currentId) => {
+              historyStack := historyStack.contents->Array.concat([currentId])
+            }
+          | None => ()
+          }
+          // Remove last item from forward stack
+          forwardStack := fwdStack->Array.slice(~start=0, ~end=len - 1)
+          // Navigate to next scene
+          switchToScene(nextId)
+        }
+      | None => ()
+      }
+    }
+  }
+
+  let refresh = (): unit => {
+    switch currentScene.contents {
+    | Some(id) => {
+        // Remove active class and re-add it to trigger any CSS animations
+        switch scenes->Map.get(id) {
+        | Some(el) => {
+            el->DomBindings.classList->DomBindings.remove("active")
+            // Use setTimeout to ensure the class removal is processed
+            let _ = Js.Global.setTimeout(() => {
+              el->DomBindings.classList->DomBindings.add("active")
+            }, 0)
+          }
+        | None => ()
+        }
+      }
+    | None => ()
+    }
+  }
+
+  let canGoBack = (): bool => historyStack.contents->Array.length > 0
+
+  let canGoForward = (): bool => forwardStack.contents->Array.length > 0
+
   let getCurrentScene = (): option<string> => currentScene.contents
 
   let getSceneIds = (): array<string> => {
@@ -444,6 +534,11 @@ let createSceneManager = (scenes: Map.t<string, DomBindings.element>): sceneMana
 
   {
     goto,
+    back,
+    forward,
+    refresh,
+    canGoBack,
+    canGoForward,
     getCurrentScene,
     getSceneIds,
   }
@@ -494,10 +589,12 @@ let render = (ast: ast, options: option<renderOptions>): renderResult => {
   | None => ()
   }
 
-  // Create a ref to hold the goto function (set after sceneManager is created)
+  // Create refs to hold navigation functions (set after sceneManager is created)
   let gotoRef: ref<option<string => unit>> = ref(None)
+  let backRef: ref<option<unit => unit>> = ref(None)
+  let forwardRef: ref<option<unit => unit>> = ref(None)
 
-  // Create action handler that uses the gotoRef
+  // Create action handler that uses the refs
   let handleAction = (action: interactionAction): unit => {
     switch action {
     | Goto({target, _}) => {
@@ -507,12 +604,16 @@ let render = (ast: ast, options: option<renderOptions>): renderResult => {
         }
       }
     | Back => {
-        // TODO: Implement history-based back navigation
-        ()
+        switch backRef.contents {
+        | Some(back) => back()
+        | None => ()
+        }
       }
     | Forward => {
-        // TODO: Implement history-based forward navigation
-        ()
+        switch forwardRef.contents {
+        | Some(forward) => forward()
+        | None => ()
+        }
       }
     | Validate(_) => {
         // TODO: Implement field validation
@@ -535,8 +636,10 @@ let render = (ast: ast, options: option<renderOptions>): renderResult => {
 
   let manager = createSceneManager(sceneMap)
 
-  // Now that sceneManager is created, set the gotoRef
+  // Now that sceneManager is created, set the refs
   gotoRef := Some(manager.goto)
+  backRef := Some(manager.back)
+  forwardRef := Some(manager.forward)
 
   if ast.scenes->Array.length > 0 {
     switch ast.scenes->Array.get(0) {
@@ -568,6 +671,7 @@ type createUISuccessResult = {
   root: DomBindings.element,
   sceneManager: sceneManager,
   ast: Types.ast,
+  warnings: array<ErrorTypes.t>,
 }
 
 type createUIResult = result<createUISuccessResult, array<ErrorTypes.t>>
@@ -595,9 +699,9 @@ type createUIResult = result<createUISuccessResult, array<ErrorTypes.t>>
 @genType
 let createUI = (text: string, options: option<renderOptions>): createUIResult => {
   switch Parser.parse(text) {
-  | Ok(ast) => {
+  | Ok((ast, warnings)) => {
       let {root, sceneManager} = render(ast, options)
-      Ok({root, sceneManager, ast})
+      Ok({root, sceneManager, ast, warnings})
     }
   | Error(errors) => Error(errors)
   }
@@ -621,9 +725,9 @@ let createUI = (text: string, options: option<renderOptions>): createUIResult =>
 @genType
 let createUIOrThrow = (text: string, options: option<renderOptions>): createUISuccessResult => {
   switch Parser.parse(text) {
-  | Ok(ast) => {
+  | Ok((ast, warnings)) => {
       let {root, sceneManager} = render(ast, options)
-      {root, sceneManager, ast}
+      {root, sceneManager, ast, warnings}
     }
   | Error(errors) => {
       let messages = errors

package/src/test/Expect.mjs

@@ -1,9 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-
-let pass;
-
-export {
-  pass,
-}
-/* No side effect */