wyreframe 0.1.0 → 0.1.1

package/src/parser/Semantic/Elements/__tests__/CheckboxParser_test.res

@@ -1,250 +0,0 @@
-// CheckboxParser_test.res
-// Unit tests for checkbox element parser
-
-open Vitest
-
-describe("CheckboxParser", () => {
-  let parser = CheckboxParser.make()
-
-  describe("canParse", () => {
-    test("recognizes checked checkbox [x]", t => {
-      t->expect(parser.canParse("[x]"))->Expect.toBe(true)
-    })
-
-    test("recognizes checked checkbox with uppercase X", t => {
-      t->expect(parser.canParse("[X]"))->Expect.toBe(true)
-    })
-
-    test("recognizes unchecked checkbox [ ]", t => {
-      t->expect(parser.canParse("[ ]"))->Expect.toBe(true)
-    })
-
-    test("recognizes unchecked checkbox with multiple spaces", t => {
-      t->expect(parser.canParse("[   ]"))->Expect.toBe(true)
-    })
-
-    test("recognizes checkbox with label", t => {
-      t->expect(parser.canParse("[x] Accept terms"))->Expect.toBe(true)
-    })
-
-    test("recognizes checkbox with label at end", t => {
-      t->expect(parser.canParse("Accept terms [x]"))->Expect.toBe(true)
-    })
-
-    test("rejects plain text", t => {
-      t->expect(parser.canParse("plain text"))->Expect.toBe(false)
-    })
-
-    test("rejects button syntax", t => {
-      t->expect(parser.canParse("[ Button ]"))->Expect.toBe(false)
-    })
-
-    test("rejects input syntax", t => {
-      t->expect(parser.canParse("#email"))->Expect.toBe(false)
-    })
-
-    test("rejects incomplete brackets", t => {
-      t->expect(parser.canParse("[x"))->Expect.toBe(false)
-      t->expect(parser.canParse("x]"))->Expect.toBe(false)
-    })
-  })
-
-  describe("parse - checked state", () => {
-    let position = Types.Position.make(5, 10)
-    let bounds = Types.Bounds.make(~top=0, ~left=0, ~bottom=10, ~right=30)
-
-    test("extracts checked state from [x]", t => {
-      switch parser.parse("[x]", position, bounds) {
-      | Some(Checkbox({checked, label, position: pos})) => {
-          t->expect(checked)->Expect.toBe(true)
-          t->expect(label)->Expect.toBe("")
-          t->expect(pos.row)->Expect.toBe(5)
-          t->expect(pos.col)->Expect.toBe(10)
-        }
-      | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Checkbox element
-      }
-    })
-
-    test("handles uppercase X in [X]", t => {
-      switch parser.parse("[X]", position, bounds) {
-      | Some(Checkbox({checked})) => {
-          t->expect(checked)->Expect.toBe(true)
-        }
-      | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Checkbox element
-      }
-    })
-
-    test("extracts label after checked checkbox", t => {
-      switch parser.parse("[x] Accept terms and conditions", position, bounds) {
-      | Some(Checkbox({checked, label})) => {
-          t->expect(checked)->Expect.toBe(true)
-          t->expect(label)->Expect.toBe("Accept terms and conditions")
-        }
-      | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Checkbox element
-      }
-    })
-
-    test("trims whitespace from label", t => {
-      switch parser.parse("[x]   Subscribe to newsletter   ", position, bounds) {
-      | Some(Checkbox({label})) => {
-          t->expect(label)->Expect.toBe("Subscribe to newsletter")
-        }
-      | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Checkbox element
-      }
-    })
-
-    test("handles label with special characters", t => {
-      switch parser.parse("[x] I agree to the Terms & Conditions", position, bounds) {
-      | Some(Checkbox({label})) => {
-          t->expect(label)->Expect.toBe("I agree to the Terms & Conditions")
-        }
-      | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Checkbox element
-      }
-    })
-  })
-
-  describe("parse - unchecked state", () => {
-    let position = Types.Position.make(3, 5)
-    let bounds = Types.Bounds.make(~top=0, ~left=0, ~bottom=10, ~right=30)
-
-    test("extracts unchecked state from [ ]", t => {
-      switch parser.parse("[ ]", position, bounds) {
-      | Some(Checkbox({checked, label})) => {
-          t->expect(checked)->Expect.toBe(false)
-          t->expect(label)->Expect.toBe("")
-        }
-      | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Checkbox element
-      }
-    })
-
-    test("handles multiple spaces in brackets", t => {
-      switch parser.parse("[   ]", position, bounds) {
-      | Some(Checkbox({checked})) => {
-          t->expect(checked)->Expect.toBe(false)
-        }
-      | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Checkbox element
-      }
-    })
-
-    test("extracts label after unchecked checkbox", t => {
-      switch parser.parse("[ ] Remember me", position, bounds) {
-      | Some(Checkbox({checked, label})) => {
-          t->expect(checked)->Expect.toBe(false)
-          t->expect(label)->Expect.toBe("Remember me")
-        }
-      | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Checkbox element
-      }
-    })
-
-    test("handles long labels", t => {
-      switch parser.parse("[ ] I would like to receive promotional emails and updates", position, bounds) {
-      | Some(Checkbox({label})) => {
-          t->expect(label)->Expect.toBe("I would like to receive promotional emails and updates")
-        }
-      | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Checkbox element
-      }
-    })
-  })
-
-  describe("parse - edge cases", () => {
-    let position = Types.Position.make(0, 0)
-    let bounds = Types.Bounds.make(~top=0, ~left=0, ~bottom=5, ~right=20)
-
-    test("handles checkbox with no label", t => {
-      switch parser.parse("[x]", position, bounds) {
-      | Some(Checkbox({label})) => {
-          t->expect(label)->Expect.toBe("")
-        }
-      | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Checkbox element
-      }
-    })
-
-    test("handles extra whitespace before checkbox", t => {
-      switch parser.parse("   [x] Label", position, bounds) {
-      | Some(Checkbox({checked, label})) => {
-          t->expect(checked)->Expect.toBe(true)
-          t->expect(label)->Expect.toBe("Label")
-        }
-      | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Checkbox element
-      }
-    })
-
-    test("handles extra whitespace after label", t => {
-      switch parser.parse("[x] Label   ", position, bounds) {
-      | Some(Checkbox({label})) => {
-          t->expect(label)->Expect.toBe("Label")
-        }
-      | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Checkbox element
-      }
-    })
-
-    test("returns None for invalid pattern", t => {
-      let result = parser.parse("not a checkbox", position, bounds)
-      t->expect(result)->Expect.toBe(None)
-    })
-
-    test("returns None for button-like pattern [ Text ]", t => {
-      let result = parser.parse("[ Submit ]", position, bounds)
-      t->expect(result)->Expect.toBe(None)
-    })
-  })
-
-  describe("parse - label variations", () => {
-    let position = Types.Position.make(2, 3)
-    let bounds = Types.Bounds.make(~top=0, ~left=0, ~bottom=10, ~right=40)
-
-    test("handles label with numbers", t => {
-      switch parser.parse("[x] Option 123", position, bounds) {
-      | Some(Checkbox({label})) => {
-          t->expect(label)->Expect.toBe("Option 123")
-        }
-      | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Checkbox element
-      }
-    })
-
-    test("handles label with punctuation", t => {
-      switch parser.parse("[ ] Yes, I agree!", position, bounds) {
-      | Some(Checkbox({label})) => {
-          t->expect(label)->Expect.toBe("Yes, I agree!")
-        }
-      | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Checkbox element
-      }
-    })
-
-    test("handles label with parentheses", t => {
-      switch parser.parse("[x] Enable feature (beta)", position, bounds) {
-      | Some(Checkbox({label})) => {
-          t->expect(label)->Expect.toBe("Enable feature (beta)")
-        }
-      | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Checkbox element
-      }
-    })
-
-    test("handles label with quotes", t => {
-      switch parser.parse("[x] Accept \"User Agreement\"", position, bounds) {
-      | Some(Checkbox({label})) => {
-          t->expect(label)->Expect.toBe("Accept \"User Agreement\"")
-        }
-      | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Checkbox element
-      }
-    })
-  })
-
-  describe("priority", () => {
-    test("has priority of 85", t => {
-      t->expect(parser.priority)->Expect.toBe(85)
-    })
-
-    test("priority is higher than text parser (1)", t => {
-      t->expect(parser.priority)->Expect.Int.toBeGreaterThan(1)
-    })
-
-    test("priority is lower than button parser (100)", t => {
-      t->expect(parser.priority)->Expect.Int.toBeLessThan(100)
-    })
-
-    test("priority is lower than input parser (90)", t => {
-      t->expect(parser.priority)->Expect.Int.toBeLessThan(90)
-    })
-  })
-})

package/src/parser/Semantic/Elements/__tests__/CodeTextParser_manual.mjs

@@ -1,293 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Types from "../../../Core/Types.mjs";
-import * as CodeTextParser from "../CodeTextParser.mjs";
-
-function test_canParse_quotedText() {
-  if (CodeTextParser.canParse("'centered text'") === true) {
-    return;
-  }
-  throw {
-    RE_EXN_ID: "Assert_failure",
-    _1: [
-      "CodeTextParser_manual.res",
-      9,
-      2
-    ],
-    Error: new Error()
-  };
-}
-
-function test_canParse_withSpaces() {
-  if (CodeTextParser.canParse("  'code'  ") === true) {
-    return;
-  }
-  throw {
-    RE_EXN_ID: "Assert_failure",
-    _1: [
-      "CodeTextParser_manual.res",
-      15,
-      2
-    ],
-    Error: new Error()
-  };
-}
-
-function test_canParse_plainText() {
-  if (CodeTextParser.canParse("plain text") === false) {
-    return;
-  }
-  throw {
-    RE_EXN_ID: "Assert_failure",
-    _1: [
-      "CodeTextParser_manual.res",
-      21,
-      2
-    ],
-    Error: new Error()
-  };
-}
-
-function test_parse_extractText() {
-  let bounds = Types.Bounds.make(0, 0, 5, 30);
-  let position = Types.Position.make(1, 1);
-  let match = CodeTextParser.parse("'Submit'", position, bounds);
-  if (match !== undefined) {
-    if (match.TAG === "Text") {
-      if (match.content !== "Submit") {
-        throw {
-          RE_EXN_ID: "Assert_failure",
-          _1: [
-            "CodeTextParser_manual.res",
-            32,
-            6
-          ],
-          Error: new Error()
-        };
-      }
-      if (match.emphasis === true) {
-        return;
-      }
-      throw {
-        RE_EXN_ID: "Assert_failure",
-        _1: [
-          "CodeTextParser_manual.res",
-          33,
-          6
-        ],
-        Error: new Error()
-      };
-    }
-    throw {
-      RE_EXN_ID: "Assert_failure",
-      _1: [
-        "CodeTextParser_manual.res",
-        35,
-        9
-      ],
-      Error: new Error()
-    };
-  }
-  throw {
-    RE_EXN_ID: "Assert_failure",
-    _1: [
-      "CodeTextParser_manual.res",
-      35,
-      9
-    ],
-    Error: new Error()
-  };
-}
-
-function test_parse_centerAlignment() {
-  let bounds = Types.Bounds.make(0, 0, 5, 30);
-  let position = Types.Position.make(1, 12);
-  let match = CodeTextParser.parse("'Centered'", position, bounds);
-  if (match !== undefined) {
-    if (match.TAG === "Text") {
-      if (match.align === "Center") {
-        return;
-      }
-      throw {
-        RE_EXN_ID: "Assert_failure",
-        _1: [
-          "CodeTextParser_manual.res",
-          47,
-          6
-        ],
-        Error: new Error()
-      };
-    }
-    throw {
-      RE_EXN_ID: "Assert_failure",
-      _1: [
-        "CodeTextParser_manual.res",
-        49,
-        9
-      ],
-      Error: new Error()
-    };
-  }
-  throw {
-    RE_EXN_ID: "Assert_failure",
-    _1: [
-      "CodeTextParser_manual.res",
-      49,
-      9
-    ],
-    Error: new Error()
-  };
-}
-
-function test_parse_leftAlignment() {
-  let bounds = Types.Bounds.make(0, 0, 5, 30);
-  let position = Types.Position.make(1, 1);
-  let match = CodeTextParser.parse("'Left'", position, bounds);
-  if (match !== undefined) {
-    if (match.TAG === "Text") {
-      if (match.align === "Left") {
-        return;
-      }
-      throw {
-        RE_EXN_ID: "Assert_failure",
-        _1: [
-          "CodeTextParser_manual.res",
-          61,
-          6
-        ],
-        Error: new Error()
-      };
-    }
-    throw {
-      RE_EXN_ID: "Assert_failure",
-      _1: [
-        "CodeTextParser_manual.res",
-        63,
-        9
-      ],
-      Error: new Error()
-    };
-  }
-  throw {
-    RE_EXN_ID: "Assert_failure",
-    _1: [
-      "CodeTextParser_manual.res",
-      63,
-      9
-    ],
-    Error: new Error()
-  };
-}
-
-function test_parse_rightAlignment() {
-  let bounds = Types.Bounds.make(0, 0, 5, 30);
-  let position = Types.Position.make(1, 24);
-  let match = CodeTextParser.parse("'Right'", position, bounds);
-  if (match !== undefined) {
-    if (match.TAG === "Text") {
-      if (match.align === "Right") {
-        return;
-      }
-      throw {
-        RE_EXN_ID: "Assert_failure",
-        _1: [
-          "CodeTextParser_manual.res",
-          75,
-          6
-        ],
-        Error: new Error()
-      };
-    }
-    throw {
-      RE_EXN_ID: "Assert_failure",
-      _1: [
-        "CodeTextParser_manual.res",
-        77,
-        9
-      ],
-      Error: new Error()
-    };
-  }
-  throw {
-    RE_EXN_ID: "Assert_failure",
-    _1: [
-      "CodeTextParser_manual.res",
-      77,
-      9
-    ],
-    Error: new Error()
-  };
-}
-
-function test_parse_emptyContent() {
-  let bounds = Types.Bounds.make(0, 0, 5, 30);
-  let position = Types.Position.make(1, 1);
-  let match = CodeTextParser.parse("'   '", position, bounds);
-  if (match === undefined) {
-    return;
-  }
-  throw {
-    RE_EXN_ID: "Assert_failure",
-    _1: [
-      "CodeTextParser_manual.res",
-      89,
-      15
-    ],
-    Error: new Error()
-  };
-}
-
-function test_make_priority() {
-  let parser = CodeTextParser.make();
-  if (parser.priority === 75) {
-    return;
-  }
-  throw {
-    RE_EXN_ID: "Assert_failure",
-    _1: [
-      "CodeTextParser_manual.res",
-      96,
-      2
-    ],
-    Error: new Error()
-  };
-}
-
-function runTests() {
-  console.log("Running CodeTextParser tests...");
-  test_canParse_quotedText();
-  console.log("  test_canParse_quotedText passed");
-  test_canParse_withSpaces();
-  console.log("  test_canParse_withSpaces passed");
-  test_canParse_plainText();
-  console.log("  test_canParse_plainText passed");
-  test_parse_extractText();
-  console.log("  test_parse_extractText passed");
-  test_parse_centerAlignment();
-  console.log("  test_parse_centerAlignment passed");
-  test_parse_leftAlignment();
-  console.log("  test_parse_leftAlignment passed");
-  test_parse_rightAlignment();
-  console.log("  test_parse_rightAlignment passed");
-  test_parse_emptyContent();
-  console.log("  test_parse_emptyContent passed");
-  test_make_priority();
-  console.log("  test_make_priority passed");
-  console.log("All CodeTextParser tests passed!");
-}
-
-runTests();
-
-export {
-  test_canParse_quotedText,
-  test_canParse_withSpaces,
-  test_canParse_plainText,
-  test_parse_extractText,
-  test_parse_centerAlignment,
-  test_parse_leftAlignment,
-  test_parse_rightAlignment,
-  test_parse_emptyContent,
-  test_make_priority,
-  runTests,
-}
-/*  Not a pure module */

package/src/parser/Semantic/Elements/__tests__/CodeTextParser_manual.res

@@ -1,134 +0,0 @@
-// CodeTextParser_test.res
-// Tests for single-quote-wrapped text parser with position-based alignment
-
-open Types
-
-// Test: should recognize single-quote-wrapped text
-let test_canParse_quotedText = () => {
-  let content = "'centered text'"
-  assert(CodeTextParser.canParse(content) === true)
-}
-
-// Test: should recognize quoted text with spaces
-let test_canParse_withSpaces = () => {
-  let content = "  'code'  "
-  assert(CodeTextParser.canParse(content) === true)
-}
-
-// Test: should not recognize plain text
-let test_canParse_plainText = () => {
-  let content = "plain text"
-  assert(CodeTextParser.canParse(content) === false)
-}
-
-// Test: should extract text from quotes
-let test_parse_extractText = () => {
-  let bounds = Bounds.make(~top=0, ~left=0, ~bottom=5, ~right=30)
-  let content = "'Submit'"
-  let position = Position.make(1, 1)
-
-  switch CodeTextParser.parse(content, position, bounds) {
-  | Some(Text({content, emphasis, _})) => {
-      assert(content === "Submit")
-      assert(emphasis === true)
-    }
-  | _ => assert(false)
-  }
-}
-
-// Test: should calculate center alignment for centered content
-let test_parse_centerAlignment = () => {
-  let bounds = Bounds.make(~top=0, ~left=0, ~bottom=5, ~right=30)
-  let content = "'Centered'"
-  let position = Position.make(1, 12) // Roughly centered
-
-  switch CodeTextParser.parse(content, position, bounds) {
-  | Some(Text({align, _})) => {
-      assert(align === Center)
-    }
-  | _ => assert(false)
-  }
-}
-
-// Test: should calculate left alignment for left-positioned content
-let test_parse_leftAlignment = () => {
-  let bounds = Bounds.make(~top=0, ~left=0, ~bottom=5, ~right=30)
-  let content = "'Left'"
-  let position = Position.make(1, 1) // Near left edge
-
-  switch CodeTextParser.parse(content, position, bounds) {
-  | Some(Text({align, _})) => {
-      assert(align === Left)
-    }
-  | _ => assert(false)
-  }
-}
-
-// Test: should calculate right alignment for right-positioned content
-let test_parse_rightAlignment = () => {
-  let bounds = Bounds.make(~top=0, ~left=0, ~bottom=5, ~right=30)
-  let content = "'Right'"
-  let position = Position.make(1, 24) // Near right edge
-
-  switch CodeTextParser.parse(content, position, bounds) {
-  | Some(Text({align, _})) => {
-      assert(align === Right)
-    }
-  | _ => assert(false)
-  }
-}
-
-// Test: should return None for empty quoted content
-let test_parse_emptyContent = () => {
-  let bounds = Bounds.make(~top=0, ~left=0, ~bottom=5, ~right=30)
-  let content = "'   '"
-  let position = Position.make(1, 1)
-
-  switch CodeTextParser.parse(content, position, bounds) {
-  | None => assert(true)
-  | Some(_) => assert(false)
-  }
-}
-
-// Test: parser should have priority 75
-let test_make_priority = () => {
-  let parser = CodeTextParser.make()
-  assert(parser.priority === 75)
-}
-
-// Run all tests
-let runTests = () => {
-  Console.log("Running CodeTextParser tests...")
-
-  test_canParse_quotedText()
-  Console.log("  test_canParse_quotedText passed")
-
-  test_canParse_withSpaces()
-  Console.log("  test_canParse_withSpaces passed")
-
-  test_canParse_plainText()
-  Console.log("  test_canParse_plainText passed")
-
-  test_parse_extractText()
-  Console.log("  test_parse_extractText passed")
-
-  test_parse_centerAlignment()
-  Console.log("  test_parse_centerAlignment passed")
-
-  test_parse_leftAlignment()
-  Console.log("  test_parse_leftAlignment passed")
-
-  test_parse_rightAlignment()
-  Console.log("  test_parse_rightAlignment passed")
-
-  test_parse_emptyContent()
-  Console.log("  test_parse_emptyContent passed")
-
-  test_make_priority()
-  Console.log("  test_make_priority passed")
-
-  Console.log("All CodeTextParser tests passed!")
-}
-
-// Auto-run tests
-let _ = runTests()