wyreframe 0.1.0

package/src/parser/Semantic/Elements/EmphasisParser.mjs

@@ -0,0 +1,46 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Types from "../../Core/Types.mjs";
+import * as AlignmentCalc from "../AlignmentCalc.mjs";
+import * as ElementParser from "./ElementParser.mjs";
+
+let emphasisPattern = /^\s*\*\s+(.+)$/;
+
+let quickTestPattern = /^\s*\*\s/;
+
+function canParse(content) {
+  return quickTestPattern.test(content);
+}
+
+function parse(content, position, bounds) {
+  let result = emphasisPattern.exec(content);
+  if (result == null) {
+    return;
+  }
+  let matches = result.slice(1);
+  let textContent = matches[0];
+  if (textContent === undefined) {
+    return;
+  }
+  let align = AlignmentCalc.calculateWithStrategy(content, position, bounds, "RespectPosition");
+  return {
+    TAG: "Text",
+    content: textContent,
+    emphasis: true,
+    position: Types.Position.make(position.row, position.col),
+    align: align
+  };
+}
+
+function make() {
+  return ElementParser.make(70, canParse, parse);
+}
+
+export {
+  emphasisPattern,
+  quickTestPattern,
+  canParse,
+  parse,
+  make,
+}
+/* Types Not a pure module */

package/src/parser/Semantic/Elements/EmphasisParser.res

@@ -0,0 +1,67 @@
+// EmphasisParser.res
+// Parser for emphasis text syntax: * Text
+
+open Types
+
+/**
+ * Emphasis pattern regex: ^\s*\*\s+(.+)
+ * Matches: * Important text
+ */
+let emphasisPattern = %re("/^\s*\*\s+(.+)$/")
+
+/**
+ * Quick test pattern for canParse (optimized for speed).
+ */
+let quickTestPattern = %re("/^\s*\*\s/")
+
+/**
+ * Check if content matches emphasis syntax pattern.
+ */
+let canParse = (content: string): bool => {
+  Js.Re.test_(quickTestPattern, content)
+}
+
+/**
+ * Parse emphasis element from content.
+ */
+let parse = (
+  content: string,
+  position: Position.t,
+  bounds: Bounds.t,
+): option<Types.element> => {
+  switch emphasisPattern->RegExp.exec(content) {
+  | None => None
+  | Some(result) => {
+      // RegExp.Result.matches slices off the full match, so matches[0] is the first captured group
+      let matches = result->RegExp.Result.matches
+      switch matches[0] {
+      | None => None
+      | Some(textContent) => {
+          let align = AlignmentCalc.calculateWithStrategy(
+            content,
+            position,
+            bounds,
+            AlignmentCalc.RespectPosition,
+          )
+
+          Some(
+            Types.Text({
+              content: textContent,
+              emphasis: true,
+              position: Types.Position.make(position.row, position.col),
+              align: align,
+            }),
+          )
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Create an EmphasisParser instance.
+ * Priority: 70
+ */
+let make = (): ElementParser.elementParser => {
+  ElementParser.make(~priority=70, ~canParse, ~parse)
+}

package/src/parser/Semantic/Elements/InputParser.mjs

@@ -0,0 +1,41 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Types from "../../Core/Types.mjs";
+import * as ElementParser from "./ElementParser.mjs";
+
+let inputPattern = /(?:^|[^#])#(\w+)\s*$/;
+
+function canParse(content) {
+  let trimmed = content.trim();
+  return inputPattern.test(trimmed);
+}
+
+function parse(content, position, _bounds) {
+  let trimmed = content.trim();
+  let result = inputPattern.exec(trimmed);
+  if (result == null) {
+    return;
+  }
+  let matches = result.slice(1);
+  let identifier = matches[0];
+  if (identifier !== undefined) {
+    return {
+      TAG: "Input",
+      id: identifier,
+      placeholder: undefined,
+      position: Types.Position.make(position.row, position.col)
+    };
+  }
+}
+
+function make() {
+  return ElementParser.make(90, canParse, parse);
+}
+
+export {
+  inputPattern,
+  canParse,
+  parse,
+  make,
+}
+/* Types Not a pure module */

package/src/parser/Semantic/Elements/InputParser.res

@@ -0,0 +1,97 @@
+// InputParser.res
+
+open Types
+// Parser for input field elements with syntax "#fieldname"
+//
+// Recognizes input fields denoted by a hash (#) followed by an identifier.
+// Example: "#email", "#password", "#username"
+
+/**
+ * Regular expression pattern for input field syntax.
+ * Matches: # followed by one or more word characters (letters, digits, underscores)
+ * The field must be at the end of the string (with optional trailing whitespace).
+ * Can appear anywhere in the line, optionally preceded by a label.
+ * Examples:
+ * - "#email" ✓
+ * - "#password123" ✓
+ * - "#user_name" ✓
+ * - "Email: #email" ✓ (with label prefix)
+ * - "Password: #password" ✓ (with label prefix)
+ * - "#first-name" ✗ (contains hyphen after word characters)
+ * - "#email.address" ✗ (dot not allowed)
+ * - "##email" ✗ (double hash not allowed)
+ * - "# email" ✗ (space after #)
+ */
+// Pattern: (start or non-#) + # + word chars + optional trailing whitespace + end
+let inputPattern = %re("/(?:^|[^#])#(\w+)\s*$/")
+
+/**
+ * Quick check if content matches input field pattern.
+ *
+ * @param content - Text content to check
+ * @return true if content contains # followed by word characters
+ */
+let canParse = (content: string): bool => {
+  let trimmed = content->String.trim
+
+  // Check if contains #\w+ pattern anywhere in the string
+  inputPattern->RegExp.test(trimmed)
+}
+
+/**
+ * Parse input field element from content.
+ *
+ * Extracts the field identifier after the # character and creates
+ * an Input element with that ID.
+ *
+ * @param content - Text content to parse (e.g., "#email")
+ * @param position - Grid position where input was found
+ * @param _bounds - Bounding box (not used for inputs, they are always left-aligned)
+ * @return Some(Input element) if parsing succeeds, None otherwise
+ */
+let parse = (
+  content: string,
+  position: Position.t,
+  _bounds: Bounds.t,
+): ElementParser.parseResult<Types.element> => {
+  let trimmed = content->String.trim
+
+  // Extract identifier after # character
+  switch inputPattern->RegExp.exec(trimmed) {
+  | Some(result) => {
+      // Get first capture group (the identifier after #)
+      // RegExp.Result.matches slices off the full match, so matches[0] is the first captured group
+      let matches = result->RegExp.Result.matches
+      switch matches[0] {
+      | Some(identifier) => {
+          // Successfully extracted identifier
+          Some(
+            Types.Input({
+              id: identifier,
+              placeholder: None,
+              position: Types.Position.make(position.row, position.col),
+            })
+          )
+        }
+      | None => None
+      }
+    }
+  | None => None
+  }
+}
+
+/**
+ * Create an InputParser instance with priority 90.
+ *
+ * Priority explanation:
+ * - 100: Buttons (highest priority)
+ * - 90: Inputs (this parser)
+ * - 80: Links
+ * - 70: Emphasis
+ * - 1: Text (fallback, lowest priority)
+ *
+ * @return ElementParser.elementParser configured for input fields
+ */
+let make = (): ElementParser.elementParser => {
+  ElementParser.make(~priority=90, ~canParse, ~parse)
+}

package/src/parser/Semantic/Elements/LinkParser.mjs

@@ -0,0 +1,60 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Types from "../../Core/Types.mjs";
+import * as ElementParser from "./ElementParser.mjs";
+
+let linkPattern = /"((?:[^"\\]|\\.)+)"/;
+
+let quickPattern = /"(?:[^"\\]|\\.)+"/;
+
+function slugify(text) {
+  return text.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+}
+
+function unescapeQuotes(text) {
+  return (text.replace(/\\"/g, '"'));
+}
+
+function canParse(content) {
+  return quickPattern.test(content);
+}
+
+function parse(content, position, _bounds) {
+  let result = linkPattern.exec(content);
+  if (result == null) {
+    return;
+  }
+  let matches = result.slice(1);
+  let linkText = matches[0];
+  if (linkText === undefined) {
+    return;
+  }
+  if (linkText.trim() === "") {
+    return;
+  }
+  let unescapedText = unescapeQuotes(linkText);
+  let linkId = slugify(unescapedText);
+  return {
+    TAG: "Link",
+    id: linkId,
+    text: unescapedText,
+    position: Types.Position.make(position.row, position.col),
+    align: "Left",
+    actions: []
+  };
+}
+
+function make() {
+  return ElementParser.make(80, canParse, parse);
+}
+
+export {
+  linkPattern,
+  quickPattern,
+  slugify,
+  unescapeQuotes,
+  canParse,
+  parse,
+  make,
+}
+/* Types Not a pure module */

package/src/parser/Semantic/Elements/LinkParser.res

@@ -0,0 +1,156 @@
+// LinkParser.res
+
+open Types
+// Parser for link syntax: "Link Text" (quoted text)
+//
+// Recognizes quoted text patterns and generates Link elements.
+// Priority: 80 (between inputs and checkboxes)
+
+/**
+ * Regular expression pattern for matching quoted text.
+ * Matches: "text content" where content can include escaped quotes (\")
+ *
+ * Pattern breakdown:
+ * - " : Opening quote
+ * - ((?:[^"\\]|\\.)+) : One or more of either:
+ *   - [^"\\] : any character except quote or backslash
+ *   - \\. : a backslash followed by any character (handles escaped quotes)
+ * - " : Closing quote
+ *
+ * Using %raw to avoid ReScript's regex escaping complexity
+ */
+let linkPattern: Js.Re.t = %raw(`/"((?:[^"\\]|\\.)+)"/`)
+
+/**
+ * Quick check pattern for canParse (faster, no capture groups)
+ * Handles escaped quotes within the quoted text
+ */
+let quickPattern: Js.Re.t = %raw(`/"(?:[^"\\]|\\.)+"/`)
+
+/**
+ * Convert text to a URL-friendly slug identifier.
+ *
+ * Rules:
+ * - Convert to lowercase
+ * - Replace spaces and special characters with hyphens
+ * - Remove consecutive hyphens
+ * - Trim leading/trailing hyphens
+ *
+ * Examples:
+ * - "Login Here" -> "login-here"
+ * - "Sign Up!" -> "sign-up"
+ * - "  Multiple   Spaces  " -> "multiple-spaces"
+ *
+ * @param text - The text to slugify
+ * @return URL-friendly identifier
+ */
+let slugify = (text: string): string => {
+  text
+  ->String.toLowerCase
+  ->String.trim
+  // Replace whitespace and special chars with hyphens
+  ->Js.String2.replaceByRe(%re("/[^a-z0-9]+/g"), "-")
+  // Remove consecutive hyphens
+  ->Js.String2.replaceByRe(%re("/-+/g"), "-")
+  // Trim hyphens from start and end
+  ->Js.String2.replaceByRe(%re("/^-+|-+$/g"), "")
+}
+
+/**
+ * Unescape quotes within the link text.
+ * Handles escaped quotes (\") within the text content.
+ *
+ * @param text - The extracted text with potential escape sequences
+ * @return Text with escape sequences resolved
+ */
+let unescapeQuotes = (text: string): string => {
+  // Match backslash followed by quote and replace with just quote
+  // Use raw JS to avoid ReScript escaping complexity
+  %raw(`text.replace(/\\"/g, '"')`)
+}
+
+/**
+ * Check if content matches the link pattern.
+ *
+ * This is a fast pattern check that doesn't extract data.
+ * Used by the parser registry to quickly determine if this parser should be tried.
+ *
+ * @param content - The content string to check
+ * @return true if content matches link syntax
+ */
+let canParse = (content: string): bool => {
+  quickPattern->Js.Re.test_(content)
+}
+
+/**
+ * Parse link content and generate a Link element.
+ *
+ * Extracts text between quotes and creates a Link element with:
+ * - id: Slugified version of the link text
+ * - text: The extracted link text
+ * - position: Grid position of the link
+ * - align: Left alignment (default for links)
+ *
+ * @param content - The content string to parse
+ * @param position - Position in the grid
+ * @param _bounds - Bounding box (unused for now, will be used for alignment calculation)
+ * @return Some(Link element) if parsing succeeds, None otherwise
+ */
+let parse = (
+  content: string,
+  position: Position.t,
+  _bounds: Bounds.t,
+): ElementParser.parseResult<Types.element> => {
+  switch linkPattern->RegExp.exec(content) {
+  | Some(result) => {
+      // RegExp.Result.matches slices off the full match, so matches[0] is the first captured group
+      let matches = result->RegExp.Result.matches
+
+      switch matches[0] {
+      | Some(linkText) => {
+          // linkText is already a string, no need for Nullable conversion
+
+          // Check for empty text
+          if linkText->String.trim === "" {
+            None
+          } else {
+            // Unescape any escaped quotes in the text
+            let unescapedText = unescapeQuotes(linkText)
+
+            // Generate ID from text
+            let linkId = slugify(unescapedText)
+
+            // Create Link element
+            // Note: Using Left alignment as default
+            // When AlignmentCalc is implemented, this will use calculated alignment
+            Some(
+              Types.Link({
+                id: linkId,
+                text: unescapedText,
+                position: Types.Position.make(position.row, position.col),
+                align: Left,
+                actions: [],
+              }),
+            )
+          }
+        }
+      | None => None
+      }
+    }
+  | None => None
+  }
+}
+
+/**
+ * Create a LinkParser instance with priority 80.
+ *
+ * Priority 80 places it:
+ * - After buttons (100) and inputs (90)
+ * - Before checkboxes (85) and emphasis (70)
+ * - Well before text fallback (1)
+ *
+ * @return ElementParser.t configured for link parsing
+ */
+let make = (): ElementParser.elementParser => {
+  ElementParser.make(~priority=80, ~canParse, ~parse)
+}

package/src/parser/Semantic/Elements/TextParser.mjs

@@ -0,0 +1,19 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Types from "../../Core/Types.mjs";
+import * as ElementParser from "./ElementParser.mjs";
+
+function make() {
+  return ElementParser.make(1, _content => true, (content, position, _bounds) => ({
+    TAG: "Text",
+    content: content,
+    emphasis: false,
+    position: Types.Position.make(position.row, position.col),
+    align: "Left"
+  }));
+}
+
+export {
+  make,
+}
+/* Types Not a pure module */

package/src/parser/Semantic/Elements/TextParser.res

@@ -0,0 +1,42 @@
+// TextParser.res
+// Fallback parser for plain text that doesn't match any other pattern
+//
+// This parser has the lowest priority (1) and always accepts content,
+// making it the last resort when no other parser matches.
+
+/**
+ * Create a TextParser instance.
+ *
+ * This is a fallback parser that catches all unrecognized content and
+ * treats it as plain text. It should be registered with the lowest priority
+ * in the ParserRegistry.
+ *
+ * Behavior:
+ * - canParse: Always returns true (catches everything)
+ * - parse: Generates a Text element with emphasis=false
+ * - Priority: 1 (lowest - used as fallback)
+ *
+ * @return An ElementParser instance configured as a text fallback parser
+ */
+let make = (): ElementParser.elementParser => {
+  ElementParser.make(
+    ~priority=1, // Lowest priority - fallback parser
+    ~canParse=_content => {
+      // Always returns true to catch any content that no other parser matched
+      true
+    },
+    ~parse=(content, position, _bounds) => {
+      // Generate a plain text element with the raw content
+      // Note: For fallback text, we use Left alignment by default
+      // This is simpler than calculating alignment for unstructured text
+      Some(
+        Types.Text({
+          content: content,
+          emphasis: false,
+          position: Types.Position.make(position.row, position.col),
+          align: Types.Left,
+        }),
+      )
+    },
+  )
+}