wyreframe 0.1.0 → 0.1.1

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

@@ -1,167 +0,0 @@
-// TextParser_test.res
-// Unit tests for the TextParser fallback module
-
-open Vitest
-
-// Create a test parser instance
-let parser = TextParser.make()
-
-// Helper to create a test position
-let makePosition = (row: int, col: int): Types.Position.t => Types.Position.make(row, col)
-
-// Helper to create test bounds
-let makeBounds = (~top: int, ~left: int, ~bottom: int, ~right: int): Types.Bounds.t => {
-  top: top,
-  left: left,
-  bottom: bottom,
-  right: right,
-}
-
-describe("TextParser", () => {
-  describe("priority", () => {
-    test("should have lowest priority (1)", t => {
-      t->expect(parser.priority)->Expect.toBe(1)
-    })
-  })
-
-  describe("canParse", () => {
-    test("should always return true for any content", t => {
-      t->expect(parser.canParse("hello world"))->Expect.toBe(true)
-    })
-
-    test("should return true for empty string", t => {
-      t->expect(parser.canParse(""))->Expect.toBe(true)
-    })
-
-    test("should return true for special characters", t => {
-      t->expect(parser.canParse("!@#$%^&*()"))->Expect.toBe(true)
-    })
-
-    test("should return true for numbers", t => {
-      t->expect(parser.canParse("12345"))->Expect.toBe(true)
-    })
-
-    test("should return true for content that looks like other elements", t => {
-      // Even if content matches other patterns, TextParser accepts it
-      // (though it would normally be caught by higher-priority parsers first)
-      t->expect(parser.canParse("[ Button ]"))->Expect.toBe(true)
-      t->expect(parser.canParse("#input"))->Expect.toBe(true)
-      t->expect(parser.canParse("\"Link\""))->Expect.toBe(true)
-      t->expect(parser.canParse("[x] Checkbox"))->Expect.toBe(true)
-      t->expect(parser.canParse("* Emphasis"))->Expect.toBe(true)
-    })
-
-    test("should return true for whitespace-only content", t => {
-      t->expect(parser.canParse("   "))->Expect.toBe(true)
-      t->expect(parser.canParse("\t"))->Expect.toBe(true)
-    })
-  })
-
-  describe("parse", () => {
-    let pos = makePosition(5, 10)
-    let bounds = makeBounds(~top=0, ~left=0, ~bottom=10, ~right=20)
-
-    test("should parse plain text content", t => {
-      let result = parser.parse("Hello World", pos, bounds)
-
-      switch result {
-      | Some(Types.Text({content, emphasis, position, align})) => {
-          t->expect(content)->Expect.toBe("Hello World")
-          t->expect(emphasis)->Expect.toBe(false)
-          t->expect(position)->Expect.toEqual(pos)
-          t->expect(align)->Expect.toBe(Types.Left)
-        }
-      | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Text element
-      }
-    })
-
-    test("should set emphasis to false by default", t => {
-      let result = parser.parse("Some text", pos, bounds)
-
-      switch result {
-      | Some(Types.Text({emphasis})) => t->expect(emphasis)->Expect.toBe(false)
-      | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Text element
-      }
-    })
-
-    test("should preserve the exact content without modification", t => {
-      let testCases = [
-        "plain text",
-        "  whitespace preserved  ",
-        "UPPERCASE",
-        "123numbers",
-        "special!@#chars",
-        "",
-      ]
-
-      testCases->Array.forEach(content => {
-        let result = parser.parse(content, pos, bounds)
-
-        switch result {
-        | Some(Types.Text({content: parsed})) =>
-          t->expect(parsed)->Expect.toBe(content)
-        | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Text element
-        }
-      })
-    })
-
-    test("should capture unrecognized patterns", t => {
-      // These patterns don't match standard element syntax
-      let unrecognizedPatterns = [
-        "This is just text",
-        "No special syntax here",
-        "Random content 123",
-        "Unmatched [ bracket",
-        "Partial #",
-        "Quote without end\"",
-      ]
-
-      unrecognizedPatterns->Array.forEach(content => {
-        let result = parser.parse(content, pos, bounds)
-
-        switch result {
-        | Some(Types.Text(_)) => () // Success - pattern matched
-        | _ => t->expect(true)->Expect.toBe(false) // fail: Should parse unrecognized pattern
-        }
-      })
-    })
-
-    test("should use provided position", t => {
-      let customPos = makePosition(42, 17)
-      let result = parser.parse("test", customPos, bounds)
-
-      switch result {
-      | Some(Types.Text({position})) => {
-          t->expect(position.row)->Expect.toBe(42)
-          t->expect(position.col)->Expect.toBe(17)
-        }
-      | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Text element
-      }
-    })
-
-    test("should always use Left alignment for fallback text", t => {
-      // TextParser uses Left alignment by default for simplicity
-      // More sophisticated alignment is handled by specific parsers
-      let result = parser.parse("centered text", pos, bounds)
-
-      switch result {
-      | Some(Types.Text({align})) => t->expect(align)->Expect.toBe(Types.Left)
-      | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Text element
-      }
-    })
-  })
-
-  describe("integration with ParserRegistry", () => {
-    test("should act as fallback when no other parser matches", t => {
-      // Simulate content that no specific parser would recognize
-      let unknownContent = "This is completely unstructured text"
-      let result = parser.parse(unknownContent, makePosition(0, 0), makeBounds(~top=0, ~left=0, ~bottom=10, ~right=50))
-
-      switch result {
-      | Some(Types.Text({content})) =>
-        t->expect(content)->Expect.toBe(unknownContent)
-      | _ => t->expect(true)->Expect.toBe(false) // fail: TextParser should catch unrecognized content
-      }
-    })
-  })
-})

package/src/parser/Semantic/__tests__/ASTBuilder_test.mjs

@@ -1,187 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Types from "../../Core/Types.mjs";
-import * as Vitest from "rescript-vitest/src/Vitest.mjs";
-import * as ASTBuilder from "../ASTBuilder.mjs";
-
-Vitest.describe("ASTBuilder", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
-  Vitest.describe("buildScene", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
-    Vitest.test("builds scene with all fields provided", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
-      let config_title = "Login Page";
-      let config_transition = "slide";
-      let config_device = "Desktop";
-      let config_elements = [];
-      let config_position = Types.Position.make(1, 0);
-      let config = {
-        id: "login",
-        title: config_title,
-        transition: config_transition,
-        device: config_device,
-        elements: config_elements,
-        position: config_position
-      };
-      let result = ASTBuilder.buildScene(config);
-      if (result.TAG !== "Ok") {
-        return t.expect(true).toBe(false);
-      }
-      let scene = result._0;
-      t.expect(scene.id).toBe("login");
-      t.expect(scene.title).toBe("Login Page");
-      t.expect(scene.transition).toBe("slide");
-      t.expect(scene.elements.length).toBe(0);
-    });
-    Vitest.test("derives title from ID when title not provided", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
-      let config_device = "Desktop";
-      let config_elements = [];
-      let config_position = Types.Position.make(1, 0);
-      let config = {
-        id: "login-page",
-        title: undefined,
-        transition: undefined,
-        device: config_device,
-        elements: config_elements,
-        position: config_position
-      };
-      let result = ASTBuilder.buildScene(config);
-      if (result.TAG !== "Ok") {
-        return t.expect(true).toBe(false);
-      }
-      let scene = result._0;
-      t.expect(scene.id).toBe("login-page");
-      t.expect(scene.title).toBe("Login Page");
-    });
-    Vitest.test("uses default transition when not provided", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
-      let config_title = "Home";
-      let config_device = "Desktop";
-      let config_elements = [];
-      let config_position = Types.Position.make(1, 0);
-      let config = {
-        id: "home",
-        title: config_title,
-        transition: undefined,
-        device: config_device,
-        elements: config_elements,
-        position: config_position
-      };
-      let result = ASTBuilder.buildScene(config);
-      if (result.TAG === "Ok") {
-        return t.expect(result._0.transition).toBe("none");
-      } else {
-        return t.expect(true).toBe(false);
-      }
-    });
-    Vitest.test("rejects empty scene ID", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
-      let config_title = "Empty ID";
-      let config_device = "Desktop";
-      let config_elements = [];
-      let config_position = Types.Position.make(1, 0);
-      let config = {
-        id: "",
-        title: config_title,
-        transition: undefined,
-        device: config_device,
-        elements: config_elements,
-        position: config_position
-      };
-      let result = ASTBuilder.buildScene(config);
-      if (result.TAG === "Ok") {
-        return t.expect(true).toBe(false);
-      }
-      switch (result._0.TAG) {
-        case "EmptySceneId" :
-          return;
-        case "DuplicateSceneId" :
-        case "InvalidSceneStructure" :
-          return t.expect(true).toBe(false);
-      }
-    });
-  });
-  Vitest.describe("buildAST", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
-    Vitest.test("builds AST with single scene", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
-      let configs = [{
-          id: "home",
-          title: "Home",
-          transition: "fade",
-          device: "Desktop",
-          elements: [],
-          position: Types.Position.make(1, 0)
-        }];
-      let result = ASTBuilder.buildAST(configs);
-      if (result.TAG === "Ok") {
-        return t.expect(result._0.scenes.length).toBe(1);
-      } else {
-        return t.expect(true).toBe(false);
-      }
-    });
-    Vitest.test("detects duplicate scene IDs", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
-      let configs = [
-        {
-          id: "home",
-          title: "Home",
-          transition: undefined,
-          device: "Desktop",
-          elements: [],
-          position: Types.Position.make(1, 0)
-        },
-        {
-          id: "home",
-          title: "Home Again",
-          transition: undefined,
-          device: "Desktop",
-          elements: [],
-          position: Types.Position.make(20, 0)
-        }
-      ];
-      let result = ASTBuilder.buildAST(configs);
-      if (result.TAG === "Ok") {
-        return t.expect(true).toBe(false);
-      } else {
-        return t.expect(result._0.length).toBeGreaterThan(0);
-      }
-    });
-  });
-  Vitest.describe("helper functions", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
-    let testAST = {
-      scenes: [
-        {
-          id: "home",
-          title: "Home",
-          transition: "none",
-          device: "Desktop",
-          elements: []
-        },
-        {
-          id: "about",
-          title: "About",
-          transition: "fade",
-          device: "Desktop",
-          elements: []
-        }
-      ]
-    };
-    Vitest.test("getSceneById finds existing scene", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
-      let scene = ASTBuilder.getSceneById(testAST, "about");
-      if (scene !== undefined) {
-        t.expect(scene.id).toBe("about");
-        return t.expect(scene.title).toBe("About");
-      } else {
-        return t.expect(true).toBe(false);
-      }
-    });
-    Vitest.test("hasScene returns true for existing scene", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
-      let exists = ASTBuilder.hasScene(testAST, "home");
-      t.expect(exists).toBe(true);
-    });
-    Vitest.test("getSceneIds returns all scene IDs", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
-      let ids = ASTBuilder.getSceneIds(testAST);
-      t.expect(ids.length).toBe(2);
-    });
-  });
-});
-
-let pass;
-
-export {
-  pass,
-}
-/*  Not a pure module */

package/src/parser/Semantic/__tests__/ASTBuilder_test.res

@@ -1,192 +0,0 @@
-// ASTBuilder_test.res
-// Unit tests for AST Builder module
-
-open Vitest
-
-let pass = ()
-
-describe("ASTBuilder", t => {
-  describe("buildScene", t => {
-    test("builds scene with all fields provided", t => {
-      let config = {
-        ASTBuilder.id: "login",
-        title: Some("Login Page"),
-        transition: Some("slide"),
-        elements: [],
-        position: Types.Position.make(1, 0),
-        device: Some(Types.Desktop),
-      }
-
-      let result = ASTBuilder.buildScene(config)
-
-      switch result {
-      | Ok(scene) => {
-          t->expect(scene.id)->Expect.toBe("login")
-          t->expect(scene.title)->Expect.toBe("Login Page")
-          t->expect(scene.transition)->Expect.toBe("slide")
-          t->expect(Array.length(scene.elements))->Expect.toBe(0)
-        }
-      | Error(_) => t->expect(true)->Expect.toBe(false) // fail: Expected successful scene build
-      }
-    })
-
-    test("derives title from ID when title not provided", t => {
-      let config = {
-        ASTBuilder.id: "login-page",
-        title: None,
-        transition: None,
-        elements: [],
-        position: Types.Position.make(1, 0),
-        device: Some(Types.Desktop),
-      }
-
-      let result = ASTBuilder.buildScene(config)
-
-      switch result {
-      | Ok(scene) => {
-          t->expect(scene.id)->Expect.toBe("login-page")
-          t->expect(scene.title)->Expect.toBe("Login Page")
-        }
-      | Error(_) => t->expect(true)->Expect.toBe(false) // fail: Expected successful scene build
-      }
-    })
-
-    test("uses default transition when not provided", t => {
-      let config = {
-        ASTBuilder.id: "home",
-        title: Some("Home"),
-        transition: None,
-        elements: [],
-        position: Types.Position.make(1, 0),
-        device: Some(Types.Desktop),
-      }
-
-      let result = ASTBuilder.buildScene(config)
-
-      switch result {
-      | Ok(scene) => {
-          t->expect(scene.transition)->Expect.toBe("none")
-        }
-      | Error(_) => t->expect(true)->Expect.toBe(false) // fail: Expected successful scene build
-      }
-    })
-
-    test("rejects empty scene ID", t => {
-      let config = {
-        ASTBuilder.id: "",
-        title: Some("Empty ID"),
-        transition: None,
-        elements: [],
-        position: Types.Position.make(1, 0),
-        device: Some(Types.Desktop),
-      }
-
-      let result = ASTBuilder.buildScene(config)
-
-      switch result {
-      | Ok(_) => t->expect(true)->Expect.toBe(false) // fail: Expected error for empty scene ID
-      | Error(ASTBuilder.EmptySceneId(_)) => pass
-      | Error(_) => t->expect(true)->Expect.toBe(false) // fail: Expected EmptySceneId error
-      }
-    })
-  })
-
-  describe("buildAST", t => {
-    test("builds AST with single scene", t => {
-      let configs = [
-        {
-          ASTBuilder.id: "home",
-          title: Some("Home"),
-          transition: Some("fade"),
-          elements: [],
-          position: Types.Position.make(1, 0),
-          device: Some(Types.Desktop),
-        },
-      ]
-
-      let result = ASTBuilder.buildAST(configs)
-
-      switch result {
-      | Ok(ast) => {
-          t->expect(Array.length(ast.scenes))->Expect.toBe(1)
-        }
-      | Error(_) => t->expect(true)->Expect.toBe(false) // fail: Expected successful AST build
-      }
-    })
-
-    test("detects duplicate scene IDs", t => {
-      let configs = [
-        {
-          ASTBuilder.id: "home",
-          title: Some("Home"),
-          transition: None,
-          elements: [],
-          position: Types.Position.make(1, 0),
-          device: Some(Types.Desktop),
-        },
-        {
-          ASTBuilder.id: "home",
-          title: Some("Home Again"),
-          transition: None,
-          elements: [],
-          position: Types.Position.make(20, 0),
-          device: Some(Types.Desktop),
-        },
-      ]
-
-      let result = ASTBuilder.buildAST(configs)
-
-      switch result {
-      | Ok(_) => t->expect(true)->Expect.toBe(false) // fail: Expected error for duplicate scene IDs
-      | Error(errors) => {
-          t->expect(Array.length(errors))->Expect.Int.toBeGreaterThan(0)
-        }
-      }
-    })
-  })
-
-  describe("helper functions", t => {
-    let testAST = {
-      Types.scenes: [
-        {
-          id: "home",
-          title: "Home",
-          transition: "none",
-          device: Types.Desktop,
-          elements: [],
-        },
-        {
-          id: "about",
-          title: "About",
-          transition: "fade",
-          device: Types.Desktop,
-          elements: [],
-        },
-      ],
-    }
-
-    test("getSceneById finds existing scene", t => {
-      let scene = ASTBuilder.getSceneById(testAST, "about")
-
-      switch scene {
-      | Some(s) => {
-          t->expect(s.id)->Expect.toBe("about")
-          t->expect(s.title)->Expect.toBe("About")
-        }
-      | None => t->expect(true)->Expect.toBe(false) // fail: Expected to find scene
-      }
-    })
-
-    test("hasScene returns true for existing scene", t => {
-      let exists = ASTBuilder.hasScene(testAST, "home")
-
-      t->expect(exists)->Expect.toBe(true)
-    })
-
-    test("getSceneIds returns all scene IDs", t => {
-      let ids = ASTBuilder.getSceneIds(testAST)
-
-      t->expect(Array.length(ids))->Expect.toBe(2)
-    })
-  })
-})