Something went wrong. Try again.
A charm-like tui library
Something went wrong. Try again.
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145//! Multi-line text editor. Each line is an `ArrayList(u21)` of codepoints;//! `(row, col)` track the cursor in those coordinates. Vertical scroll is//! built in; horizontal overflow is truncated (no soft-wrap in v1).//!//! v1 scope: char/word/line navigation, insert + delete, optional line//! numbers, prompt prefix per line, placeholder when empty, char limit,//! line-cap, paste handling. Skipped from bubbles: soft-wrap with the//! memoization cache, prompt function, dynamic height, transpose, case//! change, real-cursor mode, clipboard paste cmd.const std = @import("std");const matcha = @import("matcha");const blush = @import("blush");const key = @import("key.zig");const util = @import("util.zig");const Cursor = @import("Cursor.zig");
const Allocator = std.mem.Allocator;const Writer = std.Io.Writer;const Cmd = matcha.Cmd;const Msg = matcha.Msg;const ArrayList = std.ArrayList;
const Textarea = @This();
pub const KeyMap = struct { char_forward: key.Binding = .{ .keys = &.{ key.special(.right), key.ctrl('f') } }, char_backward: key.Binding = .{ .keys = &.{ key.special(.left), key.ctrl('b') } }, word_forward: key.Binding = .{ .keys = &.{ key.alt('f') } }, word_backward: key.Binding = .{ .keys = &.{ key.alt('b') } }, line_next: key.Binding = .{ .keys = &.{ key.special(.down), key.ctrl('n') } }, line_previous: key.Binding = .{ .keys = &.{ key.special(.up), key.ctrl('p') } }, delete_word_backward: key.Binding = .{ .keys = &.{key.ctrl('w')} }, delete_word_forward: key.Binding = .{ .keys = &.{key.alt('d')} }, delete_after_cursor: key.Binding = .{ .keys = &.{key.ctrl('k')} }, delete_before_cursor: key.Binding = .{ .keys = &.{key.ctrl('u')} }, insert_newline: key.Binding = .{ .keys = &.{ key.special(.enter), key.ctrl('m') } }, delete_char_backward: key.Binding = .{ .keys = &.{ key.special(.backspace), key.ctrl('h') } }, delete_char_forward: key.Binding = .{ .keys = &.{key.special(.delete)} }, line_start: key.Binding = .{ .keys = &.{ key.special(.home), key.ctrl('a') } }, line_end: key.Binding = .{ .keys = &.{ key.special(.end), key.ctrl('e') } }, page_up: key.Binding = .{ .keys = &.{key.special(.page_up)} }, page_down: key.Binding = .{ .keys = &.{key.special(.page_down)} }, input_begin: key.Binding = .{ .keys = &.{ key.alt('<') } }, input_end: key.Binding = .{ .keys = &.{ key.alt('>') } }, paste: key.Binding = .{ .keys = &.{key.ctrl('v')} }, transpose_char_backward: key.Binding = .{ .keys = &.{key.ctrl('t')} }, uppercase_word_forward: key.Binding = .{ .keys = &.{key.alt('u')} }, lowercase_word_forward: key.Binding = .{ .keys = &.{key.alt('l')} }, capitalize_word_forward: key.Binding = .{ .keys = &.{key.alt('c')} },};
pub const Styles = struct { text: ?blush.Style = null, prompt: ?blush.Style = null, placeholder: ?blush.Style = null, line_number: ?blush.Style = null, cursor: ?blush.Style = null, cursor_text: ?blush.Style = null,};
pub const default_styles: Styles = .{ .prompt = .{ .foreground = .{ .ansi256 = 7 } }, .placeholder = .{ .foreground = .{ .ansi256 = 240 } }, .line_number = .{ .foreground = .{ .ansi256 = 7 } },};
model: matcha.Model = .{ .vtable = &vtable },
prompt: []const u8 = "│ ",placeholder: []const u8 = "",show_line_numbers: bool = true,end_of_buffer: u8 = '~',
/// Maximum total codepoints (across all lines, excluding newlines). 0 = no/// limit.char_limit: usize = 0,/// Hard cap on the number of stored lines; insertion beyond this is dropped.max_lines: usize = 10_000,
width: u16 = 40,height: u16 = 6,/// When true, `height` auto-resizes between `min_height` and `max_height`/// to fit the line count after each edit.dynamic_height: bool = false,min_height: u16 = 1,max_height: u16 = 99,/// When true, lines wider than the content width wrap onto continuation/// rows instead of being truncated. `y_offset` counts visual rows./// Vertical nav (`line_previous`/`line_next`) moves by visual rows too.soft_wrap: bool = false,/// Mouse wheel scrolls the viewport by this many rows per notch. Set to 0/// to disable mouse-wheel scroll.mouse_wheel_delta: u16 = 3,
styles: Styles = default_styles,key_map: KeyMap = .{},cursor_blink: Cursor = .{},
/// When true, the cursor cell is rendered inline by the embedded `Cursor`/// leaf. When false, the editor renders the cell as plain text and the/// parent reads `cursorView()` to drive a real terminal cursor.use_virtual_cursor: bool = true,/// Real-cursor shape, used only when `use_virtual_cursor` is false.cursor_shape: matcha.View.Cursor.Shape = .block,/// Whether the real cursor blinks. Only used when `use_virtual_cursor`/// is false.real_cursor_blink: bool = true,
lines: ArrayList(ArrayList(u21)) = .empty,focused: bool = false,
/// Cursor row (line index) and column (codepoint index inside that line).row: usize = 0,col: usize = 0,
/// Visible-column intent retained across vertical movements so up/down/// preserves the user's logical column over jagged lines.last_col_offset: usize = 0,
y_offset: usize = 0,
const vtable: matcha.Model.VTable = .{ .init = vtableInit, .update = vtableUpdate, .view = vtableView,};
fn vtableInit(m: *matcha.Model) ?Cmd { const self: *Textarea = @fieldParentPtr("model", m); return self.focus(m.gpa);}
fn vtableUpdate(m: *matcha.Model, msg: Msg) ?Cmd { const self: *Textarea = @fieldParentPtr("model", m); return self.update(m.gpa, msg);}
fn vtableView(m: *matcha.Model, w: *Writer) Writer.Error!matcha.View { const self: *Textarea = @fieldParentPtr("model", m); try self.view(w); return .{};}
pub fn deinit(self: *Textarea, allocator: Allocator) void { for (self.lines.items) |*line| line.deinit(allocator); self.lines.deinit(allocator);}
pub fn focus(self: *Textarea, allocator: Allocator) ?Cmd { self.focused = true; if (!self.use_virtual_cursor) { self.cursor_blink.mode = .hide; return null; } return self.cursor_blink.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: *Textarea, use_virtual: bool) void { self.use_virtual_cursor = use_virtual; if (!use_virtual) self.cursor_blink.mode = .hide;}
/// Returns the real-cursor descriptor when `use_virtual_cursor` is false/// and the textarea is focused. The (x, y) is local to the textarea's/// rendered output; the parent should add its own offsets before/// assigning to `view.cursor`.pub fn cursorView(self: *const Textarea) ?matcha.View.Cursor { if (self.use_virtual_cursor or !self.focused) return null; const cur_vrow = self.cursorVisualRow(); if (cur_vrow < self.y_offset) return null; const local_vrow = cur_vrow - self.y_offset; if (local_vrow >= self.height) return null;
const prompt_w = blush.measure.cellWidth(self.prompt); const ln_w = self.lineNumberWidth(); const vcol: usize = if (self.soft_wrap) blk: { const cw = self.contentCellsLeft(); break :blk if (cw == 0) self.col else self.col % cw; } else self.col;
const x: u16 = prompt_w +| ln_w +| @as(u16, @intCast(vcol)); return .{ .x = x, .y = @intCast(local_vrow), .shape = self.cursor_shape, .blink = self.real_cursor_blink, };}
pub fn blur(self: *Textarea) void { self.focused = false; self.cursor_blink.blur();}
pub fn reset(self: *Textarea, allocator: Allocator) void { for (self.lines.items) |*line| line.deinit(allocator); self.lines.clearRetainingCapacity(); self.row = 0; self.col = 0; self.y_offset = 0; self.last_col_offset = 0;}
pub fn setValue(self: *Textarea, allocator: Allocator, text: []const u8) !void { self.reset(allocator); try self.insertText(allocator, text); self.row = self.lines.items.len -| 1; self.col = if (self.lines.items.len > 0) self.lines.items[self.row].items.len else 0; self.last_col_offset = self.col; self.ensureRowVisible();}
pub fn setWidth(self: *Textarea, w: u16) void { self.width = w;}
pub fn setHeight(self: *Textarea, h: u16) void { self.height = h; self.ensureRowVisible();}
pub fn lineCount(self: *const Textarea) usize { return self.lines.items.len;}
/// Total codepoint count across all lines (newlines not counted).pub fn length(self: *const Textarea) usize { var n: usize = 0; for (self.lines.items) |line| n += line.items.len; return n;}
pub fn cursorPosition(self: *const Textarea) struct { row: usize, col: usize } { return .{ .row = self.row, .col = self.col };}
/// Encodes the value (lines joined by `\n`) into `out`. Returns the/// encoded slice; `error.NoSpaceLeft` when `out` is too small.pub fn encodeValue(self: *const Textarea, out: []u8) ![]u8 { var w: Writer = .fixed(out); var first = true; var buf: [4]u8 = undefined; for (self.lines.items) |line| { if (!first) try w.writeByte('\n'); for (line.items) |cp| { const len = std.unicode.utf8Encode(cp, &buf) catch 1; try w.writeAll(buf[0..len]); } first = false; } return out[0..w.end];}
pub fn update(self: *Textarea, allocator: Allocator, msg: Msg) ?Cmd { if (!self.focused) return null;
const old_row = self.row; const old_col = self.col;
switch (msg) { .key_press => |k| { if (self.key_map.delete_word_backward.matches(k)) { self.deleteWordBackward(allocator); } else if (self.key_map.delete_word_forward.matches(k)) { self.deleteWordForward(allocator); } else if (self.key_map.delete_char_backward.matches(k)) { self.deleteCharBackward(allocator); } else if (self.key_map.delete_char_forward.matches(k)) { self.deleteCharForward(allocator); } else if (self.key_map.delete_after_cursor.matches(k)) { self.deleteAfterCursor(); } else if (self.key_map.delete_before_cursor.matches(k)) { self.deleteBeforeCursor(allocator); } else if (self.key_map.word_backward.matches(k)) { self.wordBackward(); } else if (self.key_map.word_forward.matches(k)) { self.wordForward(); } else if (self.key_map.char_backward.matches(k)) { self.charBackward(); } else if (self.key_map.char_forward.matches(k)) { self.charForward(); } else if (self.key_map.line_previous.matches(k)) { self.linePrevious(); } else if (self.key_map.line_next.matches(k)) { self.lineNext(); } else if (self.key_map.line_start.matches(k)) { self.lineStartAction(); } else if (self.key_map.line_end.matches(k)) { self.lineEndAction(); } else if (self.key_map.page_up.matches(k)) { self.pageUp(); } else if (self.key_map.page_down.matches(k)) { self.pageDown(); } else if (self.key_map.input_begin.matches(k)) { self.row = 0; self.col = 0; self.last_col_offset = 0; } else if (self.key_map.input_end.matches(k)) { self.row = self.lines.items.len -| 1; self.col = if (self.lines.items.len > 0) self.lines.items[self.row].items.len else 0; self.last_col_offset = self.col; } else if (self.key_map.insert_newline.matches(k)) { self.insertNewline(allocator) catch {}; } else if (self.key_map.transpose_char_backward.matches(k)) { self.transposeCharBackward(); } else if (self.key_map.uppercase_word_forward.matches(k)) { self.transformWordForward(.upper); } else if (self.key_map.lowercase_word_forward.matches(k)) { self.transformWordForward(.lower); } else if (self.key_map.capitalize_word_forward.matches(k)) { self.transformWordForward(.capitalize); } else if (self.key_map.paste.matches(k)) { return matcha.clipboard.pasteCmd(); } else if (k.kind == .rune and !k.mods.ctrl and !k.mods.alt) { self.insertCodepoint(allocator, k.rune) catch {}; } else if (k.kind == .space) { self.insertCodepoint(allocator, ' ') catch {}; } else if (k.kind == .tab) { self.insertCodepoint(allocator, '\t') catch {}; } }, .paste => |text| { self.insertText(allocator, text) catch {}; }, .mouse_wheel => |m| { if (self.mouse_wheel_delta == 0) return null; switch (m.button) { .wheel_up => self.scrollViewUp(self.mouse_wheel_delta), .wheel_down => self.scrollViewDown(self.mouse_wheel_delta), else => {}, } }, else => {}, }
self.recalculateHeight(); self.ensureRowVisible();
var cmd = self.cursor_blink.update(allocator, msg); if ((old_row != self.row or old_col != self.col) and self.cursor_blink.mode == .blink) { self.cursor_blink.is_blinked = false; } if (cmd == null and self.focused and self.cursor_blink.mode == .blink and !self.cursor_blink.running) cmd = self.cursor_blink.focus(allocator); return cmd;}
pub fn view(self: *Textarea, w: *Writer) Writer.Error!void { if (self.height == 0 or self.width == 0) return;
if (self.lines.items.len == 0 and self.placeholder.len > 0 and !self.focused) { try util.writeInline(w, self.styles.prompt, self.prompt); try util.writeInline(w, self.styles.placeholder, self.placeholder); return; }
// Lazily ensure at least one (possibly empty) line so cursor rendering // has something to anchor on. if (self.lines.items.len == 0) { try self.writeLine(w, 0, &.{}); var i: u16 = 1; while (i < self.height) : (i += 1) { try w.writeByte('\n'); try self.writeEndOfBuffer(w); } return; }
if (self.soft_wrap) { try self.viewSoftWrap(w); } else { try self.viewHardCut(w); }}
fn viewHardCut(self: *Textarea, w: *Writer) Writer.Error!void { const start = self.y_offset; const end = @min(start + self.height, self.lines.items.len);
var rendered: u16 = 0; var idx = start; while (idx < end) : (idx += 1) { if (rendered > 0) try w.writeByte('\n'); try self.writeLine(w, idx, self.lines.items[idx].items); rendered += 1; } while (rendered < self.height) : (rendered += 1) { try w.writeByte('\n'); try self.writeEndOfBuffer(w); }}
fn viewSoftWrap(self: *Textarea, w: *Writer) Writer.Error!void { const content_w = self.contentCellsLeft(); if (content_w == 0) return;
var skipped: usize = 0; var rendered: u16 = 0; var line_idx: usize = 0; while (line_idx < self.lines.items.len and rendered < self.height) : (line_idx += 1) { const line = self.lines.items[line_idx].items; const rows = visualRowsForLine(line.len, content_w); var chunk: usize = 0; while (chunk < rows and rendered < self.height) : (chunk += 1) { if (skipped < self.y_offset) { skipped += 1; continue; } if (rendered > 0) try w.writeByte('\n'); try self.writeChunk(w, line_idx, line, chunk, content_w); rendered += 1; } } while (rendered < self.height) : (rendered += 1) { if (rendered > 0) try w.writeByte('\n'); try self.writeEndOfBuffer(w); }}
fn writeChunk( self: *Textarea, w: *Writer, line_idx: usize, line: []const u21, chunk_idx: usize, content_w: u16,) Writer.Error!void { try util.writeInline(w, self.styles.prompt, self.prompt); if (self.show_line_numbers) { if (chunk_idx == 0) { try self.writeLineNumber(w, line_idx); } else { // Continuation row: blank pad matching line-number width. const ln_w = self.lineNumberWidth(); var i: u16 = 0; while (i < ln_w) : (i += 1) try w.writeByte(' '); } }
const start_cp: usize = chunk_idx * content_w; const end_cp: usize = @min(start_cp + content_w, line.len); const is_cursor_line = line_idx == self.row and self.focused; const cursor_col = if (is_cursor_line) self.col else line.len;
var emitted: u16 = 0; var cur_buf: [4]u8 = undefined; var i: usize = start_cp; while (i < end_cp) : (i += 1) { if (emitted >= content_w) break; if (i == cursor_col and self.use_virtual_cursor) { const len = std.unicode.utf8Encode(line[i], &cur_buf) catch 1; self.cursor_blink.char = cur_buf[0..len]; self.cursor_blink.style = self.styles.cursor; self.cursor_blink.text_style = self.styles.cursor_text orelse self.styles.text; try self.cursor_blink.view(w); emitted += 1; continue; } const len = std.unicode.utf8Encode(line[i], &cur_buf) catch 1; if (self.styles.text) |s| try openInlineStyle(w, s); try w.writeAll(cur_buf[0..len]); if (self.styles.text) |s| try closeInlineStyle(w, s); emitted += 1; }
// Cursor at end of line on the last chunk. if (is_cursor_line and cursor_col == line.len and end_cp == line.len and emitted < content_w and self.use_virtual_cursor) { self.cursor_blink.char = " "; self.cursor_blink.style = self.styles.cursor; self.cursor_blink.text_style = self.styles.cursor_text orelse self.styles.text; try self.cursor_blink.view(w); }}
fn visualRowsForLine(len: usize, content_w: u16) usize { if (content_w == 0 or len == 0) return 1; return (len + content_w - 1) / content_w;}
// ---- editing ----
fn insertCodepoint(self: *Textarea, allocator: Allocator, cp: u21) !void { if (self.atCharLimit()) return; if (self.lines.items.len == 0) try self.lines.append(allocator, .empty); try self.lines.items[self.row].insert(allocator, self.col, cp); self.col += 1; self.last_col_offset = self.col;}
fn insertNewline(self: *Textarea, allocator: Allocator) !void { if (self.lines.items.len >= self.max_lines) return; if (self.lines.items.len == 0) try self.lines.append(allocator, .empty);
// Split current line at col. var current = &self.lines.items[self.row]; var new_line: ArrayList(u21) = .empty; if (self.col < current.items.len) { try new_line.appendSlice(allocator, current.items[self.col..]); current.shrinkRetainingCapacity(self.col); } try self.lines.insert(allocator, self.row + 1, new_line); self.row += 1; self.col = 0; self.last_col_offset = 0;}
fn insertText(self: *Textarea, allocator: Allocator, text: []const u8) !void { if (self.lines.items.len == 0) try self.lines.append(allocator, .empty); var iter = (std.unicode.Utf8View.init(text) catch return).iterator(); while (iter.nextCodepoint()) |cp| { if (self.atCharLimit()) break; if (cp == '\n') { try self.insertNewline(allocator); } else if (cp == '\r') { // ignore } else if (cp < 0x20 and cp != '\t') { // drop other control chars } else { try self.lines.items[self.row].insert(allocator, self.col, cp); self.col += 1; } } self.last_col_offset = self.col;}
fn deleteCharBackward(self: *Textarea, allocator: Allocator) void { if (self.lines.items.len == 0) return; if (self.col > 0) { _ = self.lines.items[self.row].orderedRemove(self.col - 1); self.col -= 1; } else if (self.row > 0) { // Merge current line into previous. var prev = &self.lines.items[self.row - 1]; const new_col = prev.items.len; var current = self.lines.items[self.row]; prev.appendSlice(allocator, current.items) catch {}; current.deinit(allocator); _ = self.lines.orderedRemove(self.row); self.row -= 1; self.col = new_col; } self.last_col_offset = self.col;}
fn deleteCharForward(self: *Textarea, allocator: Allocator) void { if (self.lines.items.len == 0) return; var line = &self.lines.items[self.row]; if (self.col < line.items.len) { _ = line.orderedRemove(self.col); } else if (self.row + 1 < self.lines.items.len) { // Merge next line into current. var next = self.lines.items[self.row + 1]; line.appendSlice(allocator, next.items) catch {}; next.deinit(allocator); _ = self.lines.orderedRemove(self.row + 1); } self.last_col_offset = self.col;}
fn deleteAfterCursor(self: *Textarea) void { if (self.lines.items.len == 0) return; self.lines.items[self.row].shrinkRetainingCapacity(self.col); self.last_col_offset = self.col;}
fn deleteBeforeCursor(self: *Textarea, allocator: Allocator) void { if (self.lines.items.len == 0 or self.col == 0) return; var line = &self.lines.items[self.row]; std.mem.copyForwards( u21, line.items[0 .. line.items.len - self.col], line.items[self.col..], ); line.shrinkRetainingCapacity(line.items.len - self.col); self.col = 0; self.last_col_offset = 0; _ = allocator;}
fn deleteWordBackward(self: *Textarea, allocator: Allocator) void { if (self.lines.items.len == 0 or (self.col == 0 and self.row == 0)) return; const start_row = self.row; const start_col = self.col; self.wordBackward(); if (self.row == start_row) { var line = &self.lines.items[self.row]; std.mem.copyForwards( u21, line.items[self.col .. line.items.len - (start_col - self.col)], line.items[start_col..], ); line.shrinkRetainingCapacity(line.items.len - (start_col - self.col)); } else { // Word movement crossed a line boundary; bridge by deleting line by // line via repeated backspace. while (self.row != start_row or self.col != start_col) { // walk forward, then issue a single delete-back loop break; } // Fallback: do the simpler line-merge erase. // Erase from new (row, col) to (start_row, start_col). // Approach: first wipe to end of current line, then merge until reach start_row. var first = &self.lines.items[self.row]; first.shrinkRetainingCapacity(self.col); var i = self.row + 1; while (i < start_row) : (i += 1) { var rm = self.lines.orderedRemove(self.row + 1); rm.deinit(allocator); } // Merge remainder of start_row (after start_col) into self.row. if (self.row + 1 < self.lines.items.len) { var tail = self.lines.orderedRemove(self.row + 1); defer tail.deinit(allocator); if (start_col < tail.items.len) { self.lines.items[self.row].appendSlice(allocator, tail.items[start_col..]) catch {}; } } } self.last_col_offset = self.col;}
fn deleteWordForward(self: *Textarea, allocator: Allocator) void { if (self.lines.items.len == 0) return; const start_row = self.row; const start_col = self.col; self.wordForward(); const end_row = self.row; const end_col = self.col; self.row = start_row; self.col = start_col; if (start_row == end_row) { var line = &self.lines.items[self.row]; std.mem.copyForwards( u21, line.items[start_col .. line.items.len - (end_col - start_col)], line.items[end_col..], ); line.shrinkRetainingCapacity(line.items.len - (end_col - start_col)); } else { // Erase from (start_row, start_col) through (end_row, end_col). self.lines.items[start_row].shrinkRetainingCapacity(start_col); var i: usize = start_row + 1; while (i < end_row) : (i += 1) { var rm = self.lines.orderedRemove(start_row + 1); rm.deinit(allocator); } if (start_row + 1 < self.lines.items.len) { var tail = self.lines.orderedRemove(start_row + 1); defer tail.deinit(allocator); if (end_col < tail.items.len) { self.lines.items[start_row].appendSlice(allocator, tail.items[end_col..]) catch {}; } } } self.last_col_offset = self.col;}
// ---- navigation ----
fn charBackward(self: *Textarea) void { if (self.col > 0) { self.col -= 1; } else if (self.row > 0) { self.row -= 1; self.col = self.lines.items[self.row].items.len; } self.last_col_offset = self.col;}
fn charForward(self: *Textarea) void { if (self.lines.items.len == 0) return; if (self.col < self.lines.items[self.row].items.len) { self.col += 1; } else if (self.row + 1 < self.lines.items.len) { self.row += 1; self.col = 0; } self.last_col_offset = self.col;}
fn linePrevious(self: *Textarea) void { if (self.soft_wrap) { const cw = self.contentCellsLeft(); if (cw > 0 and self.col >= cw) { // Move up one visual row within the current logical line. self.col -= cw; return; } } if (self.row == 0) return; self.row -= 1; const prev = self.lines.items[self.row].items.len; if (self.soft_wrap) { const cw = self.contentCellsLeft(); if (cw > 0) { const last_vrow = visualRowsForLine(prev, cw) - 1; const intent_vcol = self.last_col_offset % cw; const new_col = last_vrow * cw + intent_vcol; self.col = @min(new_col, prev); return; } } self.col = @min(self.last_col_offset, prev);}
fn lineNext(self: *Textarea) void { if (self.lines.items.len == 0) return; if (self.soft_wrap) { const cw = self.contentCellsLeft(); const line_len = self.lines.items[self.row].items.len; if (cw > 0) { const this_vrow = self.col / cw; const last_vrow = visualRowsForLine(line_len, cw) - 1; if (this_vrow < last_vrow) { self.col = @min(self.col + cw, line_len); return; } } } if (self.row + 1 >= self.lines.items.len) return; self.row += 1; const next_len = self.lines.items[self.row].items.len; if (self.soft_wrap) { const cw = self.contentCellsLeft(); if (cw > 0) { const intent_vcol = self.last_col_offset % cw; self.col = @min(intent_vcol, next_len); return; } } self.col = @min(self.last_col_offset, next_len);}
fn lineStartAction(self: *Textarea) void { self.col = 0; self.last_col_offset = 0;}
fn lineEndAction(self: *Textarea) void { if (self.lines.items.len == 0) return; self.col = self.lines.items[self.row].items.len; self.last_col_offset = self.col;}
fn pageUp(self: *Textarea) void { self.row = if (self.row > self.height) self.row - self.height else 0; if (self.lines.items.len > 0) self.col = @min(self.last_col_offset, self.lines.items[self.row].items.len);}
fn pageDown(self: *Textarea) void { if (self.lines.items.len == 0) return; self.row = @min(self.row + self.height, self.lines.items.len - 1); self.col = @min(self.last_col_offset, self.lines.items[self.row].items.len);}
fn wordBackward(self: *Textarea) void { if (self.lines.items.len == 0) return; if (self.col == 0) { if (self.row == 0) return; self.row -= 1; self.col = self.lines.items[self.row].items.len; } const line = self.lines.items[self.row].items; var i = self.col; while (i > 0 and isWordSep(line[i - 1])) : (i -= 1) {} while (i > 0 and !isWordSep(line[i - 1])) : (i -= 1) {} self.col = i; self.last_col_offset = self.col;}
fn wordForward(self: *Textarea) void { if (self.lines.items.len == 0) return; var line = self.lines.items[self.row].items; if (self.col >= line.len) { if (self.row + 1 >= self.lines.items.len) return; self.row += 1; self.col = 0; line = self.lines.items[self.row].items; } var i = self.col; while (i < line.len and isWordSep(line[i])) : (i += 1) {} while (i < line.len and !isWordSep(line[i])) : (i += 1) {} self.col = i; self.last_col_offset = self.col;}
fn isWordSep(cp: u21) bool { return cp == ' ' or cp == '\t';}
const WordTransform = enum { upper, lower, capitalize };
fn transposeCharBackward(self: *Textarea) void { if (self.lines.items.len == 0) return; const line = &self.lines.items[self.row]; if (line.items.len < 2) return; if (self.col == 0) return; // If cursor is at end, swap last two and don't advance. const at_end = self.col >= line.items.len; const i = if (at_end) line.items.len - 1 else self.col; if (i == 0) return; const tmp = line.items[i - 1]; line.items[i - 1] = line.items[i]; line.items[i] = tmp; if (!at_end) self.col += 1; self.last_col_offset = self.col;}
fn transformWordForward(self: *Textarea, tform: WordTransform) void { if (self.lines.items.len == 0) return; var line = self.lines.items[self.row].items; // Skip separators at cursor. var i = self.col; while (i < line.len and isWordSep(line[i])) : (i += 1) {} // Apply transform across the word. var first_in_word = true; while (i < line.len and !isWordSep(line[i])) : (i += 1) { const cp = line[i]; const replaced: u21 = switch (tform) { .upper => upperAscii(cp), .lower => lowerAscii(cp), .capitalize => if (first_in_word) upperAscii(cp) else lowerAscii(cp), }; line[i] = replaced; first_in_word = false; } self.col = i; self.last_col_offset = self.col;}
fn upperAscii(cp: u21) u21 { return if (cp >= 'a' and cp <= 'z') cp - 32 else cp;}
fn lowerAscii(cp: u21) u21 { return if (cp >= 'A' and cp <= 'Z') cp + 32 else cp;}
// ---- limits / scroll ----
fn atCharLimit(self: *const Textarea) bool { return self.char_limit > 0 and self.length() >= self.char_limit;}
fn scrollViewUp(self: *Textarea, n: u16) void { self.y_offset = if (self.y_offset > n) self.y_offset - n else 0;}
fn scrollViewDown(self: *Textarea, n: u16) void { const total = self.lines.items.len; const max_off: usize = if (total > self.height) total - self.height else 0; const new_off = self.y_offset +| n; self.y_offset = @min(new_off, max_off);}
fn recalculateHeight(self: *Textarea) void { if (!self.dynamic_height) return; const lines: u16 = @intCast(@min(self.lines.items.len, std.math.maxInt(u16))); const lo = @max(self.min_height, 1); var h = @max(lines, lo); if (self.max_height > 0 and h > self.max_height) h = self.max_height; self.height = h;}
fn ensureRowVisible(self: *Textarea) void { if (self.height == 0) return; const cur = self.cursorVisualRow(); if (cur < self.y_offset) { self.y_offset = cur; } else if (cur >= self.y_offset + self.height) { self.y_offset = cur + 1 - self.height; } const total = self.totalVisualRows(); if (total > self.height) { const max_offset = total - self.height; if (self.y_offset > max_offset) self.y_offset = max_offset; } else { self.y_offset = 0; }}
fn cursorVisualRow(self: *const Textarea) usize { if (!self.soft_wrap) return self.row; const cw = self.contentCellsLeft(); if (cw == 0) return self.row; var v: usize = 0; var i: usize = 0; while (i < self.row) : (i += 1) { v += visualRowsForLine(self.lines.items[i].items.len, cw); } return v + self.col / cw;}
fn totalVisualRows(self: *const Textarea) usize { if (!self.soft_wrap) return self.lines.items.len; const cw = self.contentCellsLeft(); if (cw == 0) return self.lines.items.len; var total: usize = 0; for (self.lines.items) |line| total += visualRowsForLine(line.items.len, cw); return total;}
// ---- rendering ----
fn writeLine(self: *Textarea, w: *Writer, idx: usize, line: []const u21) Writer.Error!void { try util.writeInline(w, self.styles.prompt, self.prompt); if (self.show_line_numbers) try self.writeLineNumber(w, idx);
const cells_left = self.contentCellsLeft(); const is_cursor_line = idx == self.row and self.focused; const cursor_col = if (is_cursor_line) self.col else line.len; // sentinel "no cursor"
// Render up to `cells_left` codepoints from `line`, drawing the // virtual cursor when we hit `cursor_col`. var emitted: u16 = 0; var cur_buf: [4]u8 = undefined;
var i: usize = 0; while (i < line.len) : (i += 1) { if (emitted >= cells_left) break; if (i == cursor_col and self.use_virtual_cursor) { const len = std.unicode.utf8Encode(line[i], &cur_buf) catch 1; self.cursor_blink.char = cur_buf[0..len]; self.cursor_blink.style = self.styles.cursor; self.cursor_blink.text_style = self.styles.cursor_text orelse self.styles.text; try self.cursor_blink.view(w); emitted += 1; continue; } const len = std.unicode.utf8Encode(line[i], &cur_buf) catch 1; if (self.styles.text) |s| try openInlineStyle(w, s); try w.writeAll(cur_buf[0..len]); if (self.styles.text) |s| try closeInlineStyle(w, s); emitted += 1; }
// Cursor at end of line. Only the virtual cursor renders an extra cell; // the real-cursor mode lets the parent's View.cursor mark the spot. if (is_cursor_line and cursor_col == line.len and emitted < cells_left and self.use_virtual_cursor) { self.cursor_blink.char = " "; self.cursor_blink.style = self.styles.cursor; self.cursor_blink.text_style = self.styles.cursor_text orelse self.styles.text; try self.cursor_blink.view(w); emitted += 1; }}
fn writeEndOfBuffer(self: *Textarea, w: *Writer) Writer.Error!void { try util.writeInline(w, self.styles.prompt, self.prompt); if (self.show_line_numbers) { // Right-aligned space block matching line-number column width. const ln_width = self.lineNumberWidth(); var i: u16 = 0; while (i < ln_width) : (i += 1) try w.writeByte(' '); } try w.writeByte(self.end_of_buffer);}
fn writeLineNumber(self: *Textarea, w: *Writer, idx: usize) Writer.Error!void { const total = @max(self.lines.items.len, 1); const digits = countDigits(total); var buf: [16]u8 = undefined; const num = std.fmt.bufPrint(&buf, "{d}", .{idx + 1}) catch "?"; if (self.styles.line_number) |s| try openInlineStyle(w, s); var pad = digits -| num.len; while (pad > 0) : (pad -= 1) try w.writeByte(' '); try w.writeAll(num); try w.writeByte(' '); if (self.styles.line_number) |s| try closeInlineStyle(w, s);}
fn lineNumberWidth(self: *const Textarea) u16 { if (!self.show_line_numbers) return 0; return @intCast(countDigits(@max(self.lines.items.len, 1)) + 1);}
fn contentCellsLeft(self: *const Textarea) u16 { const prompt_w = blush.measure.cellWidth(self.prompt); const ln_w = self.lineNumberWidth(); const overhead = prompt_w +| ln_w; return if (self.width > overhead) self.width - overhead else 0;}
fn countDigits(n: usize) usize { var v = n; var d: usize = 1; while (v >= 10) : (v /= 10) d += 1; return d;}
fn openInlineStyle(w: *Writer, s: blush.Style) Writer.Error!void { if (s.bold) try w.writeAll("\x1b[1m"); if (s.faint) try w.writeAll("\x1b[2m"); if (s.italic) try w.writeAll("\x1b[3m"); switch (s.underline) { .none => {}, .single => try w.writeAll("\x1b[4m"), .double => try w.writeAll("\x1b[4:2m"), .curly => try w.writeAll("\x1b[4:3m"), .dotted => try w.writeAll("\x1b[4:4m"), .dashed => try w.writeAll("\x1b[4:5m"), } if (s.foreground) |c| try c.writeSgr(w, .fg); if (s.background) |c| try c.writeSgr(w, .bg);}
fn closeInlineStyle(w: *Writer, s: blush.Style) Writer.Error!void { if (s.bold or s.italic or s.underline != .none or s.faint or s.foreground != null or s.background != null) try w.writeAll("\x1b[0m");}
// ---- tests ----
const testing = std.testing;
fn newForTest() Textarea { var ta: Textarea = .{}; ta.cursor_blink.mode = .static; // skip blink-tick cmd allocation return ta;}
test "setValue / encodeValue roundtrip" { var ta = newForTest(); defer ta.deinit(testing.allocator); try ta.setValue(testing.allocator, "hello\nworld"); try testing.expectEqual(@as(usize, 2), ta.lineCount()); var buf: [32]u8 = undefined; const out = try ta.encodeValue(&buf); try testing.expectEqualStrings("hello\nworld", out);}
test "insertNewline splits current line" { var ta = newForTest(); defer ta.deinit(testing.allocator); _ = ta.focus(testing.allocator); try ta.setValue(testing.allocator, "hello world"); ta.row = 0; ta.col = 5; try ta.insertNewline(testing.allocator); var buf: [32]u8 = undefined; const out = try ta.encodeValue(&buf); try testing.expectEqualStrings("hello\n world", out); try testing.expectEqual(@as(usize, 1), ta.row); try testing.expectEqual(@as(usize, 0), ta.col);}
test "deleteCharBackward at start of line merges with previous" { var ta = newForTest(); defer ta.deinit(testing.allocator); _ = ta.focus(testing.allocator); try ta.setValue(testing.allocator, "ab\ncd"); ta.row = 1; ta.col = 0; ta.deleteCharBackward(testing.allocator); var buf: [32]u8 = undefined; const out = try ta.encodeValue(&buf); try testing.expectEqualStrings("abcd", out); try testing.expectEqual(@as(usize, 0), ta.row); try testing.expectEqual(@as(usize, 2), ta.col);}
test "lineNext preserves last_col_offset over short line" { var ta = newForTest(); defer ta.deinit(testing.allocator); _ = ta.focus(testing.allocator); try ta.setValue(testing.allocator, "abcdef\nxy\nlongerline"); ta.row = 0; ta.col = 5; ta.last_col_offset = 5; ta.lineNext(); try testing.expectEqual(@as(usize, 1), ta.row); try testing.expectEqual(@as(usize, 2), ta.col); // clamped to line length ta.lineNext(); try testing.expectEqual(@as(usize, 2), ta.row); try testing.expectEqual(@as(usize, 5), ta.col); // restored from intent}
test "char_limit blocks insertion" { var ta = newForTest(); defer ta.deinit(testing.allocator); ta.char_limit = 3; _ = ta.focus(testing.allocator); try ta.insertText(testing.allocator, "hello"); try testing.expectEqual(@as(usize, 3), ta.length());}
test "soft-wrap wraps long line into visual rows" { var ta = newForTest(); defer ta.deinit(testing.allocator); ta.soft_wrap = true; ta.show_line_numbers = false; ta.prompt = ""; ta.styles = .{}; ta.width = 4; ta.height = 3; _ = ta.focus(testing.allocator); try ta.setValue(testing.allocator, "abcdefghi"); // Move cursor off the cursor cell so it doesn't appear in output. ta.blur(); var buf: [256]u8 = undefined; var w: Writer = .fixed(&buf); try ta.view(&w); try testing.expectEqualStrings("abcd\nefgh\ni", w.buffered());}
test "soft-wrap linePrevious moves visual row" { var ta = newForTest(); defer ta.deinit(testing.allocator); ta.soft_wrap = true; ta.show_line_numbers = false; ta.prompt = ""; ta.width = 4; ta.height = 3; _ = ta.focus(testing.allocator); try ta.setValue(testing.allocator, "abcdefghi"); // Cursor at end → row 0, col 9. Visual row 2 (vcol 1). ta.linePrevious(); // Now visual row 1: col should become 9 - 4 = 5. try testing.expectEqual(@as(usize, 5), ta.col);}
test "view renders prompt, line numbers, lines" { var ta = newForTest(); defer ta.deinit(testing.allocator); ta.width = 30; ta.height = 3; ta.prompt = "> "; ta.show_line_numbers = true; ta.styles = .{}; _ = ta.focus(testing.allocator); try ta.setValue(testing.allocator, "ab\ncd"); var buf: [256]u8 = undefined; var w: Writer = .fixed(&buf); try ta.view(&w); // Two content lines + one end-of-buffer line. Cursor sits at end of "cd". const want = "> 1 ab\n> 2 cd\x1b[7m \x1b[0m\n> ~"; try testing.expectEqualStrings(want, w.buffered());}