wyreframe 0.1.0

package/src/parser/Interactions/InteractionParser.mjs

@@ -0,0 +1,88 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Types from "../Core/Types.mjs";
+import * as Core__Int from "@rescript/core/src/Core__Int.mjs";
+import * as Core__Option from "@rescript/core/src/Core__Option.mjs";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as SimpleInteractionParser from "./SimpleInteractionParser.mjs";
+
+function extractPosition(message) {
+  let jsPattern = /Line (\d+)/i;
+  let result = jsPattern.exec(message);
+  if (result === null) {
+    return;
+  }
+  let lineOpt = Core__Option.flatMap(result[1], x => {
+    if (x == null) {
+      return;
+    } else {
+      return Primitive_option.some(x);
+    }
+  });
+  if (lineOpt === undefined) {
+    return;
+  }
+  let line = Core__Int.fromString(lineOpt, undefined);
+  if (line !== undefined) {
+    return Types.Position.make(line - 1 | 0, 0);
+  }
+}
+
+function parse(input) {
+  let sceneInteractions = SimpleInteractionParser.parse(input);
+  if (sceneInteractions.TAG === "Ok") {
+    return {
+      TAG: "Ok",
+      _0: sceneInteractions._0
+    };
+  }
+  let errorMsg = sceneInteractions._0;
+  let position = extractPosition(errorMsg);
+  return {
+    TAG: "Error",
+    _0: {
+      message: errorMsg,
+      position: position
+    }
+  };
+}
+
+function parseWithDetailedError(input) {
+  let result = parse(input);
+  if (result.TAG === "Ok") {
+    return {
+      TAG: "Ok",
+      _0: result._0
+    };
+  }
+  let match = result._0;
+  let position = match.position;
+  let positionStr = position !== undefined ? ` at ` + Types.Position.toString(position) : "";
+  return {
+    TAG: "Error",
+    _0: `Interaction DSL parsing failed` + positionStr + `: ` + match.message
+  };
+}
+
+function isValid(input) {
+  let match = parse(input);
+  return match.TAG === "Ok";
+}
+
+function getSceneIds(sceneInteractions) {
+  return sceneInteractions.map(si => si.sceneId);
+}
+
+function getElementIds(sceneInteraction) {
+  return sceneInteraction.interactions.map(i => i.elementId);
+}
+
+export {
+  extractPosition,
+  parse,
+  parseWithDetailedError,
+  isValid,
+  getSceneIds,
+  getElementIds,
+}
+/* Types Not a pure module */

package/src/parser/Interactions/InteractionParser.res

@@ -0,0 +1,127 @@
+/**
+ * InteractionParser.res
+ *
+ * Main parser module for the Interaction DSL.
+ * Uses SimpleInteractionParser for lightweight, dependency-free parsing.
+ */
+
+/**
+ * Error type for interaction parsing failures.
+ * Contains error message and optional position information.
+ */
+type parseError = {
+  message: string,
+  position: option<Types.Position.t>,
+}
+
+/**
+ * Result type for parsing operations
+ */
+type parseResult = result<array<Types.sceneInteractions>, parseError>
+
+/**
+ * Extract position information from an error message.
+ *
+ * Error messages may include position in the format:
+ * "Line X: ..."
+ *
+ * @param message - The error message
+ * @returns Option<Position.t> - Extracted position or None
+ */
+let extractPosition = (message: string): option<Types.Position.t> => {
+  let jsPattern: Js.Re.t = %re("/Line (\d+)/i")
+
+  switch Js.Re.exec_(jsPattern, message) {
+  | Some(result) => {
+      let captures = Js.Re.captures(result)
+      let lineOpt = captures->Array.get(1)->Option.flatMap(x => Js.Nullable.toOption(x))
+
+      switch lineOpt {
+      | Some(lineStr) =>
+        switch Int.fromString(lineStr) {
+        | Some(line) => Some(Types.Position.make(line - 1, 0))
+        | None => None
+        }
+      | None => None
+      }
+    }
+  | None => None
+  }
+}
+
+/**
+ * Main parsing function for the Interaction DSL.
+ *
+ * Uses SimpleInteractionParser for lightweight parsing without external dependencies.
+ *
+ * @param input - The interaction DSL string to parse
+ * @returns Result with array of scene interactions or parse error
+ */
+let parse = (input: string): parseResult => {
+  switch SimpleInteractionParser.parse(input) {
+  | Ok(sceneInteractions) => Ok(sceneInteractions)
+  | Error(errorMsg) => {
+      let position = extractPosition(errorMsg)
+      Error({
+        message: errorMsg,
+        position: position,
+      })
+    }
+  }
+}
+
+/**
+ * Convenience function that returns a more detailed error message.
+ * Useful for debugging and user-facing error displays.
+ *
+ * @param input - The interaction DSL string to parse
+ * @returns Result with detailed error information
+ */
+let parseWithDetailedError = (input: string): result<array<Types.sceneInteractions>, string> => {
+  switch parse(input) {
+  | Ok(result) => Ok(result)
+  | Error({message, position}) => {
+      let positionStr = switch position {
+      | Some(pos) => ` at ${Types.Position.toString(pos)}`
+      | None => ""
+      }
+      Error(`Interaction DSL parsing failed${positionStr}: ${message}`)
+    }
+  }
+}
+
+/**
+ * Validate that the input can be parsed without returning the result.
+ * Useful for validation-only scenarios.
+ *
+ * @param input - The interaction DSL string to validate
+ * @returns true if valid, false otherwise
+ */
+let isValid = (input: string): bool => {
+  switch parse(input) {
+  | Ok(_) => true
+  | Error(_) => false
+  }
+}
+
+/**
+ * Get all scene IDs from parsed interactions.
+ * Helper function for validation and debugging.
+ *
+ * @param sceneInteractions - Parsed scene interactions
+ * @returns Array of scene IDs
+ */
+let getSceneIds = (sceneInteractions: array<Types.sceneInteractions>): array<string> => {
+  sceneInteractions->Array.map(si => si.sceneId)
+}
+
+/**
+ * Get all element IDs referenced in a scene's interactions.
+ * Useful for validation against the wireframe AST.
+ *
+ * @param sceneInteraction - A single scene's interactions
+ * @returns Array of element IDs
+ */
+let getElementIds = (sceneInteraction: Types.sceneInteractions): array<string> => {
+  sceneInteraction.interactions->Array.map(i => i.elementId)
+}

package/src/parser/Interactions/SimpleInteractionParser.mjs

@@ -0,0 +1,278 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Core__Option from "@rescript/core/src/Core__Option.mjs";
+
+let scenePattern = /^@scene:\s*(\w+)\s*$/;
+
+let inputSelectorPattern = /^#(\w+):\s*$/;
+
+let buttonSelectorPattern = /^\[([^\]]+)\]:\s*$/;
+
+let linkSelectorPattern = /^\"([^\"]+)\":\s*$/;
+
+let propertyPattern = /^\s{2}(\w+):\s*(.+?)\s*$/;
+
+let actionPattern = /^\s{2}@(\w+)\s*->\s*(.+?)\s*$/;
+
+let sceneSeparator = /^---\s*$/;
+
+function parseStringValue(value) {
+  let trimmed = value.trim();
+  if (trimmed.startsWith("\"") && trimmed.endsWith("\"")) {
+    return trimmed.slice(1, -1);
+  } else {
+    return trimmed;
+  }
+}
+
+function getCapture(result, index) {
+  return result.slice(1)[index];
+}
+
+function parseActionExpr(expr) {
+  let gotoPattern = /^goto\s*\(\s*(\w+)(?:\s*,\s*([\w-]+))?\s*\)$/;
+  let backPattern = /^back\s*\(\s*\)$/;
+  let forwardPattern = /^forward\s*\(\s*\)$/;
+  let result = gotoPattern.exec(expr);
+  if (result == null) {
+    if (backPattern.test(expr)) {
+      return "Back";
+    }
+    if (forwardPattern.test(expr)) {
+      return "Forward";
+    }
+    let callPattern = /^(\w+)\s*\(([^)]*)\)$/;
+    let result$1 = callPattern.exec(expr);
+    if (result$1 == null) {
+      return;
+    }
+    let funcName = result$1.slice(1)[0];
+    let argsStr = Core__Option.getOr(result$1.slice(1)[1], "");
+    if (funcName === undefined) {
+      return;
+    }
+    let args = argsStr.trim() === "" ? [] : argsStr.split(",").map(prim => prim.trim());
+    return {
+      TAG: "Call",
+      function: funcName,
+      args: args,
+      condition: undefined
+    };
+  }
+  let target = result.slice(1)[0];
+  let transition = Core__Option.getOr(result.slice(1)[1], "fade");
+  if (target !== undefined) {
+    return {
+      TAG: "Goto",
+      target: target,
+      transition: transition,
+      condition: undefined
+    };
+  }
+}
+
+function selectorToId(selectorType, text) {
+  switch (selectorType) {
+    case "button" :
+    case "link" :
+      break;
+    default:
+      return text;
+  }
+  return text.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+
+function createState() {
+  return {
+    currentScene: undefined,
+    currentElementId: undefined,
+    currentProperties: {},
+    currentActions: [],
+    sceneInteractions: [],
+    currentInteractions: []
+  };
+}
+
+function flushElement(state) {
+  let elementId = state.currentElementId;
+  if (elementId === undefined) {
+    return;
+  }
+  let interaction_properties = state.currentProperties;
+  let interaction_actions = state.currentActions;
+  let interaction = {
+    elementId: elementId,
+    properties: interaction_properties,
+    actions: interaction_actions
+  };
+  state.currentInteractions.push(interaction);
+  state.currentElementId = undefined;
+  state.currentProperties = {};
+  state.currentActions = [];
+}
+
+function flushScene(state) {
+  flushElement(state);
+  let sceneId = state.currentScene;
+  if (sceneId === undefined) {
+    return;
+  }
+  if (state.currentInteractions.length > 0) {
+    let si_interactions = state.currentInteractions;
+    let si = {
+      sceneId: sceneId,
+      interactions: si_interactions
+    };
+    state.sceneInteractions.push(si);
+  }
+  state.currentScene = undefined;
+  state.currentInteractions = [];
+}
+
+function parse(input) {
+  let state = {
+    currentScene: undefined,
+    currentElementId: undefined,
+    currentProperties: {},
+    currentActions: [],
+    sceneInteractions: [],
+    currentInteractions: []
+  };
+  let lines = input.split("\n");
+  let lineNum = {
+    contents: 0
+  };
+  let error = {
+    contents: undefined
+  };
+  lines.forEach(line => {
+    lineNum.contents = lineNum.contents + 1 | 0;
+    if (Core__Option.isSome(error.contents)) {
+      return;
+    }
+    let trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("//")) {
+      return;
+    }
+    if (sceneSeparator.test(trimmed)) {
+      return flushScene(state);
+    }
+    let result = scenePattern.exec(trimmed);
+    if (result == null) {
+      let result$1 = inputSelectorPattern.exec(trimmed);
+      if (result$1 == null) {
+        let result$2 = buttonSelectorPattern.exec(trimmed);
+        if (result$2 == null) {
+          let result$3 = linkSelectorPattern.exec(trimmed);
+          if (result$3 == null) {
+            let result$4 = propertyPattern.exec(line);
+            if (result$4 == null) {
+              let result$5 = actionPattern.exec(line);
+              if (result$5 == null) {
+                return;
+              }
+              let matches = result$5.slice(1);
+              let actionExpr = matches[1];
+              let match = state.currentElementId;
+              if (actionExpr === undefined) {
+                return;
+              }
+              if (match === undefined) {
+                return;
+              }
+              let action = parseActionExpr(actionExpr);
+              if (action !== undefined) {
+                state.currentActions.push(action);
+              } else {
+                error.contents = `Line ` + lineNum.contents.toString() + `: Invalid action`;
+              }
+              return;
+            }
+            let matches$1 = result$4.slice(1);
+            let key = matches$1[0];
+            let value = matches$1[1];
+            let match$1 = state.currentElementId;
+            if (key === undefined) {
+              return;
+            }
+            if (value === undefined) {
+              return;
+            }
+            if (match$1 === undefined) {
+              return;
+            }
+            let parsedValue = parseStringValue(value);
+            state.currentProperties[key] = parsedValue;
+            return;
+          }
+          flushElement(state);
+          let matches$2 = result$3.slice(1);
+          let text = matches$2[0];
+          if (text === undefined) {
+            return;
+          }
+          let id = selectorToId("link", text);
+          state.currentElementId = id;
+          return;
+        }
+        flushElement(state);
+        let matches$3 = result$2.slice(1);
+        let text$1 = matches$3[0];
+        if (text$1 === undefined) {
+          return;
+        }
+        let id$1 = selectorToId("button", text$1);
+        state.currentElementId = id$1;
+        return;
+      }
+      flushElement(state);
+      let matches$4 = result$1.slice(1);
+      let id$2 = matches$4[0];
+      if (id$2 !== undefined) {
+        state.currentElementId = id$2;
+        return;
+      } else {
+        return;
+      }
+    }
+    flushScene(state);
+    let matches$5 = result.slice(1);
+    let sceneId = matches$5[0];
+    if (sceneId !== undefined) {
+      state.currentScene = sceneId;
+      return;
+    }
+  });
+  flushScene(state);
+  let msg = error.contents;
+  if (msg !== undefined) {
+    return {
+      TAG: "Error",
+      _0: msg
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: state.sceneInteractions
+    };
+  }
+}
+
+export {
+  scenePattern,
+  inputSelectorPattern,
+  buttonSelectorPattern,
+  linkSelectorPattern,
+  propertyPattern,
+  actionPattern,
+  sceneSeparator,
+  parseStringValue,
+  getCapture,
+  parseActionExpr,
+  selectorToId,
+  createState,
+  flushElement,
+  flushScene,
+  parse,
+}
+/* No side effect */