@nan0web/ui 1.0.0 → 1.0.2

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")
-		])
-	})
-})

package/stories/App/RenderOptions.js

@@ -1,14 +0,0 @@
-import RenderOptions from "../../src/View/RenderOptions.js"
-
-class AppRenderOptions extends RenderOptions {
-	static DEFAULTS = {
-		...RenderOptions.DEFAULTS,
-		resizeToView: true,
-	}
-	static from(props = {}) {
-		if (props instanceof AppRenderOptions) return props
-		return new this(props)
-	}
-}
-
-export default AppRenderOptions

package/stories/nodejs/interface.test.js

@@ -1,27 +0,0 @@
-/**
- * @todo write tests for the interfaces StdIn, StdOut, Locale, Frame, FrameProps and View in NodeJS with vitest.
- * Follow the actor / scenario model.
- * Basic interfaces must include:
- * - read text from stdin
- * - write text to stdout
- * - read an option from a selectbox with the bordered frame
- * - write result to stdout
- *
- * Frames and Views must follow the blessed interface as for flexibility.
- */
-import { describe, it, expect } from "vitest"
-
-describe("Interface", () => {
-	it("should read text from stdin", () => {
-		expect("").toBe("")
-	})
-	it("should write text to stdout", () => {
-		expect("").toBe("")
-	})
-	it("should read an option from a selectbox with the bordered frame", () => {
-		expect("").toBe("")
-	})
-	it("should write result to stdout with the bordered frame", () => {
-		expect("").toBe("")
-	})
-})

package/system.md

@@ -1,187 +0,0 @@
-# System intructions `system.md` / NaN•Web UI
-
-Vanilla javascript UI interfaces with no platform dependencies.  
-Must work for nodejs, browser and other compilers that supports ESM.
-
-## Requirements
-
-### 1. Javascript
-
-1.1. Pure vanilla js only.  
-1.2. Platform abstract.  
-1.3. Minimum dependency as possible.  
-1.4. Classes  
-1.4.1. Order of the class elements:
-- static properties
-- properties
-- constructor
-- getters
-- setters
-- base functions
-- async functions
-- static base functions
-- static async functions
-
-1.5. Views, every must:  
-1.5.1. Have a separate file and test file `View/AppView.js` and `View/AppView.test.js`.  
-1.6. Components, every must:
-1.6.1. Have a separate directory in `View/Component/*` or registered from any other directory with files:
-- `Component.js`
-- `Component.test.js`
-- `ComponentInput.js`
-- `index.js`
-  ```js
-  export default Component
-  export { ComponentInput }
-  ```
-
-### 2. Tests
-
-Every model, component, class must have their own tests file to cover their functionality in isolated environment.
-
-#### node:test
-
-For the core (base), cgi and cli interfaces, and web interfaces non `.jsx` components `node:test` with `node:assert/strict` must be used for tests.
-
-#### vitest
-
-For `React` apps and any that uses `.jsx` components `vitest` must be used for tests.
-
-## Interfaces
-
-1. `base` - Самий базовий інтерфейс, який має описувати всі доступні для інтерфейсів функції + тести `node:test`.
-1. `cli` - Console line application на основі команд через `argv[]` і вивід на екран за допомогою `@nan0web/log`.
-1. `api` - API який працює постійно для надання даних для `web`, `mobile` та інших інтерфейсів.
-1. `cgi` - Console graphic interface з віконцями і кнопками за допомогою `blessed`.
-1. `web` - Веб інтерфейс з `Web.customElements`, `Lit`, або `React`.
-1. `mobile` - Мобільний інтерфейс з `Ionic` або `Swift` і `Java`.
-1. `desktop` - Веб інтерфейс у обкладинці `Electron` або `Tauri`.
-1. `chat` - Чат інтерфейс `@nan0web/chat-ui`.
-1. `audio` - Мовний (голосовий) інтерфейс `@nan0web/audio-ui`.
-
-Базовий інтерфейс описує всі взаємодії і можливі функції.
-Всі інші інтерфейси мають розширювати базовий.
-
-Інтерфейси клієнти, у випадку коли є окремий `api` сервер, можуть розширювати свій `ClientUI`.
-
-Приклад успадкування:
-```js
-import UI from "@nan0web/ui"
-
-class BaseUI extends UI {}
-
-class CliUI extends BaseUI {}
-
-class APIUI extends CliUI {}
-
-class CgiUI extends CliUI {}
-
-class WebUI extends BaseUI {}
-
-class MobileUI extends BaseUI {}
-
-class DesktopUI extends WebUI {}
-
-class ChatUI extends BaseUI {}
-
-class AudioUI extends ChatUI {}
-```
-
-### Views
-
-#### Widgets
-
-Widget is a control alement including a view with and ask() ability to input data.
-
-#### Output
-
-Output data is passed to the view but also in specific format:
-```js
-function UserDocumentsView(input = {}) {
-  input = UserDocumentsInput.from(input)
-  if (empty(input)) {
-    throw new Error("Input data required in a format off UserDocumentsInput")
-  }
-
-  return Frame.from([
-    ['Documents'],
-    ...input.documents.map(d => d.name),
-  ])
-}
-```
-
-In this scenario I can easily define Input classes for the every View and Widget to be sure all the input pass, and easily require the proper input from the app before running a job.
-
-
-#### Input
-
-When application needs any data it requires.
-
-The input might be a command line `node start.js -user.name root` or, if not provided, user input through the provided infterface (any of CLI, API, voice, mobile, table, desktop, web, etc.)
-
-```js
-class App {
-  async requireUser() {
-    const user = await this.view.ask("User")()
-    if (user instanceof User) return user
-    throw new TypeError("User is required to continue")
-  }
-  async run() {
-    const user = await this.requireUser()
-    this.view.render("Welcome")({ user })
-  }
-}
-```
-
-## Cross platform
-
-Very important that I can extend basic UI with different apps, for instance:
-```jsx
-// apps/web/src/components/User/DocumentsView.jsx
-import React from "react"
-/** the very basic component **/
-import UserDocumentsInput from "src/components/User/DocumentsInput.js"
-
-function UserDocumentsView(input = {}) {
-  input = UserDocumentsInput.from(input)
-  if (empty(input)) {
-    throw new Error("Input data required in a format off UserDocumentsInput")
-  }
-
-  return <div>
-    <h3>Documents</h3>
-    <ul>
-      {input.documents.map((d, i) => <li key={i}>{d.name}</li>)}
-    </ul>
-  </div>
-}
-```
-
-### Apps locations
-
-#### Core application
-
-Core application s with the minimum stdin, stdout
-- `src/*`
-- `src/App.js`
-- `bin/start.js`
-- `package.json`
-
-Core application might have own resository, for instance `@nan0web/app`.
-
-#### CLI application
-
-CLI application can utilize `blessed` or other CLI library for rich UI experience, compared to Core.
-
-- `apps/cli/src/*`
-- `apps/cli/bin/start.js`
-- `apps/cli/package.json`
-
-#### Web application
-
-Web applications can utilize `react` or `lit` or other Web UI library for rich UI experience.
-Most desired is `lit` to avoid using typescript or jsx.
-
-- `apps/web/src/*`
-- `apps/web/bin/start.js`
-- `apps/web/package.json`