@nan0web/ui 1.0.0 → 1.0.1

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!/
-		})
-	})
-})

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

@@ -1,54 +0,0 @@
-import { describe, it } from "node:test"
-import { strict as assert } from "node:assert"
-import FormMessage from "./Message.js"
-
-describe("FormMessage", () => {
-	it("should create instance with default values", () => {
-		const msg = new FormMessage()
-		assert.ok(msg instanceof FormMessage)
-		assert.deepEqual(msg.data, {})
-		assert.deepEqual(msg.schema, {})
-		assert.equal(msg.type, "form")
-	})
-
-	it("should create instance with custom values", () => {
-		const props = {
-			data: { name: "John" },
-			schema: { name: { required: true } },
-			body: ["Form content"]
-		}
-		const msg = new FormMessage(props)
-		assert.deepEqual(msg.data, { name: "John" })
-		assert.deepEqual(msg.schema, { name: { required: true } })
-		assert.deepEqual(msg.body, ["Form content"])
-	})
-
-	it("should add data", () => {
-		const msg = new FormMessage({ data: { name: "John" } })
-		const newMsg = msg.addData({ age: 30 })
-		assert.deepEqual(newMsg.data, { name: "John", age: 30 })
-	})
-
-	it("should validate data correctly", () => {
-		const schema = {
-			name: { required: true },
-			email: { type: "email" },
-			age: { type: "number" }
-		}
-		const msg = new FormMessage({ schema })
-		
-		// Valid data
-		const validData = { name: "John", email: "john@example.com", age: "30" }
-		const validResult = msg.validateData(validData)
-		assert.ok(validResult.isValid)
-		assert.deepEqual(validResult.errors, {})
-		
-		// Invalid data
-		const invalidData = { email: "invalid-email", age: "not-a-number" }
-		const invalidResult = msg.validateData(invalidData)
-		assert.ok(!invalidResult.isValid)
-		assert.ok(invalidResult.errors.name)
-		assert.ok(invalidResult.errors.email)
-		assert.ok(invalidResult.errors.age)
-	})
-})

package/src/core/InputAdapter.test.js

@@ -1,35 +0,0 @@
-import { describe, it } from "node:test"
-import { strict as assert } from "node:assert"
-import InputAdapter from "./InputAdapter.js"
-
-describe("InputAdapter", () => {
-	it("should create instance", () => {
-		const adapter = new InputAdapter()
-		assert.ok(adapter instanceof InputAdapter)
-	})
-
-	it("should start and emit input message", () => {
-		const adapter = new InputAdapter()
-		let emitted = false
-		let message = null
-		
-		adapter.on('input', (msg) => {
-			emitted = true
-			message = msg
-		})
-		
-		adapter.start()
-		assert.ok(emitted)
-		assert.ok(message)
-	})
-
-	it("should stop without error", () => {
-		const adapter = new InputAdapter()
-		assert.doesNotThrow(() => adapter.stop())
-	})
-
-	it("should be ready by default", () => {
-		const adapter = new InputAdapter()
-		assert.ok(adapter.isReady())
-	})
-})

package/src/core/Message/InputMessage.test.js

@@ -1,45 +0,0 @@
-import { describe, it } from "node:test"
-import { strict as assert } from "node:assert"
-import InputMessage from "./InputMessage.js"
-import { notEmpty, empty } from "@nan0web/types"
-
-describe("InputMessage", () => {
-	it("should create instance with default values", () => {
-		const msg = new InputMessage()
-		assert.ok(msg instanceof InputMessage)
-		assert.equal(msg.value, "")
-		assert.equal(msg.waiting, false)
-		assert.deepEqual(msg.options, [])
-	})
-
-	it("should create instance with custom values", () => {
-		const props = {
-			value: "user input",
-			waiting: true,
-			options: ["option1", "option2"]
-		}
-		const msg = new InputMessage(props)
-		assert.equal(msg.value, "user input")
-		assert.equal(msg.waiting, true)
-		assert.deepEqual(msg.options, ["option1", "option2"])
-	})
-
-	it("should handle string options correctly", () => {
-		const msg = new InputMessage({ options: "single-option" })
-		assert.deepEqual(msg.options, ["single-option"])
-	})
-
-	it("should detect empty value", () => {
-		const emptyMsg = new InputMessage({ value: "" })
-		const nonEmptyMsg = new InputMessage({ value: "test" })
-		assert.ok(emptyMsg.empty)
-		assert.ok(!nonEmptyMsg.empty)
-	})
-
-	it("should validate message", () => {
-		const validMsg = new InputMessage({ value: "test" })
-		const invalidMsg = new InputMessage({ value: "" })
-		assert.ok(validMsg.isValid)
-		assert.ok(!invalidMsg.isValid)
-	})
-})

package/src/core/Message/Message.test.js

@@ -1,58 +0,0 @@
-import { describe, it } from "node:test"
-import { strict as assert } from "node:assert"
-import UIMessage from "./Message.js"
-
-describe("UIMessage", () => {
-	it("should create instance with default values", () => {
-		const msg = new UIMessage()
-		assert.ok(msg instanceof UIMessage)
-		assert.equal(typeof msg.type, "string")
-		assert.equal(typeof msg.id, "string")
-		assert.ok(msg.time instanceof Date)
-	})
-
-	it("should create instance with custom values", () => {
-		const props = {
-			type: "test",
-			id: "custom-id",
-			body: ["test content"]
-		}
-		const msg = new UIMessage(props)
-		assert.equal(msg.type, "test")
-		assert.equal(msg.id, "custom-id")
-		assert.deepEqual(msg.body, ["test content"])
-	})
-
-	it("should generate unique id when not provided", () => {
-		const msg1 = new UIMessage()
-		const msg2 = new UIMessage()
-		assert.notEqual(msg1.id, msg2.id)
-	})
-
-	it("should use content as body when body not provided", () => {
-		const msg = new UIMessage({ content: ["hello"] })
-		assert.deepEqual(msg.body, ["hello"])
-	})
-
-	it("should create from data using from() method", () => {
-		const data = { type: "info", body: ["test"] }
-		const msg = UIMessage.from(data)
-		assert.ok(msg instanceof UIMessage)
-		assert.equal(msg.type, "info")
-		assert.deepEqual(msg.body, ["test"])
-	})
-
-	it("should validate type correctly", () => {
-		const validMsg = new UIMessage({ type: UIMessage.TYPES.TEXT })
-		const invalidMsg = new UIMessage({ type: "invalid-type" })
-		assert.ok(validMsg.isValidType())
-		assert.ok(!invalidMsg.isValidType())
-	})
-
-	it("should check if message is empty", () => {
-		const emptyMsg = new UIMessage()
-		const nonEmptyMsg = new UIMessage({ body: ["content"] })
-		assert.ok(emptyMsg.isEmpty())
-		assert.ok(!nonEmptyMsg.isEmpty())
-	})
-})

package/src/core/Message/OutputMessage.test.js

@@ -1,61 +0,0 @@
-import { describe, it } from "node:test"
-import { strict as assert } from "node:assert"
-import OutputMessage from "./OutputMessage.js"
-
-describe("OutputMessage", () => {
-	it("should create instance with default values", () => {
-		const msg = new OutputMessage()
-		assert.ok(msg instanceof OutputMessage)
-		assert.deepEqual(msg.body, [])
-		assert.deepEqual(msg.meta, {})
-		assert.equal(msg.error, null)
-		assert.equal(msg.priority, OutputMessage.PRIORITY.NORMAL)
-	})
-
-	it("should create instance with custom values", () => {
-		const props = {
-			content: ["test content"],
-			meta: { key: "value" },
-			error: new Error("test error"),
-			priority: OutputMessage.PRIORITY.HIGH
-		}
-		const msg = new OutputMessage(props)
-		assert.deepEqual(msg.content, ["test content"])
-		assert.deepEqual(msg.meta, { key: "value" })
-		assert.ok(msg.error instanceof Error)
-		assert.equal(msg.priority, OutputMessage.PRIORITY.HIGH)
-	})
-
-	it("should set type based on error presence", () => {
-		const errorMsg = new OutputMessage({ error: "error occurred" })
-		const infoMsg = new OutputMessage({ content: ["info"] })
-		assert.equal(errorMsg.type, "error")
-		assert.equal(infoMsg.type, "info")
-	})
-
-	it("should handle string content", () => {
-		const msg = new OutputMessage({ content: "single string" })
-		assert.deepEqual(msg.content, ["single string"])
-	})
-
-	it("should combine messages", () => {
-		const msg1 = new OutputMessage({ content: ["part1"], priority: 1 })
-		const msg2 = new OutputMessage({ content: ["part2"], priority: 2 })
-		const combined = msg1.combine(msg2)
-		assert.deepEqual(combined.content, ["part1", "part2"])
-		assert.equal(combined.priority, 2)
-	})
-
-	it("should convert to JSON", () => {
-		const msg = new OutputMessage({ 
-			content: ["test"],
-			meta: { test: true },
-			error: new Error("test error")
-		})
-		const json = msg.toJSON()
-		assert.ok(json.body)
-		assert.ok(json.meta)
-		assert.ok(json.error)
-		assert.ok(json.time)
-	})
-})

package/src/core/OutputAdapter.test.js

@@ -1,35 +0,0 @@
-import { describe, it } from "node:test"
-import { strict as assert } from "node:assert"
-import OutputAdapter from "./OutputAdapter.js"
-
-describe("OutputAdapter", () => {
-	it("should create instance", () => {
-		const adapter = new OutputAdapter()
-		assert.ok(adapter instanceof OutputAdapter)
-	})
-
-	it("should throw error on render method", () => {
-		const adapter = new OutputAdapter()
-		assert.throws(() => adapter.render(), {
-			message: "render() must be implemented by subclass"
-		})
-	})
-
-	it("should call render on progress", () => {
-		const adapter = new OutputAdapter()
-		let rendered = false
-		
-		// Override render for test
-		adapter.render = () => {
-			rendered = true
-		}
-		
-		adapter.progress(0.5)
-		assert.ok(rendered)
-	})
-
-	it("should stop without error", () => {
-		const adapter = new OutputAdapter()
-		assert.doesNotThrow(() => adapter.stop())
-	})
-})

package/src/core/Stream.test.js

@@ -1,78 +0,0 @@
-import { describe, it } from "node:test"
-import { strict as assert } from "node:assert"
-import UIStream from "./Stream.js"
-import StreamEntry from "./StreamEntry.js"
-
-describe("UIStream", () => {
-	it("should create processor generator", async () => {
-		const controller = new AbortController()
-		const processorFn = () => Promise.resolve("test result")
-		const generator = UIStream.createProcessor(controller.signal, processorFn)
-
-		assert.equal(typeof generator, "function")
-
-		for await (const item of generator()) {
-			assert.equal(item, "test result")
-			break
-		}
-	})
-
-	it("should handle aborted signal", async () => {
-		const controller = new AbortController()
-		controller.abort()
-
-		const processorFn = () => Promise.resolve(StreamEntry.from({ value: "Hello", done: true }))
-		const generator = UIStream.createProcessor(controller.signal, processorFn)
-
-		for await (const item of generator()) {
-			assert.deepEqual(item, StreamEntry.from({ done: true, value: "Hello" }))
-			break
-		}
-	})
-
-	it("should process stream with callbacks", async () => {
-		const controller = new AbortController()
-		let progressCalled = false
-		let completeCalled = false
-
-		const generatorFn = async function* () {
-			yield StreamEntry.from({ progress: 0.5 })
-			yield StreamEntry.from({ done: true })
-		}
-
-		const onProgress = () => { progressCalled = true }
-		const onComplete = () => { completeCalled = true }
-
-		await UIStream.process(
-			controller.signal,
-			generatorFn,
-			onProgress,
-			null,
-			onComplete
-		)
-
-		assert.ok(progressCalled)
-		assert.ok(completeCalled)
-	})
-
-	it("should handle errors in stream processing", async () => {
-		const controller = new AbortController()
-		let errorCalled = false
-
-		const generatorFn = async function* () {
-			yield { error: "test error" }
-		}
-
-		const onError = () => { errorCalled = true }
-
-		await UIStream.process(
-			controller.signal,
-			generatorFn,
-			null,
-			onError,
-			null
-		)
-
-		assert.ok(errorCalled)
-	})
-})

package/src/index.test.js

@@ -1,14 +0,0 @@
-import { describe, it } from "node:test"
-import { strict as assert } from "node:assert"
-import { App } from "@nan0web/ui"
-
-describe("App", () => {
-	it("should be defined", () => {
-		assert.ok(App)
-		assert.ok(App.Core)
-		assert.ok(App.User)
-		assert.ok(App.Command)
-		assert.ok(App.Scenario)
-		assert.ok(App.UI)
-	})
-})

package/stories/App/AppView.js

@@ -1,15 +0,0 @@
-import View from "../../src/View/View.js"
-import Welcome from "../../src/Component/Welcome/index.js"
-import Process from "../../src/Component/Process/index.js"
-import AppRenderOptions from "./RenderOptions.js"
-
-class AppView extends View {
-	static RenderOptions = AppRenderOptions
-	constructor(props = {}) {
-		super(props)
-		this.register(Welcome)
-		this.register(Process)
-	}
-}
-
-export default AppView

package/stories/App/AppView.test.js

@@ -1,22 +0,0 @@
-import { describe, it, expect } from "vitest"
-import AppView from "./AppView.js"
-import Frame from "../../src/Frame/Frame.js"
-
-describe("AppView", () => {
-	it("should create an instance", () => {
-		const view = new AppView()
-		expect(view).toBeInstanceOf(AppView)
-	})
-	it("should render a welcome component", () => {
-		const view = new AppView()
-		const welcome = view.render("Welcome")({ user: { name: "NaN•" } })
-		expect(welcome).toBeInstanceOf(Frame)
-		expect(view.stdout.stream).toEqual([
-			[
-				"Welcome NaN•!",
-				"What can we do today great?",
-				"",
-			].join("\n")
-		])
-	})
-})