@nan0web/ui-cli 1.1.1 → 2.0.0

package/src/ui/form.js

@@ -4,10 +4,11 @@
  * @module ui/form
  */
 
-import { CancelError } from "@nan0web/ui/core"
-import { createInput, Input } from "./input.js"
-import { select } from "./select.js"
-import { UiForm, FormInput } from "@nan0web/ui"
+import { CancelError } from '@nan0web/ui/core'
+import { createInput, Input } from './input.js'
+import { select } from './select.js'
+import { autocomplete } from './autocomplete.js'
+import { UiForm, FormInput } from '@nan0web/ui'
 
 /**
  * Generates a UiForm instance from a Body class static schema.
@@ -27,33 +28,33 @@ export function generateForm(BodyClass, options = {}) {
 	const fields = []
 
 	for (const [name, schema] of Object.entries(BodyClass)) {
-		if (typeof schema !== "object" || schema === null) continue
+		if (typeof schema !== 'object' || schema === null) continue
 
-		const translate = (value) => (typeof t === "function" ? t(value) : value)
+		const translate = (value) => (typeof t === 'function' ? t(value) : value)
 
 		fields.push(
 			new FormInput({
 				name,
 				label: translate(schema.help || name),
-				type: schema.type || "text",
+				type: schema.type || 'text',
 				required: Boolean(schema.required),
-				placeholder: translate(schema.placeholder || schema.defaultValue || ""),
+				placeholder: translate(schema.placeholder || schema.defaultValue || ''),
 				options: schema.options
 					? schema.options.map((opt) =>
-						typeof opt === "string"
-							? opt
-							: opt.label
-								? { label: opt.label, value: opt.value }
-								: opt,
-					)
+							typeof opt === 'string'
+								? opt
+								: opt.label
+									? { label: opt.label, value: opt.value }
+									: opt
+						)
 					: [],
 				validation: schema.validate
 					? (value) => {
-						const res = schema.validate(value)
-						return res === true ? true : typeof res === "string" ? res : `Invalid ${name}`
-					}
+							const res = schema.validate(value)
+							return res === true ? true : typeof res === 'string' ? res : `Invalid ${name}`
+						}
 					: () => true,
-			}),
+			})
 		)
 	}
 
@@ -82,15 +83,22 @@ export default class Form {
 	 * @param {Object} [options={}] - Options.
 	 * @param {string[]} [options.stops=["quit", "cancel", "exit"]] - Stop words.
 	 * @param {(prompt: string) => Promise<Input>} [options.inputFn] - Custom input function.
+	 * @param {(config: object) => Promise<{index:number, value:any}>} [options.selectFn] - Custom select function.
+	 * @param {(config: object) => Promise<{value: number, cancelled: boolean}>} [options.sliderFn] - Custom slider function.
+	 * @param {(config: object) => Promise<{value: boolean, cancelled: boolean}>} [options.toggleFn] - Custom toggle function.
+	 * @param {Function} [options.t] - Optional translation function.
 	 * @throws {TypeError} If model is not an object with a constructor.
 	 */
 	constructor(model, options = {}) {
-		if (!model || typeof model !== "object" || !model.constructor) {
-			throw new TypeError("Form requires a model instance with a constructor")
+		if (!model || typeof model !== 'object' || !model.constructor) {
+			throw new TypeError('Form requires a model instance with a constructor')
 		}
 		this.#model = model
-		const { stops = ["quit", "cancel", "exit"], inputFn } = options
+		this.options = options
+		const { stops = ['quit', 'cancel', 'exit'], inputFn, selectFn, t = (k) => k } = options
+		this.t = t
 		this.handler = inputFn || createInput(stops)
+		this.select = selectFn || select
 		this.#fields = this.#generateFields()
 	}
 
@@ -103,25 +111,41 @@ export default class Form {
 		const Class = this.#model.constructor
 		const fields = []
 		for (const [name, schema] of Object.entries(Class)) {
-			if (typeof schema !== "object" || schema === null) continue
+			if (typeof schema !== 'object' || schema === null) continue
 			const isRequired = schema.required === true || schema.defaultValue === undefined
-			const placeholder = schema.placeholder || schema.defaultValue || ""
+			const placeholder = this.t(String(schema.placeholder || schema.defaultValue || ''))
 			const options = schema.options || []
-			const validation = schema.validate
+
+			// Support both 'validate' and 'validator' (validator takes precedence)
+			const validateFn = schema.validator || schema.validate
+			const validation = validateFn
 				? (value) => {
-					const res = schema.validate(value)
-					if (res === true) return true
-					if (typeof res === "string") return res
-					return `Invalid ${name}`
-				}
+						try {
+							const res = validateFn(value)
+							if (res === true) return true
+							if (res === false) return `${this.t('validate.error')} ${name}`
+							if (typeof res === 'string') return this.t(res)
+							return `${this.t('validate.error')} ${name}`
+						} catch (error) {
+							const err = /** @type {Error} */ (error)
+							return err.message || `${this.t('validate.error')} ${name}`
+						}
+					}
 				: () => true
+
 			fields.push({
 				name,
-				label: schema.help || name,
-				type: schema.type || "text",
+				label: this.t(schema.help || name),
+				type: schema.type || 'text',
 				required: isRequired,
 				placeholder,
-				options,
+				min: schema.min,
+				max: schema.max,
+				step: schema.step,
+				options: options.map((opt) => {
+					if (typeof opt === 'string') return { label: this.t(opt), value: opt }
+					return { ...opt, label: this.t(opt.label) }
+				}),
 				validation,
 			})
 		}
@@ -144,14 +168,8 @@ export default class Form {
 		return new Form(model, options)
 	}
 
-	/**
-	 * Prompts for selection using the provided configuration.
-	 *
-	 * @param {Object} config - Selection configuration.
-	 * @returns {Promise<{index:number, value:any}>} Selected option.
-	 */
-	async select(config) {
-		return select(config)
+	get fields() {
+		return this.#fields
 	}
 
 	/**
@@ -177,20 +195,54 @@ export default class Form {
 		while (idx < this.#fields.length) {
 			const field = this.#fields[idx]
 			const currentValue = this.#model[field.name] ?? field.placeholder
-			const prompt = `${field.label}${field.required ? " *" : ""} [${currentValue}]: `
+			const prompt = `${field.label}${field.required ? ' *' : ''} [${currentValue}]: `
 			try {
-				if (field.options.length > 0) {
+				if (field.options.length > 0 || field.type === 'autocomplete') {
 					const selConfig = {
 						title: field.label,
-						prompt: "Choose (number): ",
-						options: field.options.map((opt) =>
-							typeof opt === "string" ? opt : opt.label ? { label: opt.label, value: opt.value } : opt,
-						),
-						console: { info: console.info.bind(console) },
+						message: field.label,
+						prompt: `${this.t('Select')}: `,
+						options: field.options,
+						console: /** @type {any} */ (this.options).console || {
+							info: (msg) => process.stdout.write(msg + '\n'),
+						},
 						ask: this.handler,
 					}
-					const selResult = await this.select(selConfig)
-					const val = selResult.value
+					let val
+					if (field.type === 'autocomplete') {
+						const autoResult = await autocomplete(selConfig)
+						val = autoResult.value
+					} else {
+						const selResult = await this.select(selConfig)
+						val = selResult.value
+					}
+
+					const validRes = field.validation(val)
+					if (validRes !== true) {
+						console.error(`\n${validRes}`)
+						continue
+					}
+					this.#model[field.name] = this.convertValue(field, val)
+					idx++
+				} else if (
+					field.type === 'number' &&
+					field.min !== undefined &&
+					field.max !== undefined &&
+					/** @type {any} */ (this.options).sliderFn
+				) {
+					// Use slider for number fields with range
+					const sliderConfig = {
+						message: field.label,
+						min: field.min,
+						max: field.max,
+						step: field.step || 1,
+						initial: Number(currentValue) || field.min,
+					}
+					const sliderResult = await /** @type {any} */ (this.options).sliderFn(sliderConfig)
+					if (sliderResult && sliderResult.cancelled) {
+						return { cancelled: true }
+					}
+					const val = sliderResult ? sliderResult.value : currentValue
 					const validRes = field.validation(val)
 					if (validRes !== true) {
 						console.error(`\n${validRes}`)
@@ -198,14 +250,27 @@ export default class Form {
 					}
 					this.#model[field.name] = this.convertValue(field, val)
 					idx++
+				} else if (field.type === 'toggle' && /** @type {any} */ (this.options).toggleFn) {
+					// Use toggle for boolean fields
+					const toggleConfig = {
+						message: field.label,
+						initial: currentValue === 'true' || currentValue === true,
+					}
+					const toggleResult = await /** @type {any} */ (this.options).toggleFn(toggleConfig)
+					if (toggleResult && toggleResult.cancelled) {
+						return { cancelled: true }
+					}
+					const val = toggleResult ? toggleResult.value : currentValue
+					idx++ // Toggles don't fail validation usually
+					this.#model[field.name] = val
 				} else {
 					const inputObj = await this.input(prompt)
 					if (inputObj.cancelled) {
 						return { cancelled: true }
 					}
 					let answer = inputObj.value.trim()
-					if (answer === "" && !field.required) {
-						this.#model[field.name] = ""
+					if (answer === '' && !field.required) {
+						this.#model[field.name] = ''
 						idx++
 						continue
 					}
@@ -236,12 +301,12 @@ export default class Form {
 	 */
 	convertValue(field, value) {
 		const schema = this.#model.constructor[field.name]
-		const type = schema?.type || typeof (schema?.defaultValue ?? "string")
+		const type = schema?.type || typeof (schema?.defaultValue ?? 'string')
 		switch (type) {
-			case "number":
+			case 'number':
 				return Number(value) || 0
-			case "boolean":
-				return value.toLowerCase() === "true"
+			case 'boolean':
+				return value.toLowerCase() === 'true'
 			default:
 				return String(value)
 		}

package/src/ui/index.js

@@ -1,4 +1,18 @@
-export { Input } from "./input.js"
-export { createInput, ask } from "./input.js"
-export { select, default as baseSelect } from "./select.js"
-export { next, pause } from "./next.js"
+export { Input, text, createInput, ask } from './input.js'
+export { select, select as baseSelect } from './select.js'
+export { confirm, confirm as baseConfirm } from './confirm.js'
+export { next, pause } from './next.js'
+export { autocomplete, autocomplete as baseAutocomplete } from './autocomplete.js'
+export { table, table as baseTable } from './table.js'
+export { multiselect, multiselect as baseMultiselect } from './multiselect.js'
+export { mask, mask as baseMask } from './mask.js'
+export { toggle, toggle as baseToggle } from './toggle.js'
+export { slider, slider as baseSlider } from './slider.js'
+export { progress, ProgressBar, progress as baseProgress } from './progress.js'
+export { spinner, Spinner, spinner as baseSpinner } from './spinner.js'
+export { badge } from './badge.js'
+export { alert } from './alert.js'
+export { toast } from './toast.js'
+export { breadcrumbs, tabs, steps } from './nav.js'
+export { tree } from './tree.js'
+export { datetime } from './date-time.js'

package/src/ui/input.js

@@ -4,32 +4,16 @@
  * @module ui/input
  */
 
-import { createInterface } from "node:readline"
-import { stdin, stdout } from "node:process"
-import { CancelError } from "@nan0web/ui"
-
-/** @typedef {import("./select.js").ConsoleLike} ConsoleLike */
-/** @typedef {(input: Input) => Promise<boolean>} LoopFn */
-/** @typedef {(input: Input) => string} NextQuestionFn */
+import prompts from 'prompts'
+import { CancelError } from '@nan0web/ui/core'
+import process from 'node:process'
+import { validateString, validateFunction } from '../core/PropValidation.js'
 
 /**
- * Input function.
- * ---
- * Must be used only as a type — typedef does not work with full arguments description for functions.
- * ---
- * @param {string} question - Prompt displayed to the user.
- * @param {boolean | LoopFn} [loop=false] - Loop‑control flag, validator or boolean that forces a single answer.
- * @param {string | NextQuestionFn} [nextQuestion] - When `false` the prompt ends after one answer.
- *                                            When a `function` is supplied it receives the current {@link Input}
- *                                            and must return a new question string for the next iteration.
- *
- * @returns {Promise<Input>} Resolves with an {@link Input} instance that contains the final answer,
- *                           the raw value and cancellation state.
- *
- * @throws {Error} May propagate errors from the underlying readline interface.
+ * Triggers a system beep (ASCII Bell).
  */
-export async function InputFn(question, loop = false, nextQuestion = undefined) {
-	return new Input()
+export function beep() {
+	process.stdout.write('\u0007')
 }
 
 /**
@@ -42,181 +26,124 @@ export async function InputFn(question, loop = false, nextQuestion = undefined)
  */
 export class Input {
 	/** @type {string} */
-	value = ""
+	value = ''
 	/** @type {string[]} */
 	stops = []
 	#cancelled = false
 
-	/**
-	 * Create a new {@link Input} instance.
-	 *
-	 * @param {Object} [input={}] - Optional initial values.
-	 * @param {string} [input.value] - Initial answer string.
-	 * @param {boolean} [input.cancelled] - Initial cancel flag.
-	 * @param {string|string[]} [input.stops] - Words that trigger cancellation.
-	 */
 	constructor(input = {}) {
-		const {
-			value = this.value,
-			cancelled = this.#cancelled,
-			stops = [],
-		} = input
-
+		const { value = this.value, cancelled = this.#cancelled, stops = [] } = input
 		this.value = String(value)
-
-		const normalizedStops = Array.isArray(stops) ? stops : [stops].filter(Boolean)
-		this.stops = normalizedStops.map(String)
-
+		this.stops = stops
 		this.#cancelled = Boolean(cancelled)
 	}
 
-	/**
-	 * Returns whether the input has been cancelled either explicitly or via a stop word.
-	 *
-	 * @returns {boolean}
-	 */
 	get cancelled() {
 		return this.#cancelled || this.stops.includes(this.value)
 	}
 
-	/** @returns {string} The raw answer value. */
 	toString() {
 		return this.value
 	}
 }
 
 /**
- * Low‑level prompt that returns a trimmed string.
- *
- * @param {Object} input
- * @param {string} input.question - Text displayed as a prompt.
- * @param {string} [input.predef] - Optional predefined answer (useful for testing).
- * @param {ConsoleLike} [input.console] - Optional console to show predefined value
- * @param {import("node:readline").Interface} [input.rl] - Readline interface instnace
- * @returns {Promise<string>} The answer without surrounding whitespace.
+ * Modern text input with validation and default value.
  *
- * When `predef` is supplied the function mimics the usual readline output
- * (`question + answer + newline`) and returns the trimmed value.
+ * @param {Object} config
+ * @param {string} config.message - Prompt question
+ * @param {string} [config.initial] - Default value
+ * @param {string} [config.type] - Prompt type (text, password, etc)
+ * @param {(value:string)=>boolean|string|Promise<boolean|string>} [config.validate] - Validator
+ * @param {(value:string)=>string} [config.format] - Formatter
+ * @returns {Promise<{value:string, cancelled:boolean}>}
  */
-export async function _askRaw(input) {
-	const {
-		question,
-		predef = undefined,
-		console,
-		rl: initialRL,
-	} = input
-	// Fast‑path for predefined answers – mimic readline output.
-	if (typeof predef === "string") {
-		if (console) {
-			console.info(`${question}${predef}\n`)
-		} else {
-			process.stdout.write(`${question}${predef}\n`)
+export async function text(config) {
+	validateString(config.message, 'message', 'Input.text', true)
+	validateString(config.initial, 'initial', 'Input.text')
+	validateFunction(config.validate, 'validate', 'Input.text')
+	validateFunction(config.format, 'format', 'Input.text')
+
+	const { message, initial, validate, type = 'text', format } = config
+	const response = await prompts(
+		{
+			type: type,
+			name: 'value',
+			message,
+			initial,
+			validate,
+			format,
+		},
+		{
+			onCancel: () => {
+				throw new CancelError()
+			},
 		}
-		return predef.trim()
-	}
+	)
 
-	return new Promise(resolve => {
-		const rl = initialRL ?? createInterface({ input: stdin, output: stdout, terminal: true })
-		rl.question(question, answer => {
-			rl.close()
-			resolve(answer.trim())
-		})
-	})
+	return { value: response.value, cancelled: response.value === undefined }
 }
 
 /**
  * Factory that creates a reusable async input handler.
+ * Adapter for legacy ask() signature.
  *
  * @param {string[]} [stops=[]] Words that trigger cancellation.
  * @param {string|undefined} [predef] Optional predefined answer for testing.
- * @param {ConsoleLike} [console] Optional console instance.
- * @returns {InputFn} Async function that resolves to an {@link Input}.
+ * @param {Object} [console] Optional console instance.
+ * @param {(input: Input) => Promise<boolean>|boolean} [loop] Optional loop validator.
+ * @returns {Function} Async function that resolves to an {@link Input}.
  */
-export function createInput(stops = [], predef = undefined, console = undefined) {
-	const input = new Input({ stops })
-
-	/**
-	 * Internal handler used by the factory.
-	 *
-	 * @param {string} question - Prompt displayed to the user.
-	 * @param {boolean | LoopFn} [loop=false] - Loop‑control flag or validator.
-	 * @param {string | NextQuestionFn} [nextQuestion=false] - Next prompt generator or its value.
-	 * @returns {Promise<Input>}
-	 */
-	async function fn(question, loop = false, nextQuestion = undefined) {
-		let currentQuestion = question
-		while (true) {
-			input.value = await _askRaw({ question: currentQuestion, predef, console })
-
-			if (false === loop || input.cancelled) return input
-			if (true === loop && input.value) return input
-			if (typeof loop === "function") {
-				const cont = await loop(input)
-				if (!cont) return input
+export function createInput(stops = [], predef = undefined, console = undefined, loop = undefined) {
+	return async function ask(question, loopVal = loop, nextQuestion = undefined) {
+		const currentLoop = typeof loopVal === 'function' ? loopVal : loop
+		if (predef !== undefined) {
+			prompts.inject([predef])
+		}
+
+		// Map options to prompts config
+		let validationFn = undefined
+
+		if (typeof currentLoop === 'function') {
+			validationFn = async (val) => {
+				if (stops.includes(val)) return true
+				// Loop returns true to CONTINUE (invalid), false to STOP (valid).
+				// prompts returns true for VALID, string/false for INVALID.
+				const inputObj = new Input({ value: val, stops })
+				if (inputObj.cancelled) return true
+
+				const shouldContinue = await currentLoop(inputObj)
+				return shouldContinue ? 'Invalid input' : true
 			}
-			if (typeof nextQuestion === "string") currentQuestion = nextQuestion
-			if (typeof nextQuestion === "function") currentQuestion = nextQuestion(input)
 		}
+
+		const result = await text({
+			message: question,
+			validate: validationFn,
+		})
+
+		return new Input({ value: result.value, stops })
 	}
-	return fn
 }
 
 /**
  * High‑level input helper `ask`.
- *
- * This constant inherits the full {@link InputFn} signature **and** the
- * detailed JSDoc description for each argument, as defined in {@link InputFn}.
- *
- * @type {InputFn}
+ * Use this for simple string prompts.
  */
 export const ask = createInput()
 
 /**
- * @param {string[]} predefined
- * @param {ConsoleLike} console
- * @param {string[]} [stops=[]]
- * @returns {import("./select.js").InputFn}
- * @throws {CancelError}
+ * Mock helper for predefined inputs (Testing).
  */
 export function createPredefinedInput(predefined, console, stops = []) {
 	const strPredefined = predefined.map(String)
-	const input = new Input({ stops })
 	let index = 0
-	return async function predefinedHandler(question, loop = false, nextQuestion = undefined) {
-		let currentQuestion = question
-		while (true) {
-			if (index >= strPredefined.length) {
-				throw new CancelError("No more predefined answers")
-			}
-			const predef = strPredefined[index++]
-			if (console) {
-				console.info(`${currentQuestion}${predef}\n`)
-			} else {
-				process.stdout.write(`${currentQuestion}${predef}\n`)
-			}
-			input.value = predef.trim()
-			if (input.cancelled) {
-				return input
-			}
-			if (false === loop) {
-				return input
-			}
-			if (true === loop && input.value) {
-				return input
-			}
-			if (typeof loop === "function") {
-				const cont = await loop(input)
-				if (!cont) {
-					return input
-				}
-			}
-			if (typeof nextQuestion === "string") {
-				currentQuestion = nextQuestion
-			} else if (typeof nextQuestion === "function") {
-				currentQuestion = nextQuestion(input)
-			}
+	return async function (question) {
+		if (index >= strPredefined.length) {
+			throw new CancelError('No more predefined answers')
 		}
+		const val = strPredefined[index++]
+		if (console) console.info(`${question}${val}`)
+		return new Input({ value: val, stops })
 	}
 }
-
-export default createInput