@nan0web/ui 1.12.2 → 3.1.0

package/src/StdIn.js

@@ -1,100 +0,0 @@
-import EventProcessor from '@nan0web/event/oop'
-import { typeOf } from '@nan0web/types'
-import { UiMessage } from './core/index.js'
-
-class Processor extends EventProcessor {}
-
-/**
- * Handles standard input stream with message buffering.
- */
-export default class StdIn extends EventProcessor {
-	/** @type {number} Read interval in milliseconds */
-	static READ_INTERVAL = 99
-
-	/** @type {string[]} Messages to ignore */
-	static IGNORE_MESSAGES = ['', 'undefined']
-
-	/**
-	 * Creates a new StdIn instance.
-	 * @param {object} props - StdIn properties
-	 * @param {Processor} [props.processor] - Input processor
-	 * @param {UiMessage[]} [props.stream=[]] - Initial input stream
-	 */
-	constructor(props = {}) {
-		super()
-		const { processor = new Processor(), stream = [] } = props
-		/** @type {Processor} Input processor */
-		this.processor = processor
-		/** @type {UiMessage[]} Input message buffer */
-		this.stream = stream
-		this.processor?.on('data', (data) => {
-			this.write(data)
-		})
-	}
-
-	/**
-	 * Checks if there are messages waiting in the input stream.
-	 * @returns {boolean} True if waiting messages, false otherwise
-	 */
-	get waiting() {
-		return this.stream.length > 0
-	}
-
-	/**
-	 * Checks if the input stream has ended (no messages left).
-	 * @returns {boolean} True if no messages left, false otherwise
-	 */
-	get ended() {
-		return 0 === this.stream.length
-	}
-
-	/**
-	 * Reads a message from the input stream.
-	 * Waits until messages are available if stream is empty.
-	 * @returns {Promise<UiMessage>} Next input message
-	 */
-	async read() {
-		while (this.ended) {
-			await new Promise((resolve) => setTimeout(resolve, StdIn.READ_INTERVAL))
-		}
-		return this.stream.shift() ?? new UiMessage()
-	}
-
-	/**
-	 * Writes a message to the input stream.
-	 * @param {string} message - Message to write
-	 * @returns {boolean} True if message accepted, False if ignored
-	 */
-	write(message) {
-		// this.processor?.emit("data", message)
-		const text = String(message)
-		if (StdIn.IGNORE_MESSAGES.includes(text)) {
-			return false
-		}
-		this.stream.push(this.decode(text))
-		return true
-	}
-
-	/**
-	 * Decodes a message into an UiMessage instance.
-	 * @param {UiMessage | string[] | any} message - Message to decode
-	 * @returns {UiMessage} Decoded input message
-	 */
-	decode(message) {
-		if (message instanceof UiMessage) return message
-		if (Array.isArray(message) && message.every(typeOf(String))) {
-			return new UiMessage({ value: message })
-		}
-		return new UiMessage(message)
-	}
-
-	/**
-	 * Creates a StdIn instance from the given input.
-	 * @param {StdIn|object} input - The input to create from
-	 * @returns {StdIn} A StdIn instance
-	 */
-	static from(input) {
-		if (input instanceof StdIn) return input
-		return new this(input)
-	}
-}

package/src/StdOut.js

@@ -1,95 +0,0 @@
-import { typeOf } from '@nan0web/types'
-import EventProcessor from '@nan0web/event/oop'
-
-/**
- * Handles standard output stream with formatting capabilities.
- */
-class StdOut extends EventProcessor {
-	/** @type {string} End of line character */
-	static EOL = '\n'
-
-	/** @type {string} Beginning of line character */
-	static BOL = '\r'
-
-	/** @type {string} Reset formatting escape code */
-	static RESET = '\x1b[0m'
-
-	/** @type {string} Clear screen escape code */
-	static CLEAR = '\x1b[2J\x1b[H'
-
-	/** @type {object} Color escape codes */
-	static COLORS = {
-		red: '\x1b[31m',
-		green: '\x1b[32m',
-		yellow: '\x1b[33m',
-		blue: '\x1b[34m',
-		magenta: '\x1b[35m',
-		cyan: '\x1b[36m',
-		white: '\x1b[37m',
-		gray: '\x1b[90m',
-		black: '\x1b[30m',
-	}
-
-	/** @type {Record<string, string>} Style escape codes */
-	static STYLES = {
-		dim: '\x1b[2m',
-		bold: '\x1b[1m',
-		underline: '\x1b[4m',
-	}
-
-	/**
-	 * @todo define go top by rows constants.
-	 */
-
-	/** @type {string[]} Output stream buffer */
-	stream = []
-
-	/** @type {number[]} Window size [width, height] */
-	windowSize = []
-
-	/** @type {any} Output processor */
-	processor
-
-	/**
-	 * Creates a new StdOut instance.
-	 * @param {object} props - StdOut properties
-	 * @param {any} [props.processor] - Output processor
-	 * @param {string[]} [props.stream=[]] - Initial output stream
-	 * @param {number[]} [props.windowSize=[144, 33]] - Window size [width, height]
-	 */
-	constructor(props = {}) {
-		super()
-		const { processor, stream = [], windowSize = [144, 33] } = props
-		this.processor = processor
-		this.stream = stream
-		this.windowSize = windowSize
-	}
-
-	/**
-	 * Writes output to the output stream.
-	 * Must be overwritten by other apps.
-	 * @param {any} output - Output to write
-	 * @param {Function} onError - Error handler callback
-	 */
-	write(output, onError = (v) => 1) {
-		/**
-		 * @todo manage the
-		 */
-		if (typeOf(Array)(output)) {
-			output = output.join('\n')
-		}
-		this.stream.push(output)
-		this.processor?.write(output, onError)
-		this.emit('data', output)
-	}
-
-	/**
-	 * Gets the window size.
-	 * @returns {number[]} Window size [width, height]
-	 */
-	getWindowSize() {
-		return this.processor?.getWindowSize?.() ?? this.windowSize
-	}
-}
-
-export default StdOut

package/src/View/RenderOptions.js

@@ -1,48 +0,0 @@
-import Frame from '../Frame/Frame.js'
-
-class RenderOptions {
-	static DEFAULTS = {
-		resizeToView: false,
-		translateFrame: false,
-		render: true,
-		renderMethod: Frame.RenderMethod.VISIBLE,
-	}
-	/** @type {boolean} [false] */
-	resizeToView
-	/** @type {boolean} [false] */
-	translateFrame
-	/** @type {boolean} [true] */
-	render
-	/** @type {string} */
-	renderMethod
-	/** @type {number} */
-	width
-	/** @type {number} */
-	height
-	constructor(props = {}) {
-		const DEFAULTS = this.DEFAULTS
-		const {
-			resizeToView = DEFAULTS.resizeToView,
-			translateFrame = DEFAULTS.translateFrame,
-			render = DEFAULTS.render,
-			renderMethod = DEFAULTS.renderMethod,
-			width = 0,
-			height = 0,
-		} = props
-		this.resizeToView = resizeToView
-		this.translateFrame = translateFrame
-		this.render = render
-		this.renderMethod = renderMethod
-		this.width = width
-		this.height = height
-	}
-	get DEFAULTS() {
-		return /** @type {typeof RenderOptions} */ (this.constructor).DEFAULTS
-	}
-	static from(props = {}) {
-		if (props instanceof RenderOptions) return props
-		return new this(props)
-	}
-}
-
-export default RenderOptions

package/src/View/View.js

@@ -1,306 +0,0 @@
-import { empty, equal, typeOf } from '@nan0web/types'
-import Frame, { FrameRenderMethod } from '../Frame/Frame.js'
-import Locale from '../Locale.js'
-import StdOut from '../StdOut.js'
-import StdIn from '../StdIn.js'
-import RenderOptions from './RenderOptions.js'
-import UiMessage from '../core/Message/Message.js'
-
-/**
- * @typedef {Object} ComponentFn
- * @property {string} name
- * @property {(input: UiMessage) => Promise<any>} ask
- * @property {Function} bind
- */
-
-export default class View {
-	/** @type {typeof RenderOptions} */
-	static RenderOptions = RenderOptions
-	/** @type {typeof FrameRenderMethod} */
-	static RenderMethod = Frame.RenderMethod
-	/** @type {StdIn} */
-	stdin
-	/** @type {StdOut} */
-	stdout
-	/** @type {number} */
-	startedAt
-	/** @type {Frame} */
-	frame
-	/** @type {Locale} */
-	locale
-	/** @type {Map<string, string>} */
-	vocab
-	/** @type {number[]} */
-	windowSize
-	/** @type {Map<string, ComponentFn>} */
-	components
-	/** @type {string} */
-	renderMethod
-	/**
-	 * @param {object} [input]
-	 * @param {StdIn} [input.stdin]
-	 * @param {StdOut} [input.stdout]
-	 * @param {number} [input.startedAt]
-	 * @param {Frame} [input.frame]
-	 * @param {Locale} [input.locale]
-	 * @param {Map<string, string>} [input.vocab]
-	 * @param {number[]} [input.windowSize]
-	 * @param {Map<string, ComponentFn>} [input.components]
-	 * @param {string} [input.renderMethod]
-	 */
-	constructor(input = {}) {
-		const {
-			stdin = new StdIn(),
-			stdout = new StdOut(),
-			startedAt = Date.now(),
-			frame = new Frame(),
-			locale = Locale.from('uk-UA'),
-			vocab = new Map(),
-			windowSize = [0, 0],
-			components = new Map(),
-			renderMethod = Frame.RenderMethod.VISIBLE,
-		} = input
-		this.stdin = stdin
-		this.stdout = stdout
-		this.startedAt = startedAt
-		this.frame = frame
-		this.locale = locale
-		this.vocab = vocab
-		this.windowSize = /** @type {number[]} */ (null === windowSize ? this.stdout.getWindowSize() : windowSize)
-		this.components = components
-		this.renderMethod = renderMethod
-		if (!empty(frame)) {
-			this.render(1)(this.frame)
-		}
-	}
-	get empty() {
-		return empty(this.frame)
-	}
-	get RenderMethod() {
-		return /** @type {typeof View} */ (this.constructor).RenderMethod
-	}
-	get RenderOptions() {
-		return /** @type {typeof View} */ (this.constructor).RenderOptions
-	}
-	getWindowSize() {
-		return equal(this.windowSize, [0, 0]) ? this.stdout.getWindowSize() : this.windowSize
-	}
-	/**
-	 * @param {number} width
-	 * @param {number} height
-	 */
-	setWindowSize(width, height) {
-		this.windowSize = [width, height]
-	}
-	startTimer() {
-		this.startedAt = Date.now()
-	}
-	spent(checkpoint = this.startedAt) {
-		return Math.round((Date.now() - checkpoint) / 1000)
-	}
-	/**
-	 * @param {boolean | number | Function | ComponentFn} [shouldRender=0]
-	 * @param {RenderOptions} [options]
-	 * @returns {(value: Frame|string|string[], ...args: any) => Frame}
-	 */
-	render(shouldRender = 0, options = new this.RenderOptions()) {
-		const [width, height] = this.getWindowSize()
-		options = this.RenderOptions.from({
-			...options,
-			renderMethod: this.renderMethod,
-			width,
-			height,
-			// @ts-ignore
-		})
-		const renderFn =
-			'function' === typeof shouldRender // no errors.
-				? // const renderFn = typeOf(Function)(shouldRender) // Property 'bind' does not exist on type 'number | boolean | Function'.
-					shouldRender.bind(this)
-				: 'string' === typeof shouldRender
-					? this.components.get(shouldRender)?.bind(this)
-					: null
-
-		return (value, ...args) => {
-			if (renderFn) {
-				/** @type {Frame} */
-				let rendered = renderFn.bind(this)(value, ...args)
-				if (!(rendered instanceof Frame)) {
-					rendered = new Frame({
-						value: rendered,
-						renderMethod: options.renderMethod,
-						width: options.width,
-						height: options.height,
-					})
-				}
-				rendered = View.fixFrame(rendered, options)
-				rendered = rendered.transform(this.t.bind(this))
-				rendered.render()
-				if (options.render) {
-					this.stdout.write(String(rendered))
-					this.frame = rendered
-				}
-				return rendered
-			}
-
-			let frame = Frame.from({ ...options, value })
-			frame = View.fixFrame(frame, options)
-			let clearFrame = false
-			if (String(frame.value[0] ?? '') === Frame.BOF) {
-				frame.value = frame.value.slice(1)
-				clearFrame = true
-			}
-			let translated = options.translateFrame ? frame.transform(this.t.bind(this)) : frame
-			translated = View.fixFrame(translated, options)
-
-			let rendered = translated
-			rendered.render()
-			if (shouldRender) {
-				if (clearFrame) {
-					const distance = options.height - frame.value.length
-					this.stdout.write(Frame.BOF)
-					for (let i = 0; i < distance; i++) {
-						this.stdout.write(Frame.EOL)
-					}
-				}
-				this.stdout.write(Frame.RESET + String(rendered))
-				this.frame = rendered
-			}
-			return rendered
-		}
-	}
-
-	clear(shouldRender = 0) {
-		const [width, height] = this.windowSize
-		const frame = new Frame({ width, height, renderMethod: Frame.RenderMethod.REPLACE })
-		frame.value = []
-		for (let i = 0; i < height; i++) frame.value.push([])
-		return this.render(shouldRender)(frame)
-	}
-
-	progress(shouldRender = false) {
-		return (value) => {
-			const frame = Frame.from(value)
-			frame.renderMethod = Frame.RenderMethod.REPLACE
-			return this.render(!!shouldRender)(frame)
-		}
-	}
-
-	/** @param {any} value */
-	t(value) {
-		if (typeOf(Array)(value)) {
-			value = value.map((row) => {
-				if (typeOf(Array)(row)) {
-					return row.map((col) => {
-						return this.vocab.has(col) ? this.vocab.get(col) : col
-					})
-				}
-				return this.vocab.has(row) ? this.vocab.get(row) : row
-			})
-			return value
-		}
-		return this.vocab.has(value) ? this.vocab.get(value) : value
-	}
-
-	/** @param {any[]} args */
-	debug(...args) {
-		// @ts-ignore
-		return this.render(1)([StdOut.STYLES.dim, 'Debug: ', args.join(' '), Frame.EOL, StdOut.RESET])
-	}
-
-	/** @param {any[]} args */
-	info(...args) {
-		// @ts-ignore
-		return this.render(1)([StdOut.COLORS.green, 'Info : ', args.join(' '), Frame.EOL, StdOut.RESET])
-	}
-
-	/** @param {any[]} args */
-	warn(...args) {
-		return this.render(1)([
-			// @ts-ignore
-			StdOut.COLORS.yellow,
-			'Warn : ',
-			args.join(' '),
-			Frame.EOL,
-			StdOut.RESET,
-		])
-	}
-
-	/** @param {any[]} args */
-	error(...args) {
-		return this.render(1)([
-			// @ts-ignore
-			StdOut.COLORS.red,
-			StdOut.STYLES.bold,
-			'Error: ',
-			args.join(' '),
-			Frame.EOL,
-			StdOut.RESET,
-		])
-	}
-
-	/**
-	 * @param {string} name
-	 * @param {ComponentFn} component
-	 */
-	register(name, component) {
-		if (undefined === component && 'function' === typeof name) {
-			component = name
-			name = component.name
-		}
-		this.components.set(name, component)
-	}
-
-	/**
-	 * @param {string} name
-	 */
-	unregister(name) {
-		this.components.delete(name)
-	}
-
-	/**
-	 * @param {string} name
-	 * @returns {boolean}
-	 */
-	has(name) {
-		return this.components.has(name)
-	}
-
-	/**
-	 * @param {string} name
-	 * @returns {ComponentFn | undefined}
-	 */
-	get(name) {
-		return this.components.get(name)
-	}
-
-	/**
-	 * @param {UiMessage} input
-	 * @returns {Promise<UiMessage | null>}
-	 */
-	async ask(input) {
-		const name = input.constructor.name.replace(/Input$/, '')
-		const component = this.get(name)
-		if (component) {
-			return await component.ask.apply(this, [input])
-		}
-		let result = null
-		do {
-			const answer = await this.stdin.read()
-			result = /** @type {typeof UiMessage} */ (input.constructor).from(answer)
-		} while (!result.isValid && !result.head.cancelled)
-		return result.head.cancelled ? null : result
-	}
-
-	/**
-	 * @param {Frame} frame
-	 * @param {RenderOptions} [options]
-	 * @returns {Frame}
-	 */
-	static fixFrame(frame, options = new RenderOptions()) {
-		if (options.resizeToView && !equal(options.width, frame.width, options.height, frame.height)) {
-			frame.setWindowSize(options.width, options.height)
-		}
-		// @todo add multiline visibility, for instance extended frame row into rows if it's wider than width.
-		return frame
-	}
-}

package/src/core/Message/index.js

@@ -1,6 +0,0 @@
-import UiMessage from './Message.js'
-import OutputMessage from './OutputMessage.js'
-
-export { UiMessage, OutputMessage }
-
-export default UiMessage

package/types/App/Command/DepsCommand.d.ts

@@ -1,14 +0,0 @@
-export class DepsCommand extends UiMessage {
-    static Body: typeof DepsCommandBody;
-    constructor(input?: {});
-}
-export default DepsCommand;
-import UiMessage from '../../core/Message/Message.js';
-declare class DepsCommandBody {
-    static fix: {
-        help: string;
-        defaultValue: boolean;
-    };
-    constructor(input?: {});
-    fix: boolean;
-}

package/types/App/Core/CoreApp.d.ts

@@ -1,70 +0,0 @@
-/** @typedef {Function} CommandFn */
-/**
- * Abstract base class for all apps.
- * Each app processes input commands and produces output.
- */
-export default class CoreApp {
-    /**
-     * Creates a new CoreApp instance.
-     * @param {object} props - CoreApp properties
-     * @param {string} [props.name="CoreApp"] - App name
-     * @param {object} [props.state={}] - Initial state object
-     * @param {Message} [props.startCommand=new Message()] - Command line arguments to parse
-     */
-    constructor(props?: {
-        name?: string | undefined;
-        state?: object;
-        startCommand?: Message | undefined;
-    });
-    /** @type {string} App name */
-    name: string;
-    /** @type {Map<string, CommandFn>} Registered command handlers */
-    commands: Map<string, CommandFn>;
-    /** @type {Record<string, any>} App state */
-    state: Record<string, any>;
-    /** @type {Message} Starting command parsed from argv */
-    startCommand: Message;
-    /**
-     * Sets app state.
-     * @param {string|object} state - State key or object with multiple keys
-     * @param {any} [value] - State value if state is a string key
-     * @returns {object} Updated state
-     */
-    set(state: string | object, value?: any): object;
-    /**
-     * Register a command handler.
-     * @param {string} commandName - Name of the command to register
-     * @param {Function} handler - async function or sync function that accepts params and returns output
-     */
-    registerCommand(commandName: string, handler: Function): void;
-    /**
-     * Returns a string representation of the app.
-     * @returns {string} String representation including name and state
-     */
-    toString(): string;
-    /**
-     * Process a command message.
-     * @param {Message} msg - Command to process
-     * @param {UI} ui - UI instance to use for rendering
-     * @returns {Promise<any>} Output of the command
-     * @throws {Error} If the command is not registered
-     */
-    processCommand(msg: Message, ui: UI): Promise<any>;
-    /**
-     * Process an array of command messages sequentially.
-     * @param {Message[]} Messages - Array of commands to process
-     * @param {UI} ui - UI instance to use for rendering
-     * @returns {Promise<any[]>} Array of command outputs
-     */
-    processCommands(Messages: Message[], ui: UI): Promise<any[]>;
-    /**
-     * Select a command to run. Must be implemented by subclasses.
-     * @param {UI} ui - UI instance for interaction
-     * @returns {Promise<string>} Command name to execute
-     * @throws {Error} Always thrown as this method must be implemented by subclasses
-     */
-    selectCommand(ui: UI): Promise<string>;
-}
-export type CommandFn = Function;
-import { Message } from '@nan0web/co';
-import UI from './UI.js';

package/types/App/Core/UI.d.ts

@@ -1,38 +0,0 @@
-/** @typedef {import("../../View/View.js").ComponentFn} ComponentFn */
-/**
- * Abstract UI class to connect apps and widgets.
- * Supports input/output data typed classes and views.
- */
-export default class UI extends Widget {
-    /**
-     * Creates a new UI instance.
-     * @param {CoreApp} app - The app to connect to this UI
-     * @param {View} [view] - View instance for rendering (default: new View())
-     */
-    constructor(app: CoreApp, view?: View);
-    /** @type {CoreApp} The app instance connected to this UI */
-    app: CoreApp;
-    /**
-     * Convert raw input to Message array.
-     * Must be implemented by subclasses.
-     * @param {any} rawInput - Raw input to convert
-     * @returns {Message[]} Array of command messages
-     * @throws {Error} Always thrown as this method must be implemented by subclasses
-     */
-    convertInput(rawInput: any): Message[];
-    /**
-     * Sets up event handlers for UI process events.
-     * @param {ComponentFn} UIProcess - Process view component
-     */
-    show(UIProcess: ComponentFn): void;
-    /**
-     * Output results to the interface.
-     * @param {any[]} results - Results to output
-     */
-    output(results: any[]): void;
-}
-export type ComponentFn = import("../../View/View.js").ComponentFn;
-import Widget from './Widget.js';
-import CoreApp from './CoreApp.js';
-import { Message } from '@nan0web/co';
-import View from '../../View/View.js';