bare-tui-form 0.0.0 → 0.0.2

package/fields/number.js

@@ -0,0 +1,60 @@
+// number — a numeric field. Wraps textinput for entry, but value() coerces to a
+// Number and syncValidate() enforces numeric-ness plus optional min/max/integer.
+const { textinput } = require('bare-tui')
+const { Field } = require('./base')
+
+class NumberField extends Field {
+  constructor(opts = {}) {
+    super(opts)
+    this.min = opts.min
+    this.max = opts.max
+    this.integer = !!opts.integer
+    this.control = textinput.create({
+      value: opts.value === undefined || opts.value === null ? '' : String(opts.value),
+      placeholder: opts.placeholder || '',
+      prompt: opts.prompt ?? '> '
+    })
+  }
+
+  // null when blank, a finite Number when parseable, otherwise NaN (so
+  // syncValidate() can flag it; an unflagged NaN would JSON-serialize to null).
+  value() {
+    const raw = this.control.value.trim()
+    if (raw === '') return null
+    return Number(raw)
+  }
+
+  setValue(v) {
+    this.control.setValue(v === undefined || v === null ? '' : String(v))
+    return this
+  }
+
+  isEmpty(v) {
+    return v === null
+  }
+
+  // The numeric rules live here (not in validate()) because the form validates
+  // through syncValidate — both on enter-confirm and on submit.
+  syncValidate(v) {
+    // Base handles required + empty + any custom validator first.
+    const base = super.syncValidate(v)
+    if (base) return base
+
+    if (v === null) return null // optional and blank
+    if (Number.isNaN(v)) return 'must be a number'
+    if (this.integer && !Number.isInteger(v)) return 'must be a whole number'
+    if (this.min !== undefined && v < this.min) return `must be ≥ ${this.min}`
+    if (this.max !== undefined && v > this.max) return `must be ≤ ${this.max}`
+    return null
+  }
+
+  controlView() {
+    return this.control.view()
+  }
+}
+
+function number(opts) {
+  return new NumberField(opts)
+}
+
+module.exports = { number, NumberField }

package/fields/radio.js

@@ -0,0 +1,32 @@
+// radio — pick one from an expanded list, wrapping bare-tui's radio.
+const { radio } = require('bare-tui')
+const { Field } = require('./base')
+
+class RadioField extends Field {
+  constructor(opts = {}) {
+    super(opts)
+    this.control = radio.create({
+      options: opts.options || [],
+      selected: opts.selected || 0
+    })
+  }
+
+  value() {
+    return this.control.value()
+  }
+
+  setValue(v) {
+    this.control.setValue(v)
+    return this
+  }
+
+  controlView() {
+    return this.control.view()
+  }
+}
+
+function radio_(opts) {
+  return new RadioField(opts)
+}
+
+module.exports = { radio: radio_, RadioField }

package/fields/section.js

@@ -0,0 +1,71 @@
+// section — the include/omit toggle for an optional nested-object section.
+//
+// A non-required object in a schema becomes a sub-section the user can choose to
+// fill in or leave out. This field is its gate: a focusable checkbox rendered as
+// the section's heading. The form:
+//
+//   - auto-checks it the moment any field inside the section gets a value,
+//   - omits the whole subtree from value() while it's unchecked,
+//   - and only validates the section's inner `required` fields while it's on.
+//
+// So the user is in control — start typing and the section is "in", toggle the
+// box off to drop it — and the fields stay visible the whole time (no dynamic
+// show/hide). It never carries a value of its own; `isSection` tells the form to
+// treat it as a gate, not a leaf, and it never blocks submission itself.
+const { checkbox } = require('bare-tui')
+const { Field } = require('./base')
+
+class SectionToggleField extends Field {
+  constructor(opts = {}) {
+    super(opts)
+    this.isSection = true
+    this.control = checkbox.create({
+      label: opts.title || opts.label || this.key,
+      checked: !!opts.value
+    })
+  }
+
+  get checked() {
+    return this.control.checked
+  }
+
+  value() {
+    return this.control.checked
+  }
+
+  setValue(v) {
+    this.control.setChecked(v)
+    return this
+  }
+
+  // A section gate is never itself required and never reports an error — the
+  // completeness of an included section is enforced by its own inner fields.
+  requiredError() {
+    return null
+  }
+
+  syncValidate() {
+    return null
+  }
+
+  controlView() {
+    return this.control.view()
+  }
+
+  // Renders as the section heading: the checkbox + title, with a quiet hint when
+  // it's off so it's clear the section won't be submitted.
+  view() {
+    const t = this.theme
+    const head = t.sectionTitle(this.control.view())
+    const hint = this.control.checked ? '' : '  ' + t.help('(off — not included)')
+    const lines = [head + hint]
+    if (this.description) lines.push(t.description(this.description))
+    return lines.join('\n')
+  }
+}
+
+function section(opts) {
+  return new SectionToggleField(opts)
+}
+
+module.exports = { section, SectionToggleField }

package/fields/select.js

@@ -0,0 +1,46 @@
+// select — pick one from a dropdown, wrapping bare-tui's select.
+//
+// It forwards the control's overlay (menuView) so the form can composite the
+// dropdown, and claims enter while the menu is open (to commit the choice).
+const { select } = require('bare-tui')
+const { Field } = require('./base')
+
+class SelectField extends Field {
+  constructor(opts = {}) {
+    super(opts)
+    this.control = select.create({
+      options: opts.options || [],
+      selected: opts.selected ?? -1,
+      placeholder: opts.placeholder || 'select…',
+      maxVisible: opts.maxVisible || 6
+    })
+  }
+
+  value() {
+    return this.control.value()
+  }
+
+  setValue(v) {
+    this.control.setValue(v)
+    return this
+  }
+
+  // While the menu is open, enter commits the highlighted option.
+  wantsEnter() {
+    return this.control.open
+  }
+
+  menuView() {
+    return this.control.menuView()
+  }
+
+  controlView() {
+    return this.control.view()
+  }
+}
+
+function select_(opts) {
+  return new SelectField(opts)
+}
+
+module.exports = { select: select_, SelectField }

package/fields/text.js

@@ -0,0 +1,35 @@
+// text — a single-line text field, wrapping bare-tui's textinput.
+const { textinput } = require('bare-tui')
+const { Field } = require('./base')
+
+class TextField extends Field {
+  constructor(opts = {}) {
+    super(opts)
+    this.control = textinput.create({
+      value: opts.value || '',
+      placeholder: opts.placeholder || '',
+      prompt: opts.prompt ?? '> ',
+      charLimit: opts.charLimit || 0,
+      echoMode: opts.echoMode || 'normal'
+    })
+  }
+
+  value() {
+    return this.control.value
+  }
+
+  setValue(v) {
+    this.control.setValue(v === null || v === undefined ? '' : v)
+    return this
+  }
+
+  controlView() {
+    return this.control.view()
+  }
+}
+
+function text(opts) {
+  return new TextField(opts)
+}
+
+module.exports = { text, TextField }

package/fields/textarea.js

@@ -0,0 +1,43 @@
+// textarea — a multi-line text field, wrapping bare-tui's textarea.
+//
+// Unlike the other fields it *captures enter* (newline), so the form moves on
+// via tab rather than enter.
+const { textarea } = require('bare-tui')
+const { Field } = require('./base')
+
+class TextareaField extends Field {
+  constructor(opts = {}) {
+    super(opts)
+    this.control = textarea.create({
+      value: opts.value || '',
+      placeholder: opts.placeholder || '',
+      width: opts.width || 40,
+      height: opts.rows || opts.height || 4, // `rows` mirrors uiSchema's ui:rows
+      charLimit: opts.charLimit || 0
+    })
+  }
+
+  value() {
+    return this.control.value
+  }
+
+  setValue(v) {
+    this.control.setValue(v === null || v === undefined ? '' : v)
+    return this
+  }
+
+  // Enter inserts a newline here; advance with tab instead.
+  wantsEnter() {
+    return true
+  }
+
+  controlView() {
+    return this.control.view()
+  }
+}
+
+function textarea_(opts) {
+  return new TextareaField(opts)
+}
+
+module.exports = { textarea: textarea_, TextareaField }