//! Single-line text input with prompt, placeholder, blinking cursor, and //! horizontal-scroll clipping when `width` is set. //! //! Storage is a flat slice of codepoints (`u21`), with `pos` as a codepoint //! index. The embedded `Cursor` is driven by routing the parent's update //! messages through `update(allocator, msg)`; the parent kicks off cursor //! blink by calling `focus(allocator)` and including the returned Cmd. //! //! Completion suggestions (ghost text) and clipboard paste (via //! `tea.clipboard`) are supported. Not ported from bubbles: cell-width //! (as opposed to codepoint) measurement for wide glyphs, and the //! error-carrying validation surface. const std = @import("std"); const tea = @import("blacktea"); const matte = @import("matte"); const util = @import("util.zig"); const Cursor = @import("Cursor.zig"); const t = testing; const Allocator = std.mem.Allocator; const Writer = std.Io.Writer; const ArrayList = std.ArrayList; const TextInput = @This(); const EchoMode = enum { normal, password, none }; /// Returns true if the value is acceptable. The input is the codepoint /// buffer. Set `err` from this fn's caller-side or via `Validate` plumbing /// — TextInput just records pass/fail. const ValidateFn = *const fn (value: []const u21) bool; const KeyMap = struct { const key = @import("key.zig"); char_forward: key.Binding = .{ .keys = &.{ .right, .ctrl(.f) } }, char_backward: key.Binding = .{ .keys = &.{ .left, .ctrl(.b) } }, word_forward: key.Binding = .{ .keys = &.{ .alt(.f), .alt(.right), .ctrl(.right), } }, word_backward: key.Binding = .{ .keys = &.{ .alt(.b), .alt(.left), .ctrl(.left), } }, delete_word_backward: key.Binding = .{ .keys = &.{ .ctrl(.w), .alt(.backspace), .ctrl(.backspace), } }, delete_word_forward: key.Binding = .{ .keys = &.{ .alt(.d), .alt(.delete), .ctrl(.delete), } }, delete_after_cursor: key.Binding = .{ .keys = &.{.ctrl(.k)} }, delete_before_cursor: key.Binding = .{ .keys = &.{.ctrl(.u)} }, delete_char_backward: key.Binding = .{ .keys = &.{ .backspace, .ctrl(.h) } }, delete_char_forward: key.Binding = .{ .keys = &.{ .delete, .ctrl(.d) } }, line_start: key.Binding = .{ .keys = &.{ .home, .ctrl(.a) } }, line_end: key.Binding = .{ .keys = &.{ .end, .ctrl(.e) } }, paste: key.Binding = .{ .keys = &.{.ctrl(.v)} }, accept_suggestion: key.Binding = .{ .keys = &.{.tab} }, next_suggestion: key.Binding = .{ .keys = &.{ .down, .ctrl(.n) } }, prev_suggestion: key.Binding = .{ .keys = &.{ .up, .ctrl(.p) } }, }; /// Per-focus-state styles (bubbles' `StyleState`, styles.go:63-68). const StyleState = struct { text: matte.Style = .none, placeholder: matte.Style = .none, suggestion: matte.Style = .none, prompt: matte.Style = .none, }; /// Cursor styling (bubbles' `CursorStyle`, styles.go:71-96). `color` styles /// the cursor block (the fg is the cursor color for real cursors); `text_style` /// styles the cell when the cursor is blinked off (falls back to the active /// state's `text`). const CursorStyle = struct { color: matte.Style = .none, text_style: matte.Style = .none, blink: bool = true, }; /// Styles split by focus state, plus the cursor (bubbles' `Styles`, /// styles.go:50-54). `view` picks `focused`/`blurred` from `self.focused`. const Styles = struct { const style = matte.style; focused: StyleState = .{ .placeholder = style.fg(.ansi256(240)), .suggestion = style.fg(.ansi256(40)), .prompt = style.fg(.ansi256(7)), .text = .none, }, blurred: StyleState = .{ .placeholder = style.fg(.ansi256(240)), .suggestion = style.fg(.ansi256(240)), .prompt = style.fg(.ansi256(7)), .text = .none, }, cursor: CursorStyle = .{ .color = style.fg(.ansi256(7)), .blink = true, }, pub const dark: Styles = .{ .blurred = .{ .text = style.fg(.ansi256(245)), }, }; pub const light: Styles = .{ .blurred = .{ .text = style.fg(.ansi256(7)), } }; }; prompt: []const u8 = "> ", placeholder: []const u8 = "", echo_mode: EchoMode = .normal, echo_char: u21 = '*', /// Maximum number of codepoints accepted. 0 means unlimited. char_limit: usize = 0, /// Maximum visible cells for the value (excludes prompt). 0 means unlimited. width: u16 = 0, styles: Styles = .dark, key_map: KeyMap = .{}, validate: ?ValidateFn = null, /// Set by `update` to true when `validate` returned false on the latest /// edit. Caller can read this to show an error indicator. err: bool = false, /// When true (the default), the cursor cell is rendered inline by the /// embedded `Cursor` leaf (reverse-video block, blinks via tick Cmd). /// When false, the leaf renders the cell as plain text and `cursorView()` /// returns a `tea.View.Cursor` for the parent to set on its `View`. use_virtual_cursor: bool = true, /// Real-cursor shape, used only when `use_virtual_cursor` is false. cursor_shape: tea.View.Cursor.Shape = .block, /// Whether the real cursor blinks. Only used when `use_virtual_cursor` /// is false. real_cursor_blink: bool = true, value: ArrayList(u21) = .empty, focused: bool = false, /// Cursor position as a codepoint index in [0, value.items.len]. pos: usize = 0, /// Auto-completion suggestions. Caller-owned UTF-8 strings, borrowed by /// the input. Filtering is case-insensitive prefix match against `value`. show_suggestions: bool = false, suggestions: []const []const u8 = &.{}, /// Indices into `suggestions` that match the current value. Refreshed /// whenever the value changes. matched_suggestions: ArrayList(usize) = .empty, /// Index into `matched_suggestions` selecting which one is offered as /// completion / shown as ghost text. current_suggestion: usize = 0, /// Visible window into `value` when `width` clips. Indexes into `value`. offset: usize = 0, offset_right: usize = 0, cursor: Cursor = .{}, model: tea.Model = .{ .vtable = &.{ .init = vtableInit, .update = vtableUpdate, .view = vtableView, }, }, fn vtableInit(m: *tea.Model) ?tea.Cmd { const self: *TextInput = @fieldParentPtr("model", m); return self.focus(m.gpa); } fn vtableUpdate(m: *tea.Model, msg: tea.Msg) ?tea.Cmd { const self: *TextInput = @fieldParentPtr("model", m); return self.update(m.gpa, msg); } fn vtableView(m: *tea.Model, writer: *Writer) Writer.Error!tea.View { const self: *TextInput = @fieldParentPtr("model", m); try self.view(writer); return .{}; } pub fn deinit(self: *TextInput, allocator: Allocator) void { self.value.deinit(allocator); self.matched_suggestions.deinit(allocator); } /// Borrows `list`. Lifetime: caller must keep the slices alive for as /// long as the input is in use. pub fn setSuggestions(self: *TextInput, allocator: Allocator, list: []const []const u8) void { self.suggestions = list; self.refreshSuggestions(allocator); } /// Returns the byte slice of the currently-selected suggestion's tail /// (the unaccepted part), or null if there's no usable completion. pub fn currentSuggestionTail(self: *const TextInput) ?[]const u8 { if (!self.show_suggestions) return null; if (self.matched_suggestions.items.len == 0) return null; if (self.current_suggestion >= self.matched_suggestions.items.len) return null; const sug_idx = self.matched_suggestions.items[self.current_suggestion]; if (sug_idx >= self.suggestions.len) return null; const sug = self.suggestions[sug_idx]; return suggestionTail(self.value.items, sug); } fn suggestionTail(value: []const u21, suggestion: []const u8) ?[]const u8 { var iter = (std.unicode.Utf8View.init(suggestion) catch return null).iterator(); var i: usize = 0; while (i < value.len) : (i += 1) { const cp = iter.nextCodepoint() orelse return null; if (foldCase(cp) != foldCase(value[i])) return null; } return suggestion[iter.i..]; } fn foldCase(cp: u21) u21 { return if (cp >= 'A' and cp <= 'Z') cp + 32 else cp; } fn refreshSuggestions(self: *TextInput, allocator: Allocator) void { if (!self.show_suggestions) { self.matched_suggestions.clearRetainingCapacity(); self.current_suggestion = 0; return; } self.matched_suggestions.clearRetainingCapacity(); if (self.value.items.len == 0 or self.suggestions.len == 0) { self.current_suggestion = 0; return; } for (self.suggestions, 0..) |sug, idx| { if (suggestionTail(self.value.items, sug) != null) { self.matched_suggestions.append(allocator, idx) catch break; } } if (self.current_suggestion >= self.matched_suggestions.items.len) self.current_suggestion = 0; } fn acceptSuggestion(self: *TextInput, allocator: Allocator) void { const tail = self.currentSuggestionTail() orelse return; var iter = (std.unicode.Utf8View.init(tail) catch return).iterator(); while (iter.nextCodepoint()) |cp| { if (self.charLimitRemaining() == 0) break; self.value.append(allocator, cp) catch break; } self.pos = self.value.items.len; } pub fn focus(self: *TextInput, allocator: Allocator) ?tea.Cmd { self.focused = true; if (!self.use_virtual_cursor) { // Hide the virtual cursor so it doesn't schedule blink ticks. self.cursor.mode = .hide; return null; } return self.cursor.focus(allocator); } /// Toggles virtual vs real cursor. When set to false, hide the embedded /// cursor leaf and rely on the parent to plug `cursorView()` into its /// View.cursor. pub fn setVirtualCursor(self: *TextInput, use_virtual: bool) void { self.use_virtual_cursor = use_virtual; if (!use_virtual) self.cursor.mode = .hide; } /// Returns the real-cursor descriptor when `use_virtual_cursor` is false /// and the input is focused. Caller is expected to add its own y/x offset /// for the input's position within the surrounding View, then assign to /// `view.cursor`. pub fn cursorView(self: *const TextInput) ?tea.View.Cursor { if (self.use_virtual_cursor or !self.focused) return null; const prompt_w = matte.measure.cellWidth(self.prompt); const local_pos: u16 = @intCast(self.pos -| self.offset); var x: u16 = prompt_w +| local_pos; if (self.width > 0 and local_pos > self.width) x = prompt_w +| self.width; return .{ .x = x, .y = 0, .shape = self.cursor_shape, .blink = self.real_cursor_blink, }; } pub fn blur(self: *TextInput) void { self.focused = false; self.cursor.blur(); } pub fn reset(self: *TextInput) void { self.value.clearRetainingCapacity(); self.pos = 0; self.offset = 0; self.offset_right = 0; self.err = false; } pub fn setValue(self: *TextInput, allocator: Allocator, text: []const u8) !void { self.value.clearRetainingCapacity(); try appendSanitized(&self.value, allocator, text); if (self.char_limit > 0 and self.value.items.len > self.char_limit) self.value.shrinkRetainingCapacity(self.char_limit); self.pos = self.value.items.len; self.runValidate(); self.handleOverflow(); } pub fn position(self: *const TextInput) usize { return self.pos; } pub fn setCursor(self: *TextInput, pos: usize) void { self.pos = @min(pos, self.value.items.len); self.handleOverflow(); } pub fn cursorStart(self: *TextInput) void { self.setCursor(0); } pub fn cursorEnd(self: *TextInput) void { self.setCursor(self.value.items.len); } pub fn setWidth(self: *TextInput, cells: u16) void { self.width = cells; self.handleOverflow(); } /// Borrow the current codepoint buffer. Caller must not retain across /// mutating calls (`update`, `setValue`, etc.). pub fn valueCodepoints(self: *const TextInput) []const u21 { return self.value.items; } /// Encodes the current value to UTF-8 in the caller-supplied buffer. /// Returns the encoded slice. If `out` is too small, returns /// `error.NoSpaceLeft` after partially filling. pub fn encodeValue(self: *const TextInput, out: []u8) ![]u8 { var w: Writer = .fixed(out); try writeCodepoints(&w, self.value.items); return out[0..w.end]; } pub fn update(self: *TextInput, allocator: Allocator, msg: tea.Msg) ?tea.Cmd { if (!self.focused) return null; const old_pos = self.pos; var input_changed = false; switch (msg) { .key_press => |k| { if (self.key_map.delete_word_backward.matches(k)) { self.deleteWordBackward(); input_changed = true; } else if (self.key_map.delete_char_backward.matches(k)) { if (self.pos > 0 and self.value.items.len > 0) { _ = self.value.orderedRemove(self.pos - 1); self.pos -= 1; input_changed = true; } } else if (self.key_map.word_backward.matches(k)) { self.wordBackward(); } else if (self.key_map.char_backward.matches(k)) { if (self.pos > 0) self.pos -= 1; } else if (self.key_map.word_forward.matches(k)) { self.wordForward(); } else if (self.key_map.char_forward.matches(k)) { if (self.pos < self.value.items.len) self.pos += 1; } else if (self.key_map.line_start.matches(k)) { self.cursorStart(); } else if (self.key_map.delete_char_forward.matches(k)) { if (self.pos < self.value.items.len) { _ = self.value.orderedRemove(self.pos); input_changed = true; } } else if (self.key_map.delete_word_forward.matches(k)) { self.deleteWordForward(); input_changed = true; } else if (self.key_map.line_end.matches(k)) { self.cursorEnd(); } else if (self.key_map.delete_after_cursor.matches(k)) { self.value.shrinkRetainingCapacity(self.pos); input_changed = true; } else if (self.key_map.delete_before_cursor.matches(k)) { std.mem.copyForwards( u21, self.value.items[0 .. self.value.items.len - self.pos], self.value.items[self.pos..], ); self.value.shrinkRetainingCapacity(self.value.items.len - self.pos); self.pos = 0; input_changed = true; } else if (self.key_map.paste.matches(k)) { return tea.clipboard.pasteCmd(); } else if (self.key_map.accept_suggestion.matches(k)) { // Go accepts only when a suggestion is available; otherwise // the (sanitized) tab falls through to normal input. if (self.matched_suggestions.items.len > 0) { self.acceptSuggestion(allocator); input_changed = true; } else { self.insertCodepoint(allocator, ' ') catch {}; input_changed = true; } } else if (self.show_suggestions and self.key_map.next_suggestion.matches(k)) { if (self.matched_suggestions.items.len > 0) self.current_suggestion = (self.current_suggestion + 1) % self.matched_suggestions.items.len; } else if (self.show_suggestions and self.key_map.prev_suggestion.matches(k)) { if (self.matched_suggestions.items.len > 0) self.current_suggestion = (self.current_suggestion + self.matched_suggestions.items.len - 1) % self.matched_suggestions.items.len; } else if (k.kind == .rune and !k.mods.ctrl and !k.mods.alt) { self.insertCodepoint(allocator, k.codepoint) catch {}; input_changed = true; } else if (k.kind == .space) { self.insertCodepoint(allocator, ' ') catch {}; input_changed = true; } }, .paste => |text| { appendSanitizedAt(&self.value, allocator, text, self.pos, self.charLimitRemaining()) catch {}; self.pos = countCodepointsUntilOriginal(&self.value, text, self.pos); input_changed = true; }, else => {}, } if (input_changed) { self.runValidate(); self.refreshSuggestions(allocator); } self.handleOverflow(); var cmd = self.cursor.update(allocator, msg); if (old_pos != self.pos and self.cursor.mode == .blink) { // Reset the blink so cursor movement feels snappy. self.cursor.is_blinked = false; } if (cmd == null and self.focused and self.cursor.mode == .blink and !self.cursor.running) cmd = self.cursor.focus(allocator); return cmd; } /// The style state matching the current focus (bubbles picks focused/blurred). fn activeState(self: *const TextInput) StyleState { return if (self.focused) self.styles.focused else self.styles.blurred; } /// Configures the embedded cursor's styles from `styles.cursor` and the active /// state's text style (used for the blinked-off cell). fn applyCursorStyle(self: *TextInput, ss: StyleState) void { self.cursor.style = self.styles.cursor.color; const styled = self.styles.cursor.text_style.hasAnyStyling(); self.cursor.text_style = if (styled) self.styles.cursor.text_style else ss.text; } pub fn view(self: *TextInput, writer: *Writer) Writer.Error!void { const ss = self.activeState(); if (self.value.items.len == 0 and self.placeholder.len > 0) { try self.placeholderView(writer); return; } try util.writeInline(writer, ss.prompt, self.prompt); const visible = self.visibleSlice(); const local_pos = if (self.pos > self.offset) self.pos - self.offset else 0; // Text before the cursor. try self.writeTransformed(writer, visible[0..@min(local_pos, visible.len)]); // Cursor cell. With a real cursor, render plain text; the parent's // View.cursor handles drawing the cursor itself. var cur_buf: [4]u8 = undefined; if (local_pos < visible.len) { const cp = visible[local_pos]; const masked = self.echoCp(cp); const len = std.unicode.utf8Encode(masked, &cur_buf) catch 1; if (self.use_virtual_cursor) { self.cursor.char = cur_buf[0..len]; self.applyCursorStyle(ss); try self.cursor.view(writer); } else { try util.writeInline(writer, ss.text, cur_buf[0..len]); } // Text after the cursor. try self.writeTransformed(writer, visible[local_pos + 1 ..]); } else if (self.use_virtual_cursor and self.focused) { // At end of value: ghost cursor either holds the first char of an // unaccepted suggestion (if any) or a space. Suggestions only render // while focused (textinput.go:705). if (self.currentSuggestionTail()) |tail| { var t_iter = (std.unicode.Utf8View.init(tail) catch unreachable).iterator(); if (t_iter.nextCodepoint()) |cp| { const len = std.unicode.utf8Encode(cp, &cur_buf) catch 1; self.cursor.char = cur_buf[0..len]; self.cursor.style = self.styles.cursor.color; self.cursor.text_style = ss.suggestion; try self.cursor.view(writer); try util.writeInline(writer, ss.suggestion, tail[len..]); } else { self.cursor.char = " "; self.applyCursorStyle(ss); try self.cursor.view(writer); } } else { self.cursor.char = " "; self.applyCursorStyle(ss); try self.cursor.view(writer); } } else { // Real cursor mode: still render the ghost text inline while focused. if (self.focused) { if (self.currentSuggestionTail()) |tail| { try util.writeInline(writer, ss.suggestion, tail); } } } // Width-padding (so a styled background extends to the configured width). if (self.width > 0 and ss.text.hasAnyStyling()) { const visible_cells: u16 = @intCast(visible.len); var pad: u16 = if (self.width > visible_cells) self.width - visible_cells else 0; if (local_pos < visible.len) {} else if (pad > 0) pad -= 1; // cursor occupied a cell if (pad > 0) { try util.writeInline(writer, ss.text, ""); var i: u16 = 0; while (i < pad) : (i += 1) try writer.writeByte(' '); try writer.writeAll("\x1b[0m"); } } } fn placeholderView(self: *TextInput, w: *Writer) Writer.Error!void { const ss = self.activeState(); try util.writeInline(w, ss.prompt, self.prompt); // First placeholder codepoint sits under the cursor; the rest renders // styled with `placeholder`. Real-cursor mode just renders the // placeholder verbatim and lets the parent draw the cursor on top. var iter = (std.unicode.Utf8View.init(self.placeholder) catch return).iterator(); const first_cp = iter.nextCodepoint() orelse { if (self.use_virtual_cursor) { self.cursor.char = " "; self.cursor.style = self.styles.cursor.color; self.cursor.text_style = ss.placeholder; try self.cursor.view(w); } return; }; var cur_buf: [4]u8 = undefined; const len = std.unicode.utf8Encode(first_cp, &cur_buf) catch 1; if (self.use_virtual_cursor) { self.cursor.char = cur_buf[0..len]; self.cursor.style = self.styles.cursor.color; self.cursor.text_style = ss.placeholder; try self.cursor.view(w); } else { try util.writeInline(w, ss.placeholder, cur_buf[0..len]); } const rest = self.placeholder[len..]; try util.writeInline(w, ss.placeholder, rest); // Pad to width so the placeholder area stays a fixed width when set. if (self.width > 0) { const ph_cells = matte.measure.cellWidth(self.placeholder); if (ph_cells < self.width) { const pad = self.width - ph_cells; var i: u16 = 0; while (i < pad) : (i += 1) try w.writeByte(' '); } } } fn writeTransformed(self: *TextInput, writer: *Writer, cps: []const u21) Writer.Error!void { if (self.echo_mode == .none) return; if (cps.len == 0) return; const text_style = self.activeState().text; const fg: ?matte.Color = text_style.internal.foreground; if (fg) |c| try c.writeSgr(writer, .fg); var buf: [4]u8 = undefined; for (cps) |cp| { const masked = self.echoCp(cp); const len = std.unicode.utf8Encode(masked, &buf) catch 1; try writer.writeAll(buf[0..len]); } if (fg) |_| try writer.writeAll("\x1b[0m"); } fn echoCp(self: *const TextInput, cp: u21) u21 { return switch (self.echo_mode) { .normal => cp, .password => self.echo_char, .none => ' ', }; } fn visibleSlice(self: *const TextInput) []const u21 { if (self.offset_right == 0 or self.offset_right > self.value.items.len) return self.value.items[self.offset..]; return self.value.items[self.offset..self.offset_right]; } fn handleOverflow(self: *TextInput) void { if (self.width == 0 or self.value.items.len <= self.width) { self.offset = 0; self.offset_right = self.value.items.len; return; } self.offset_right = @min(self.offset_right, self.value.items.len); if (self.pos < self.offset) { self.offset = self.pos; self.offset_right = @min(self.offset + self.width, self.value.items.len); } else if (self.pos >= self.offset_right) { self.offset_right = self.pos; self.offset = if (self.offset_right > self.width) self.offset_right - self.width else 0; } } fn charLimitRemaining(self: *const TextInput) usize { if (self.char_limit == 0) return std.math.maxInt(usize); if (self.value.items.len >= self.char_limit) return 0; return self.char_limit - self.value.items.len; } fn insertCodepoint(self: *TextInput, allocator: Allocator, cp: u21) !void { if (self.charLimitRemaining() == 0) return; try self.value.insert(allocator, self.pos, cp); self.pos += 1; } fn runValidate(self: *TextInput) void { if (self.validate) |v| self.err = !v(self.value.items) else self.err = false; } // ---- word movement ---- fn isWordSep(cp: u21) bool { return cp == ' ' or cp == '\t' or cp == '\n'; } fn wordBackward(self: *TextInput) void { if (self.pos == 0 or self.value.items.len == 0) return; if (self.echo_mode != .normal) { self.cursorStart(); return; } var i = self.pos; // Skip trailing separators just left of the cursor. while (i > 0 and isWordSep(self.value.items[i - 1])) : (i -= 1) {} // Skip the word. while (i > 0 and !isWordSep(self.value.items[i - 1])) : (i -= 1) {} self.pos = i; } fn wordForward(self: *TextInput) void { if (self.pos >= self.value.items.len) return; if (self.echo_mode != .normal) { self.cursorEnd(); return; } var i = self.pos; // Skip separators at the cursor. while (i < self.value.items.len and isWordSep(self.value.items[i])) : (i += 1) {} // Skip the word. while (i < self.value.items.len and !isWordSep(self.value.items[i])) : (i += 1) {} self.pos = i; } fn deleteWordBackward(self: *TextInput) void { if (self.pos == 0 or self.value.items.len == 0) return; if (self.echo_mode != .normal) { std.mem.copyForwards( u21, self.value.items[0 .. self.value.items.len - self.pos], self.value.items[self.pos..], ); self.value.shrinkRetainingCapacity(self.value.items.len - self.pos); self.pos = 0; return; } const start = self.pos; self.wordBackward(); const end = start; const dst = self.value.items[self.pos .. self.value.items.len - (end - self.pos)]; std.mem.copyForwards(u21, dst, self.value.items[end..]); self.value.shrinkRetainingCapacity(self.value.items.len - (end - self.pos)); } fn deleteWordForward(self: *TextInput) void { if (self.pos >= self.value.items.len or self.value.items.len == 0) return; if (self.echo_mode != .normal) { // Masked input: reveal nothing, wipe everything after the cursor // (Go's deleteAfterCursor). self.value.shrinkRetainingCapacity(self.pos); return; } const start = self.pos; self.wordForward(); const end = self.pos; self.pos = start; const dst = self.value.items[self.pos .. self.value.items.len - (end - self.pos)]; std.mem.copyForwards(u21, dst, self.value.items[end..]); self.value.shrinkRetainingCapacity(self.value.items.len - (end - self.pos)); } // ---- helpers ---- fn appendSanitized(list: *ArrayList(u21), allocator: Allocator, text: []const u8) !void { var iter = (std.unicode.Utf8View.init(text) catch return).iterator(); while (iter.nextCodepoint()) |cp| { const safe: u21 = if (cp == '\n' or cp == '\t' or cp == '\r') ' ' else cp; if (safe < 0x20 and safe != ' ') continue; // drop other control chars try list.append(allocator, safe); } } fn appendSanitizedAt( list: *ArrayList(u21), allocator: Allocator, text: []const u8, at: usize, max_to_insert: usize, ) !void { var iter = (std.unicode.Utf8View.init(text) catch return).iterator(); var inserted: usize = 0; var insert_at = at; while (iter.nextCodepoint()) |cp| { if (inserted >= max_to_insert) break; const safe: u21 = if (cp == '\n' or cp == '\t' or cp == '\r') ' ' else cp; if (safe < 0x20 and safe != ' ') continue; try list.insert(allocator, insert_at, safe); insert_at += 1; inserted += 1; } } fn countCodepointsUntilOriginal(list: *ArrayList(u21), text: []const u8, start: usize) usize { _ = list; var iter = (std.unicode.Utf8View.init(text) catch return start).iterator(); var n: usize = 0; while (iter.nextCodepoint()) |cp| { if (cp < 0x20 and cp != ' ' and cp != '\n' and cp != '\t' and cp != '\r') continue; n += 1; } return start + n; } fn writeCodepoints(w: *Writer, cps: []const u21) Writer.Error!void { var buf: [4]u8 = undefined; for (cps) |cp| { const len = std.unicode.utf8Encode(cp, &buf) catch 1; try w.writeAll(buf[0..len]); } } // ---- tests ---- const testing = std.testing; test "setValue / encodeValue roundtrip" { var ti: TextInput = .{}; defer ti.deinit(testing.allocator); try ti.setValue(testing.allocator, "hello"); var buf: [16]u8 = undefined; const out = try ti.encodeValue(&buf); try testing.expectEqualStrings("hello", out); try testing.expectEqual(@as(usize, 5), ti.pos); } test "char_limit truncates setValue" { var ti: TextInput = .{ .char_limit = 3 }; defer ti.deinit(testing.allocator); try ti.setValue(testing.allocator, "abcdef"); try testing.expectEqual(@as(usize, 3), ti.value.items.len); try testing.expectEqual(@as(usize, 3), ti.pos); } test "backspace removes codepoint before cursor" { var ti: TextInput = .{}; defer ti.deinit(testing.allocator); try ti.setValue(testing.allocator, "abc"); ti.cursor.mode = .static; // skip blink-tick allocation _ = ti.focus(testing.allocator); const bs: tea.Msg = .{ .key_press = .{ .kind = .backspace } }; _ = ti.update(testing.allocator, bs); try testing.expectEqual(@as(usize, 2), ti.value.items.len); try testing.expectEqual(@as(u21, 'b'), ti.value.items[1]); try testing.expectEqual(@as(usize, 2), ti.pos); } test "char_forward / char_backward respects bounds" { var ti: TextInput = .{}; defer ti.deinit(testing.allocator); try ti.setValue(testing.allocator, "ab"); ti.cursor.mode = .static; // skip blink-tick allocation _ = ti.focus(testing.allocator); ti.cursorStart(); const right: tea.Msg = .{ .key_press = .right }; const left: tea.Msg = .{ .key_press = .left }; _ = ti.update(testing.allocator, right); _ = ti.update(testing.allocator, right); _ = ti.update(testing.allocator, right); // clamped try testing.expectEqual(@as(usize, 2), ti.pos); _ = ti.update(testing.allocator, left); _ = ti.update(testing.allocator, left); _ = ti.update(testing.allocator, left); // clamped try testing.expectEqual(@as(usize, 0), ti.pos); } test "wordBackward jumps past spaces" { var ti: TextInput = .{}; defer ti.deinit(testing.allocator); try ti.setValue(testing.allocator, "foo bar baz"); ti.cursor.mode = .static; // skip blink-tick allocation _ = ti.focus(testing.allocator); ti.cursorEnd(); const ab: tea.Msg = .{ .key_press = .alt(.b) }; _ = ti.update(testing.allocator, ab); try testing.expectEqual(@as(usize, 8), ti.pos); // start of "baz" _ = ti.update(testing.allocator, ab); try testing.expectEqual(@as(usize, 4), ti.pos); // start of "bar" } test "validate sets err flag" { const Validators = struct { fn nonEmpty(v: []const u21) bool { return v.len > 0; } }; var ti: TextInput = .{ .validate = Validators.nonEmpty }; defer ti.deinit(testing.allocator); try ti.setValue(testing.allocator, ""); try testing.expect(ti.err); try ti.setValue(testing.allocator, "x"); try testing.expect(!ti.err); } test "suggestion match + accept" { var ti: TextInput = .{ .show_suggestions = true }; defer ti.deinit(testing.allocator); ti.cursor.mode = .static; _ = ti.focus(testing.allocator); const sugs = [_][]const u8{ "apple", "apricot", "banana" }; ti.setSuggestions(testing.allocator, &sugs); try ti.setValue(testing.allocator, "ap"); ti.refreshSuggestions(testing.allocator); try testing.expectEqual(@as(usize, 2), ti.matched_suggestions.items.len); try testing.expectEqualStrings("ple", ti.currentSuggestionTail().?); ti.acceptSuggestion(testing.allocator); var buf: [16]u8 = undefined; const out = try ti.encodeValue(&buf); try testing.expectEqualStrings("apple", out); } test "deleteWordForward removes word after cursor" { var ti: TextInput = .{}; defer ti.deinit(testing.allocator); ti.cursor.mode = .static; _ = ti.focus(testing.allocator); try ti.setValue(testing.allocator, "foo bar baz"); ti.cursorStart(); const ad: tea.Msg = .{ .key_press = .alt(.d) }; _ = ti.update(testing.allocator, ad); var buf: [32]u8 = undefined; try testing.expectEqualStrings(" bar baz", try ti.encodeValue(&buf)); _ = ti.update(testing.allocator, ad); // skips the space, deletes "bar" try testing.expectEqualStrings(" baz", try ti.encodeValue(&buf)); _ = ti.update(testing.allocator, ad); // skips the space, deletes "baz" try testing.expectEqualStrings("", try ti.encodeValue(&buf)); } test "tab without matched suggestion inserts a space" { var ti: TextInput = .{}; defer ti.deinit(testing.allocator); ti.cursor.mode = .static; _ = ti.focus(testing.allocator); const tab: tea.Msg = .{ .key_press = .tab }; _ = ti.update(testing.allocator, tab); var buf: [16]u8 = undefined; try testing.expectEqualStrings(" ", try ti.encodeValue(&buf)); } test "tab accepts suggestion when one matches" { var ti: TextInput = .{ .show_suggestions = true }; defer ti.deinit(testing.allocator); ti.cursor.mode = .static; _ = ti.focus(testing.allocator); const sugs = [_][]const u8{"apple"}; ti.setSuggestions(testing.allocator, &sugs); try ti.setValue(testing.allocator, "ap"); ti.refreshSuggestions(testing.allocator); const tab: tea.Msg = .{ .key_press = .tab }; _ = ti.update(testing.allocator, tab); var buf: [16]u8 = undefined; try testing.expectEqualStrings("apple", try ti.encodeValue(&buf)); } test "suggestion cycle next" { var ti: TextInput = .{ .show_suggestions = true }; defer ti.deinit(testing.allocator); ti.cursor.mode = .static; _ = ti.focus(testing.allocator); const sugs = [_][]const u8{ "alpha", "alpine", "alabaster" }; ti.setSuggestions(testing.allocator, &sugs); try ti.setValue(testing.allocator, "al"); ti.refreshSuggestions(testing.allocator); try testing.expectEqual(@as(usize, 3), ti.matched_suggestions.items.len); try testing.expectEqualStrings("pha", ti.currentSuggestionTail().?); const down: tea.Msg = .{ .key_press = .down }; _ = ti.update(testing.allocator, down); try testing.expectEqualStrings("pine", ti.currentSuggestionTail().?); } test "echo password masks output" { var ti: TextInput = .{ .echo_mode = .password, .echo_char = '*' }; defer ti.deinit(testing.allocator); try ti.setValue(testing.allocator, "abc"); var buf: [256]u8 = undefined; var w: Writer = .fixed(&buf); try ti.view(&w); // Prompt then three '*' then a cursor space — accept any cursor styling. try testing.expect(std.mem.indexOf(u8, w.buffered(), "***") != null); } test "blurred text is dimmed but focused text is not" { var ti: TextInput = .{}; defer ti.deinit(testing.allocator); ti.cursor.mode = .static; ti.use_virtual_cursor = false; // avoid virtual cursor cell in output try ti.setValue(testing.allocator, "abc"); // Focused: text carries no foreground (focused Text is unstyled). _ = ti.focus(testing.allocator); var fbuf: [256]u8 = undefined; var fw: Writer = .fixed(&fbuf); try ti.view(&fw); try testing.expect(std.mem.indexOf(u8, fw.buffered(), "\x1b[38;5;245m") == null); // Blurred: text is dimmed with ANSI 245 (dark default). ti.blur(); var bbuf: [256]u8 = undefined; var bw: Writer = .fixed(&bbuf); try ti.view(&bw); try testing.expect(std.mem.indexOf(u8, bw.buffered(), "\x1b[38;5;245m") != null); } test "light styles dim blurred text with ANSI 7" { var ti: TextInput = .{ .styles = .light }; defer ti.deinit(testing.allocator); ti.cursor.mode = .static; ti.use_virtual_cursor = false; try ti.setValue(testing.allocator, "hi"); ti.blur(); var buf: [256]u8 = undefined; var w: Writer = .fixed(&buf); try ti.view(&w); // Light blurred text foreground is ANSI 7 (not the dark 245). try testing.expect(std.mem.indexOf(u8, w.buffered(), "\x1b[38;5;7m") != null); try testing.expect(std.mem.indexOf(u8, w.buffered(), "\x1b[38;5;245m") == null); }