@nan0web/ui 1.0.0 → 1.0.2

package/src/Frame/Frame.test.js

@@ -1,429 +0,0 @@
-import { describe, it } from "node:test"
-import { strict as assert } from "node:assert"
-import { empty, notEmpty } from "@nan0web/types"
-import Frame from "./Frame.js"
-import stringWidth from "string-width"
-
-describe("Frame", () => {
-	it("should create empty Frame", () => {
-		const frame = new Frame()
-		assert.ok(empty(frame))
-	})
-	it("should create non-empty Frame", () => {
-		const frame = Frame.from(["Non", "empty"])
-		assert.ok(notEmpty(frame))
-	})
-	it("should print empty zero and false", () => {
-		const input = [
-			[0, "0", false, "false"],
-			[undefined, null, "", {}]
-		]
-		const frame = new Frame({ value: input, width: 144, height: 33 })
-		assert.ok(notEmpty(frame))
-		const rows = input.map(row => row.map(String))
-		assert.deepStrictEqual(frame.value, rows)
-		frame.render()
-		assert.equal(
-			frame.imprint,
-			rows.map(
-				row => row.join("")
-			).map(
-				row => row + " ".repeat(144 - stringWidth(row))
-			).join("\n")
-		)
-	})
-	it("should print welcome", () => {
-		const input = [
-			["Welcome", " ", "World", "!"],
-			["What can we do today great?"],
-		]
-		const rows = input.map(
-			row => row.join("")
-		).map(
-			row => row + " ".repeat(144 - stringWidth(row))
-		)
-		const frame = new Frame({ value: input, width: 144, height: 33 })
-		frame.render()
-		assert.equal(frame.imprint, rows.join("\n"))
-	})
-	it("should transform value", () => {
-		const frame = Frame.from(["Welcome"])
-		const t = v => "Вітання"
-		const transformed = frame.transform(t)
-		assert.deepStrictEqual(transformed.value, [["Вітання"]])
-	})
-	it("should print special utf characters and fit the width", () => {
-		const input = [
-			["你好", "世界"],
-			["Привіт", "Світ"],
-			["こんにちは", "世界"],
-		]
-		const frame = Frame.from(input)
-		frame.render()
-		const imprintLines = frame.imprint.split("\n")
-		imprintLines.forEach(line => {
-			assert.ok(stringWidth(line) <= 144)
-		})
-		assert.deepStrictEqual(frame.value, input)
-	})
-	it("should render table with padding", () => {
-		const rows = [
-			["gpt-4.1", 1_047_576],
-			["gpt-4o", 128_000],
-		]
-		const table = Frame.table({ padding: 3 })(rows)
-		assert.deepStrictEqual(table, [
-			["gpt-4.1   ", "1047576"],
-			["gpt-4o    ", "128000"],
-		])
-	})
-	it("should render with replace method and fill spaces", () => {
-		const input = [["Test"]]
-		const frame = new Frame({ value: input, width: 10, height: 3 })
-		const output = frame.render({ method: Frame.RenderMethod.REPLACE }).split("\n")
-		assert.equal(output.length, 3)
-		assert.equal(output[0].length - `\x1b[0;0H`.length, 10)
-		assert.equal(output[1].length, 10)
-		assert.equal(output[2].length, 10)
-	})
-	it("should render with append method over previous frame", () => {
-		const input = [["Append"]]
-		const frame = new Frame({ value: input, width: 10, height: 3 })
-		const output = frame.render({ method: "append" }).split("\n")
-		assert.ok(output.length <= 3)
-		assert.ok(output[0].length <= 10)
-	})
-	it("should render visible method", () => {
-		const input = [["Visible"]]
-		const frame = new Frame({ value: input, width: 10, height: 3 })
-		const output = frame.render({ method: "visible" }).split("\n")
-		assert.ok(output.length <= 3)
-	})
-	it("should handle cell options with style objects", () => {
-		const input = [
-			["<b>Hello</b>", "<i>World</i>"],
-			["<fg=red>Red</>", "<bg=#00ff00>Green background</>"]
-		]
-		const frame = new Frame({ value: input, width: 20, height: 4 })
-		const output = frame.render()
-		assert.ok(output.split("\n").length <= 4)
-	})
-	it("should handle row options with style objects", () => {
-		const input = [
-			["Name", "Age"],
-			["John", 30],
-			["<u>Underlined</u>", "<s>Strikethrough</s>", { color: "blue" }]
-		]
-		const frame = new Frame({ value: input, width: 30, height: 4 })
-		const output = frame.render()
-		assert.ok(output.split("\n").length <= 4)
-	})
-	it("should handle frame options set by method with XML tags", () => {
-		const input = [
-			["<b>Bold</b>", "<i>Italic</i>"],
-			["<fg=red>Red</fg>", "<bg=#0000ff>Blue bg</bg>"]
-		]
-		const frame = new Frame({ value: input, width: 20, height: 4 })
-		const output = frame.render()
-		assert.ok(output.split("\n").length <= 4)
-	})
-
-	it("should render correctly with different window sizes", () => {
-		const input = [
-			["Line 1: Hello World!"],
-			["Line 2: Another line"],
-			["Line 3: Yet another line"],
-			["Line 4: More text here"],
-			["Line 5: Last line"]
-		]
-
-		const sizes = [
-			{ width: 10, height: 2 },
-			{ width: 20, height: 3 },
-			{ width: 50, height: 5 },
-			{ width: 144, height: 33 },
-		]
-
-		sizes.forEach(({ width, height }) => {
-			const frame = new Frame({ value: input, width, height })
-			const output = frame.render({ method: Frame.RenderMethod.APPEND })
-			const lines = output.split("\n")
-			assert.ok(lines.length <= height)
-			lines.forEach(line => {
-				assert.ok(stringWidth(line) <= width)
-			})
-		})
-	})
-
-	// Additional tests for BOF, BOL in different positions with REPLACE, VISIBLE, APPEND
-
-	it("should handle BOF at start with REPLACE method", () => {
-		const input = [
-			Frame.BOF,
-			["Line 1"],
-			["Line 2"]
-		]
-		const frame = new Frame({ value: input, width: 10, height: 4 })
-		const output = frame.render({ method: Frame.RenderMethod.REPLACE })
-		assert.ok(output.startsWith(Frame.BOF))
-		const lines = output.split("\n")
-		assert.equal(lines.length, 4)
-		assert.match(lines[1], /^\s*$/) // empty row
-		assert.deepStrictEqual(lines.slice(-2), ["Line 1    ", "Line 2    "])
-	})
-
-	it("should handle BOF at end with REPLACE method", () => {
-		const input = [
-			["Line 1"],
-			["Line 2"],
-			Frame.BOF
-		]
-		const frame = new Frame({ value: input, width: 10, height: 4 })
-		const output = frame.render({ method: Frame.RenderMethod.REPLACE })
-		assert.ok(output.endsWith(Frame.BOF))
-		const lines = output.split("\n")
-		assert.equal(lines.length, 4)
-		assert.deepStrictEqual(lines.slice(0, 2), [
-			"Line 1    ",
-			"Line 2    "
-		])
-		assert.match(lines[2], /^\s*$/) // empty row
-	})
-
-	it("should handle BOF at start with APPEND method", () => {
-		const input = [
-			Frame.BOF,
-			["Line 1"],
-			["Line 2"]
-		]
-		const frame = new Frame({ value: input, width: 10, height: 4 })
-		const output = frame.render({ method: Frame.RenderMethod.APPEND })
-		assert.ok(output.startsWith(Frame.BOF))
-		const lines = output.split("\n")
-		assert.ok(lines.length <= 4)
-		assert.deepStrictEqual(lines.slice(-2), ["Line 1    ", "Line 2    "])
-	})
-
-	it("should handle BOF at end with APPEND method", () => {
-		const input = [
-			["Line 1"],
-			["Line 2"],
-			Frame.BOF
-		]
-		const frame = new Frame({ value: input, width: 10, height: 4 })
-		const output = frame.render({ method: Frame.RenderMethod.APPEND })
-		assert.ok(output.endsWith(Frame.BOF))
-		const lines = output.split("\n")
-		assert.equal(lines.length, 4)
-		assert.deepStrictEqual(lines.slice(1, 3), ["Line 2    ", ""])
-	})
-
-	it("should handle BOF at start with VISIBLE method", () => {
-		const input = [
-			Frame.BOF,
-			["Line 1"],
-			["Line 2"]
-		]
-		const frame = new Frame({ value: input, width: 10, height: 4 })
-		const output = frame.render({ method: Frame.RenderMethod.VISIBLE })
-		assert.ok(output.startsWith(`\x1b[1A`))
-		const lines = output.split("\n")
-		assert.ok(lines.length <= 2)
-		assert.deepStrictEqual(lines, [
-			Frame.cursorUp() + Frame.CLEAR_LINE + "\r" + "Line 1",
-			Frame.CLEAR_LINE + "\r" + "Line 2"
-		])
-	})
-
-	it("should handle BOF at end with VISIBLE method", () => {
-		const input = [
-			["Line 1"],
-			["Line 2"],
-			Frame.BOF
-		]
-		const frame = new Frame({ value: input, width: 10, height: 4 })
-		const output = frame.render({ method: Frame.RenderMethod.VISIBLE })
-		assert.ok(output.startsWith(Frame.CLEAR_LINE + "\r"))
-		const lines = output.split("\n")
-		assert.ok(lines.length <= 2)
-		assert.deepStrictEqual(lines, [
-			Frame.CLEAR_LINE + "\r" + "Line 1",
-			Frame.CLEAR_LINE + "\r" + "Line 2" + Frame.cursorUp(1)
-		])
-	})
-
-	it("should handle BOL in lines with REPLACE method", () => {
-		const input = [
-			["Line 1" + Frame.BOL],
-			["Line 2"]
-		]
-		const frame = new Frame({ value: input, width: 10, height: 3 })
-		const output = frame.render({ method: Frame.RenderMethod.REPLACE })
-		const lines = output.split("\n")
-		assert.ok(lines.some(line => line.includes(Frame.BOL)))
-		assert.equal(lines.length, 3)
-	})
-
-	it("should handle BOL in lines with APPEND method", () => {
-		const input = [
-			["Line 1" + Frame.BOL],
-			["Line 2"]
-		]
-		const frame = new Frame({ value: input, width: 10, height: 3 })
-		const output = frame.render({ method: Frame.RenderMethod.APPEND })
-		const lines = output.split("\n")
-		assert.ok(lines.some(line => line.includes(Frame.BOL)))
-		assert.ok(lines.length <= 3)
-	})
-
-	it("should handle BOL in lines with VISIBLE method", () => {
-		const input = [
-			["Line 1" + Frame.BOL],
-			["Line 2"]
-		]
-		const frame = new Frame({ value: input, width: 10, height: 3 })
-		const output = frame.render({ method: Frame.RenderMethod.VISIBLE })
-		const lines = output.split("\n")
-		assert.ok(lines.some(line => line.includes(Frame.BOL)))
-		assert.ok(lines.length <= 3)
-	})
-})
-
-describe("Frame.RenderMethod", () => {
-	const table = Frame.table({
-		aligns: ["r"],
-		padding: 2,
-	})([
-		["Usage: node memory-usage.js", "", ""],
-		["[process_name]", "", "Name of the process to check memory usage for"],
-		["-n number_of_processes", "", "Number of top memory consumers to show (default: 9)"],
-		["--help", "", "Show this help message"],
-	])
-	const frame = new Frame({
-		value: [...table, ""],
-		renderMethod: Frame.RenderMethod.REPLACE,
-	})
-
-	it("should render with REPLACE method", () => {
-		const output = frame.render({
-			method: Frame.RenderMethod.REPLACE,
-		})
-		assert.equal(typeof output, "string")
-		const lines = output.split("\n")
-		assert.ok(lines.length > 0)
-		lines.forEach(line => {
-			assert.ok(line.length <= (frame.width < 0 ? 144 : frame.width))
-		})
-	})
-
-	it("should render with APPEND method", () => {
-		const output = frame.render({ method: Frame.RenderMethod.APPEND })
-		assert.equal(typeof output, "string")
-		const lines = output.split("\n")
-		const height = frame.height < 0 ? 10 : frame.height
-		const width = frame.width < 0 ? 144 : frame.width
-		assert.ok(lines.length <= height)
-		lines.forEach(line => {
-			assert.ok(line.length <= width)
-		})
-	})
-
-	it("should render with VISIBLE method", () => {
-		const output = frame.render({ method: Frame.RenderMethod.VISIBLE })
-		assert.equal(typeof output, "string")
-		const lines = output.split("\n")
-		const height = frame.height < 0 ? 10 : frame.height
-		const width = frame.width < 0 ? 144 : frame.width
-		assert.ok(lines.length <= height)
-		lines.forEach(line => {
-			assert.ok(line.length <= width)
-		})
-	})
-})
-
-describe("Frame (3rd party deprecations)", () => {
-	it("should detect extra lines above BOF and allow for offset rendering", () => {
-		// Simulate a terminal with 2 extra lines above (e.g., from warnings)
-		const extraLines = 2
-		const selectBox = [
-			Frame.BOF,
-			["Select a command to run"],
-			["[+]draw"],
-			[" - send"],
-			[" - stats"],
-			[" - analyze"],
-			[" - extract"]
-		]
-		const frame = new Frame({ value: selectBox, width: 30, height: 8 })
-		const output = frame.render({ method: Frame.RenderMethod.REPLACE })
-		// The output should start with BOF and have the select box content
-		assert.ok(output.startsWith(Frame.BOF))
-		const lines = output.split("\n")
-		// Simulate that the select box is rendered at the top, but if there are extra lines above,
-		// the select box will be shifted down by `extraLines`
-		// To check for this, we can simulate a "screen" with extra lines and see where the select box appears
-		const screen = [
-			"DeprecationWarning: ...", // extra line 1
-			"Some other warning...",   // extra line 2
-			...lines
-		]
-		// The select box should appear at index `extraLines` (after the warnings)
-		assert.ok(screen[extraLines + 2].includes("Select a command to run"))
-		assert.ok(screen[extraLines + 3].includes("[+]draw"))
-		assert.ok(screen[extraLines + 4].includes("- send"))
-	})
-
-	it("should allow for offset rendering by prepending empty lines before BOF", () => {
-		// If you want to compensate for extra lines, you can prepend empty lines before BOF
-		const extraLines = 2
-		const selectBox = [
-			"",
-			"",
-			Frame.BOF,
-			["Select a command to run"],
-			["[+]draw"],
-			[" - send"],
-			[" - stats"],
-			[" - analyze"],
-			[" - extract"]
-		]
-		const frame = new Frame({ value: selectBox, width: 30, height: 10 })
-		const output = frame.render({ method: Frame.RenderMethod.REPLACE })
-		const lines = output.split("\n")
-		// The select box should now appear after the empty lines
-		assert.equal(lines[4], "Select a command to run".padEnd(30))
-		assert.equal(lines[5], "[+]draw".padEnd(30))
-	})
-
-	it("should render select box correctly even with extra lines above (simulate terminal shift)", () => {
-		// Simulate a terminal with 2 extra lines above (e.g., from warnings)
-		const extraLines = 2
-		const selectBox = [
-			Frame.BOF,
-			["Select a command to run"],
-			["[+]draw"],
-			[" - send"],
-			[" - stats"],
-			[" - analyze"],
-			[" - extract"]
-		]
-		const frame = new Frame({ value: selectBox, width: 30, height: 8 })
-		const output = frame.render({ method: Frame.RenderMethod.REPLACE })
-		const lines = output.split("\n")
-		// Simulate a "screen" with extra lines above
-		const screen = [
-			"DeprecationWarning: ...",
-			"Some other warning...",
-			...lines
-		]
-		// The select box should still be visible at the correct offset
-		assert.equal(screen[extraLines].trim(), `\x1b[0;0H`)
-		assert.equal(screen[extraLines + 1].trim(), "")
-		assert.equal(screen[extraLines + 2].trim(), "Select a command to run")
-		assert.equal(screen[extraLines + 3].trim(), "[+]draw")
-		assert.equal(screen[extraLines + 4].trim(), "- send")
-		assert.equal(screen[extraLines + 5].trim(), "- stats")
-		assert.equal(screen[extraLines + 6].trim(), "- analyze")
-		assert.equal(screen[extraLines + 7].trim(), "- extract")
-	})
-})

package/src/View/View.test.js

@@ -1,77 +0,0 @@
-import { describe, it } from "node:test"
-import { strict as assert } from "node:assert"
-import stringWidth from "string-width"
-import View from "./View.js"
-import Frame from "../Frame/Frame.js"
-import FrameProps from "../Frame/Props.js"
-import Welcome from "../Component/Welcome/index.js"
-
-describe("View", () => {
-	it("should create empty instance", () => {
-		const view = new View()
-		assert.ok(view)
-	})
-	it("should print frame", () => {
-		const view = new View()
-		view.render(1)(["Hello"])
-		assert.equal(String(view.frame), Frame.CLEAR_LINE + "\r" + "Hello")
-		const value = view.render(0)(["No output"])
-		assert.deepStrictEqual({ ...value }, {
-			imprint: Frame.CLEAR_LINE + "\r" + "No output",
-			value: [["No output"]],
-			width: 144,
-			height: 33,
-			renderMethod: "visible",
-			defaultProps: new FrameProps(),
-		})
-		view.render(() => (["fn result"]))(["Even with a function"])
-		assert.equal(String(view.frame), Frame.CLEAR_LINE + "\r" + "fn result")
-		assert.deepStrictEqual(view.stdout.stream, [
-			Frame.RESET + Frame.CLEAR_LINE + "\r" + "Hello",
-			Frame.CLEAR_LINE + "\r" + "fn result"
-		])
-	})
-	it("should print frame with render method set to append", () => {
-		const view = new View({ renderMethod: View.RenderMethod.APPEND })
-		view.render(1)(["Hello"])
-		assert.equal(String(view.frame), "Hello" + " ".repeat(139))
-		view.render(1)(["world"])
-		assert.equal(String(view.frame), "world" + " ".repeat(139))
-		const value = view.render(0)(["No output"])
-		assert.deepStrictEqual({ ...value }, {
-			imprint: "No output" + " ".repeat(144 - "No output".length),
-			value: [["No output"]],
-			width: 144,
-			height: 33,
-			renderMethod: View.RenderMethod.APPEND,
-			defaultProps: new FrameProps(),
-		})
-		view.render(() => (["fn result"]))(["Even with a function"])
-		assert.equal(String(view.frame), "fn result" + " ".repeat(144 - 9))
-		assert.deepStrictEqual(view.stdout.stream, [
-			Frame.RESET + "Hello",
-			Frame.RESET + "world",
-			"fn result"
-		].map(
-			row => row + " ".repeat(144 - stringWidth(row))
-		))
-	})
-	it("should render Welcome component", () => {
-		const view = new View({
-			renderMethod: View.RenderMethod.APPEND,
-			width: 144,
-			height: 33,
-		})
-		view.register(Welcome)
-		const frame = view.render("Welcome")({ user: { name: "View" } })
-		assert.ok(frame instanceof Frame)
-		const expected = [
-			"Welcome View!",
-			"What can we do today great?",
-			"",
-		].map(
-			row => (row + " ".repeat(144 - row.length))
-		).join("\n")
-		assert.deepStrictEqual(view.stdout.stream, [expected])
-	})
-})

package/src/core/Form/Form.test.js

@@ -1,116 +0,0 @@
-import { describe, it } from "node:test"
-import { strict as assert } from "node:assert"
-import UIForm from "./Form.js"
-import FormInput from "./Input.js"
-
-describe("UIForm", () => {
-	it("should create instance with default values", () => {
-		const form = new UIForm()
-		assert.ok(form instanceof UIForm)
-		assert.equal(form.title, "")
-		assert.deepEqual(form.fields, [])
-		assert.deepEqual(form.state, {})
-	})
-
-	it("should create instance with custom values", () => {
-		const fields = [
-			new FormInput({ name: "name", label: "Name", required: true }),
-			new FormInput({ name: "email", label: "Email", type: "email" })
-		]
-		const props = {
-			title: "Test Form",
-			fields,
-			state: { name: "John" }
-		}
-		const form = new UIForm(props)
-		assert.equal(form.title, "Test Form")
-		assert.equal(form.fields.length, 2)
-		assert.deepEqual(form.state, { name: "John" })
-	})
-
-	it("should set data", () => {
-		const form = new UIForm({ state: { name: "John" } })
-		const newForm = form.setData({ email: "john@example.com" })
-		assert.deepEqual(newForm.state, { name: "John", email: "john@example.com" })
-	})
-
-	it("should get field by name", () => {
-		const fields = [new FormInput({ name: "test", label: "Test Field" })]
-		const form = new UIForm({ fields })
-		const field = form.getField("test")
-		assert.ok(field)
-		assert.equal(field.name, "test")
-	})
-
-	it("should get values", () => {
-		const form = new UIForm({ state: { name: "John", age: 30 } })
-		const values = form.getValues()
-		assert.deepEqual(values, { name: "John", age: 30 })
-	})
-
-	it("should validate form", () => {
-		const fields = [new FormInput({ name: "requiredField", required: true })]
-		const form = new UIForm({ fields, state: {} })
-		const result = form.validate()
-		assert.ok(!result.isValid)
-		assert.ok(result.errors.requiredField)
-	})
-
-	it("should validate individual field", () => {
-		const fields = [new FormInput({ name: "email", type: "email" })]
-		const form = new UIForm({ fields })
-		const result = form.validateField("email", "invalid-email")
-		assert.ok(!result.isValid)
-		assert.ok(result.errors.email)
-	})
-
-	it("should convert to JSON", () => {
-		const form = new UIForm({ title: "Test", state: { name: "John" } })
-		const json = form.toJSON()
-		assert.ok(json.id)
-		assert.equal(json.title, "Test")
-		assert.ok(Array.isArray(json.fields))
-		assert.ok(json.state)
-		assert.ok(json.meta)
-	})
-
-	it("parses default text fields", () => {
-		const data = { name: "", email: "" }
-		const { fields } = UIForm.parse(data)
-		assert.equal(fields.length, 2)
-		assert.ok(fields[0] instanceof FormInput)
-		assert.equal(fields[0].name, "name")
-		assert.equal(fields[0].label, "Name")
-		assert.equal(fields[0].type, FormInput.TYPES.TEXT)
-		assert.equal(fields[0].required, false)
-	})
-
-	it("applies overrides correctly", () => {
-		const data = { age: "" }
-		const { fields } = UIForm.parse(data, {
-			age: { type: FormInput.TYPES.NUMBER, required: true, label: "User Age" },
-		})
-		const ageField = fields[0]
-		assert.equal(ageField.type, FormInput.TYPES.NUMBER)
-		assert.ok(ageField.required)
-		assert.equal(ageField.label, "User Age")
-	})
-
-	it("supports static custom validators", () => {
-		// register a validator that ensures a string contains only digits
-		UIForm.addValidator("digitsOnly", value => {
-			return /^\d+$/.test(value) ? true : "Must contain only digits"
-		})
-
-		const fields = [
-			new FormInput({ name: "phone", label: "Phone", required: true })
-		]
-		const schema = {
-			phone: { validator: "digitsOnly" }
-		}
-		const form = new UIForm({ fields, schema, state: { phone: "12a34" } })
-		const result = form.validate()
-		assert.ok(!result.isValid)
-		assert.equal(result.errors.phone, "Must contain only digits")
-	})
-})

package/src/core/Form/Input.test.js

@@ -1,58 +0,0 @@
-import { describe, it } from "node:test"
-import { strict as assert } from "node:assert"
-import FormInput from "./Input.js"
-
-describe("FormInput", () => {
-	it("should create instance with default values", () => {
-		const input = new FormInput({ name: "name" })
-		assert.ok(input instanceof FormInput)
-		assert.equal(input.type, FormInput.TYPES.TEXT)
-		assert.equal(input.required, false)
-		assert.equal(input.name, "name")
-		assert.equal(input.placeholder, "")
-		assert.deepEqual(input.options, [])
-	})
-
-	it("should create instance with custom values", () => {
-		const props = {
-			type: "email",
-			name: "email",
-			label: "Email Address",
-			required: true,
-			placeholder: "Enter email",
-			options: ["option1", "option2"],
-			defaultValue: "test@example.com"
-		}
-		const input = new FormInput(props)
-		assert.equal(input.type, "email")
-		assert.equal(input.name, "email")
-		assert.equal(input.label, "Email Address")
-		assert.equal(input.required, true)
-		assert.equal(input.placeholder, "Enter email")
-		assert.deepEqual(input.options, ["option1", "option2"])
-		assert.equal(input.defaultValue, "test@example.com")
-	})
-
-	it("should create from string", () => {
-		const input = FormInput.from("testField")
-		assert.equal(input.name, "testField")
-		assert.equal(input.label, "testField")
-	})
-
-	it("should create from object", () => {
-		const objInput = { name: "test", type: "text" }
-		const input = FormInput.from(objInput)
-		assert.ok(input instanceof FormInput)
-		assert.equal(input.name, "test")
-	})
-
-	it("should validate type", async () => {
-		const validInput = new FormInput({ name: "email", type: "email" })
-		assert.ok(validInput)
-		const fn = async () => new FormInput({ name: "email", type: "invalid" })
-		await assert.rejects(fn, {
-			name: "TypeError",
-			message: /FormInput\.type is invalid!/
-		})
-	})
-})