const std = @import("std"); const measure = @import("measure.zig"); const util = @import("util.zig"); const Color = @import("color.zig").Color; pub const Border = @import("Border.zig"); const position = @import("position.zig"); const assert = std.debug.assert; const Io = std.Io; const File = Io.File; const Allocator = std.mem.Allocator; const Writer = std.Io.Writer; const Style = @This(); /// Error set returned by [render]: allocation failures plus writer failures. pub const RenderError = Allocator.Error || Writer.Error; /// A render-time text transform (lipgloss `Transform`). It receives the /// allocator `render` is using and must return a freshly allocated string; /// `render` owns and frees the result. pub const Transform = fn (Allocator, []const u8) Allocator.Error![]u8; /// Horizontal alignment of content within a styled block. Mirrors lipgloss /// `Left`/`Center`/`Right`. Unlike lipgloss's float `Position`, alignment is /// an enum: fractional placement only exists for `position.place`/`join`. pub const HAlign = enum { left, center, right }; /// Vertical alignment of content within a styled block. Mirrors lipgloss /// `Top`/`Center`/`Bottom`. See [HAlign] on why this is an enum. pub const VAlign = enum { top, center, bottom }; // --- stored properties --- // Optional fields use `null` to mean "unset"; see [[project-v2-target]]. bold: bool = false, italic: bool = false, underline: Underline = .none, strikethrough: bool = false, reverse: bool = false, blink: bool = false, faint: bool = false, foreground: ?Color = null, background: ?Color = null, underline_color: ?Color = null, width: ?u16 = null, height: ?u16 = null, max_width: ?u16 = null, max_height: ?u16 = null, /// Tab stop width. null disables conversion, 0 strips tabs, N expands to N /// spaces. Mirrors lipgloss `TabWidth` (default 4). tab_width: ?u8 = 4, padding: Spacing = .{}, padding_char: u21 = ' ', margin: Spacing = .{}, margin_char: u21 = ' ', margin_background: ?Color = null, border: ?Border = null, border_top: bool = true, border_right: bool = true, border_bottom: bool = true, border_left: bool = true, border_top_fg: ?Color = null, border_right_fg: ?Color = null, border_bottom_fg: ?Color = null, border_left_fg: ?Color = null, border_top_bg: ?Color = null, border_right_bg: ?Color = null, border_bottom_bg: ?Color = null, border_left_bg: ?Color = null, align_horizontal: HAlign = .left, align_vertical: VAlign = .top, color_whitespace: bool = true, inline_mode: bool = false, /// Whether spaces receive the underline. `null` follows the underline state /// (lipgloss `UnderlineSpaces`, which defaults on when underline is on). underline_spaces: ?bool = null, /// Whether spaces receive the strikethrough. `null` follows the strikethrough /// state (lipgloss `StrikethroughSpaces`). strikethrough_spaces: ?bool = null, link: ?[]const u8 = null, link_params: ?[]const u8 = null, pub const none: Style = .{}; /// Underline style. Mirrors lipgloss `Underline` (ansi.Underline). Not all /// terminals support every variant; unsupported styles typically fall back /// to a single underline. const Underline = enum { none, single, double, curly, dotted, dashed }; const Spacing = struct { top: u16 = 0, right: u16 = 0, bottom: u16 = 0, left: u16 = 0, }; const AttrName = enum { bold, italic, strikethrough, reverse, blink, faint, }; const Side = enum { top, right, bottom, left, horizontal, vertical, all, }; const Sides = struct { top: bool, right: bool, bottom: bool, left: bool, }; pub fn new() Style { return .none; } fn init(style: Style) Style { return style; } /// Sets the foreground color (lipgloss `Foreground`). pub fn fg(style: Style, color: Color) Style { var out = style; out.foreground = color; return out; } /// Sets the background color (lipgloss `Background`). pub fn bg(style: Style, color: Color) Style { var out = style; out.background = color; return out; } /// Sets the underline color (lipgloss `UnderlineColor`). pub fn underlineColor(style: Style, color: Color) Style { var out = style; out.underline_color = color; return out; } /// Toggles a boolean text attribute (lipgloss `Bold`/`Italic`/etc.). pub fn attr(style: Style, name: AttrName, value: bool) Style { var out = style; switch (name) { .bold => out.bold = value, .italic => out.italic = value, .strikethrough => out.strikethrough = value, .reverse => out.reverse = value, .blink => out.blink = value, .faint => out.faint = value, } return out; } /// Sets the underline style (lipgloss `UnderlineStyle`). Pass `.single` for a /// plain underline; `.none` disables it. pub fn ul(style: Style, kind: Underline) Style { var out = style; out.underline = kind; return out; } /// Controls whether spaces receive the underline (lipgloss `UnderlineSpaces`). pub fn underlineSpaces(style: Style, on: bool) Style { var out = style; out.underline_spaces = on; return out; } /// Controls whether spaces receive the strikethrough /// (lipgloss `StrikethroughSpaces`). pub fn strikethroughSpaces(style: Style, on: bool) Style { var out = style; out.strikethrough_spaces = on; return out; } /// Sets padding on the given side(s) (lipgloss `Padding*`). pub fn pad(style: Style, side: Side, cells: u16) Style { var out = style; applySpacing(&out.padding, side, cells); return out; } /// Sets the padding fill character (lipgloss `PaddingChar`). pub fn paddingChar(style: Style, char: u21) Style { var out = style; out.padding_char = char; return out; } /// Sets margin on the given side(s) (lipgloss `Margin*`). pub fn mar(style: Style, side: Side, cells: u16) Style { var out = style; applySpacing(&out.margin, side, cells); return out; } /// Sets the margin fill character (lipgloss `MarginChar`). pub fn marginChar(style: Style, char: u21) Style { var out = style; out.margin_char = char; return out; } /// Sets the margin background color (lipgloss `MarginBackground`). pub fn marginBackground(style: Style, color: Color) Style { var out = style; out.margin_background = color; return out; } /// Sets the border style (lipgloss `BorderStyle`). All four sides are drawn /// unless individually disabled with `borderSide`. pub fn box(style: Style, border: Border) Style { var out = style; out.border = border; return out; } /// Enables or disables drawing the border on the given side(s) /// (lipgloss `BorderTop`/`BorderRight`/etc.). pub fn borderSide(style: Style, side: Side, on: bool) Style { var out = style; switch (side) { .top => out.border_top = on, .right => out.border_right = on, .bottom => out.border_bottom = on, .left => out.border_left = on, .horizontal => { out.border_left = on; out.border_right = on; }, .vertical => { out.border_top = on; out.border_bottom = on; }, .all => { out.border_top = on; out.border_right = on; out.border_bottom = on; out.border_left = on; }, } return out; } /// Sets the border foreground color on the given side(s) /// (lipgloss `BorderForeground`/`BorderTopForeground`/etc.). pub fn borderFg(style: Style, side: Side, color: Color) Style { var out = style; switch (side) { .top => out.border_top_fg = color, .right => out.border_right_fg = color, .bottom => out.border_bottom_fg = color, .left => out.border_left_fg = color, .horizontal => { out.border_left_fg = color; out.border_right_fg = color; }, .vertical => { out.border_top_fg = color; out.border_bottom_fg = color; }, .all => { out.border_top_fg = color; out.border_right_fg = color; out.border_bottom_fg = color; out.border_left_fg = color; }, } return out; } /// Sets the border background color on the given side(s) /// (lipgloss `BorderBackground`/`BorderTopBackground`/etc.). pub fn borderBg(style: Style, side: Side, color: Color) Style { var out = style; switch (side) { .top => out.border_top_bg = color, .right => out.border_right_bg = color, .bottom => out.border_bottom_bg = color, .left => out.border_left_bg = color, .horizontal => { out.border_left_bg = color; out.border_right_bg = color; }, .vertical => { out.border_top_bg = color; out.border_bottom_bg = color; }, .all => { out.border_top_bg = color; out.border_right_bg = color; out.border_bottom_bg = color; out.border_left_bg = color; }, } return out; } /// Sets a fixed block width, including borders (lipgloss `Width`). pub fn cols(style: Style, cells: u16) Style { var out = style; out.width = cells; return out; } /// Sets a fixed block height, including borders (lipgloss `Height`). pub fn rows(style: Style, lines: u16) Style { var out = style; out.height = lines; return out; } /// Caps the rendered width, truncating each line (lipgloss `MaxWidth`). pub fn maxWidth(style: Style, cells: u16) Style { var out = style; out.max_width = cells; return out; } /// Caps the rendered height, truncating trailing lines (lipgloss `MaxHeight`). pub fn maxHeight(style: Style, lines: u16) Style { var out = style; out.max_height = lines; return out; } /// Sets the tab stop width (lipgloss `TabWidth`). `null` disables tab /// conversion. pub fn tabWidth(style: Style, cells: ?u8) Style { var out = style; out.tab_width = cells; return out; } /// Sets the horizontal alignment (lipgloss `AlignHorizontal`). pub fn alignH(style: Style, a: HAlign) Style { var out = style; out.align_horizontal = a; return out; } /// Sets the vertical alignment (lipgloss `AlignVertical`). pub fn alignV(style: Style, a: VAlign) Style { var out = style; out.align_vertical = a; return out; } /// Controls whether the background color is applied to whitespace such as /// padding (lipgloss `ColorWhitespace`). Defaults to true. pub fn colorWhitespace(style: Style, on: bool) Style { var out = style; out.color_whitespace = on; return out; } /// Renders on a single line, disabling padding, borders, and margins /// (lipgloss `Inline`). pub fn inlineMode(style: Style, on: bool) Style { var out = style; out.inline_mode = on; return out; } /// Sets a hyperlink on the rendered text (lipgloss `Hyperlink`). pub fn hyperlink(style: Style, url: []const u8) Style { var out = style; out.link = url; return out; } /// Sets a hyperlink with OSC 8 parameters (lipgloss `Hyperlink` with params). pub fn hyperlinkParams(style: Style, url: []const u8, params: []const u8) Style { var out = style; out.link = url; out.link_params = params; return out; } fn applySpacing(spacing: *Spacing, side: Side, cells: u16) void { switch (side) { .top => spacing.top = cells, .right => spacing.right = cells, .bottom => spacing.bottom = cells, .left => spacing.left = cells, .horizontal => { spacing.left = cells; spacing.right = cells; }, .vertical => { spacing.top = cells; spacing.bottom = cells; }, .all => { spacing.top = cells; spacing.right = cells; spacing.bottom = cells; spacing.left = cells; }, } } fn borderSides(style: Style) Sides { const has = style.border != null; return .{ .top = has and style.border_top, .right = has and style.border_right, .bottom = has and style.border_bottom, .left = has and style.border_left, }; } fn IfComptime(comptime T: anytype) type { switch (@TypeOf(T)) { comptime Style => []const u8, else => []u8, } } /// Renders `text` styled by this style into a freshly allocated string backed /// by `gpa`; the caller owns the result. A convenience wrapper over the /// allocator-free [render]. No trailing newline is emitted (matching lipgloss). pub fn renderAlloc(style: Style, allocator: Allocator, text: []const u8) ![]u8 { var buffer: Writer.Allocating = .init(allocator); defer buffer.deinit(); try style.render(&buffer.writer, text); return buffer.toOwnedSlice(); } pub fn render(style: Style, writer: *Writer, text: []const u8) Writer.Error!void { if (style.max_width == null and style.max_height == null) { return style.renderInner(writer, text); } // max_width / max_height are post-process caps on the final output; apply // them with a streaming filter so render stays allocator-free. var filter: FilterWriter = .init( writer, style.max_width orelse std.math.maxInt(u16), style.max_height orelse std.math.maxInt(u16), ); return style.renderInner(&filter.interface, text); } /// Renders `text` at compile time, returning a `[]const u8` with static /// lifetime (no allocator, no runtime work). Because `render` is allocator-free /// and only streams to a `*Writer`, the full layout pipeline — wrapping, /// alignment, borders, padding, margins, tab expansion, SGR/OSC8 emission — /// runs in the comptime interpreter. `self` and `text` must be comptime-known. /// /// Output is sized in two passes: a probe render into a fixed scratch buffer to /// learn the exact length, then an exact-sized emit. Output exceeding /// [comptime_scratch_size] raises a comptime error. pub fn renderComptime(comptime self: Style, comptime text: []const u8) []const u8 { const comptime_scratch_size = 64 * 1024; comptime { @setEvalBranchQuota(@as(u32, @max(text.len, 64)) * 100 + 10_000); // Pass 1: render into a fixed scratch buffer to learn the exact output // length. The buffer exists only in the comptime interpreter, so its // size costs nothing at runtime; overflowing it is a comptime error. var scratch: [comptime_scratch_size]u8 = undefined; var probe: Writer = .fixed(&scratch); // Overflowing the scratch buffer trips this `unreachable` at comptime, // reported as output exceeding `comptime_scratch_size`. self.render(&probe, text) catch unreachable; const len = probe.buffered().len; // Pass 2: emit into an exact-sized buffer and freeze it into a const so // the returned slice has static lifetime. var buf: [len]u8 = undefined; var fixed: Writer = .fixed(&buf); self.render(&fixed, text) catch unreachable; const frozen = buf; return &frozen; } } fn renderInner(style: Style, writer: *Writer, text: []const u8) Writer.Error!void { if (style.inline_mode) { const has_link = style.link != null and text.len > 0; if (has_link) try writeOsc8Open(writer, style.link.?, style.link_params); try writeSgrOpen(writer, style); const max_w = style.max_width orelse std.math.maxInt(u16); var w: u16 = 0; var i: usize = 0; while (i < text.len) { const c = text[i]; if (c == '\r' or c == '\n') { i += 1; continue; } if (c == '\t') { i += 1; if (style.tab_width == null) { if (w < max_w) { try writer.writeByte('\t'); w += 1; } } else if (style.tab_width.? > 0) { const n: u16 = style.tab_width.?; var k: u16 = 0; while (k < n and w < max_w) : (k += 1) { try writer.writeByte(' '); w += 1; } } continue; } if (c == 0x1b) { const e = skipEscape(text, i); try writer.writeAll(text[i..e]); i = e; continue; } if (w >= max_w) break; const l = utf8Len(text, i); try writer.writeAll(text[i .. i + l]); w += 1; i += l; } try writeSgrClose(writer, style); if (has_link) try writeOsc8Close(writer); return; } // Block mode: two-pass (scan then emit). const sides = borderSides(style); const left_b: u16 = if (sides.left) 1 else 0; const right_b: u16 = if (sides.right) 1 else 0; const top_b: u16 = if (sides.top) 1 else 0; const bottom_b: u16 = if (sides.bottom) 1 else 0; const h_border = left_b + right_b; const v_border = top_b + bottom_b; const pad_l = style.padding.left; const pad_r = style.padding.right; const pad_t = style.padding.top; const pad_b = style.padding.bottom; const marg_l = style.margin.left; const marg_r = style.margin.right; const wrap_at: u16 = if (style.width) |w| w -| h_border -| pad_l -| pad_r else 0; // Pass 1: scan to get line count and max content width. const scan = wrapScanW(text, style.tab_width, wrap_at); const body_lines = scan.line_count; const content_w: u16 = if (style.width) |w| w -| h_border else util.satAdd(util.satAdd(scan.max_line_w, pad_l), pad_r); const box_w = util.satAdd(util.satAdd(left_b, content_w), right_b); const total_w = util.satAdd(util.satAdd(marg_l, box_w), marg_r); const target_h: u16 = if (style.height) |h| h -| v_border else util.satAdd(util.satAdd(body_lines, pad_t), pad_b); const inner_h = target_h -| pad_t -| pad_b; const blank_before: u16 = switch (style.align_vertical) { .bottom => inner_h -| body_lines, .center => (inner_h -| body_lines) / 2, .top => 0, }; // Pass 2: streaming emit. Emit '\n' *before* each row except the first to // avoid a trailing newline (matching render()'s stripped output). var sep = false; // true once the first row has been emitted // margin top { var r: u16 = 0; while (r < style.margin.top) : (r += 1) { if (sep) try writer.writeByte('\n'); sep = true; try writeMargin(writer, style, total_w); } } // border top if (sides.top) { if (sep) try writer.writeByte('\n'); sep = true; try writeBorderLineW(writer, style, marg_l, marg_r, content_w, sides.left, sides.right, .top); } // padding top { var r: u16 = 0; while (r < pad_t) : (r += 1) { if (sep) try writer.writeByte('\n'); sep = true; try writeFillRowW(writer, style, marg_l, marg_r, content_w, sides.left, sides.right); } } // vertical-align blank rows before content { var r: u16 = 0; while (r < blank_before) : (r += 1) { if (sep) try writer.writeByte('\n'); sep = true; try writeContentRowW(writer, style, marg_l, marg_r, content_w, sides.left, sides.right, ""); } } // content rows { var iter: WrapLineIterW = .init(text, style.tab_width, wrap_at); // Count the vertical-align blank rows already emitted so the fill loop // below tops up to exactly inner_h (max_height is handled by render's // FilterWriter, not here). var rendered: u16 = blank_before; while (iter.next()) |line| { if (rendered >= inner_h) break; if (sep) try writer.writeByte('\n'); sep = true; try writeContentRowW(writer, style, marg_l, marg_r, content_w, sides.left, sides.right, line); rendered += 1; } // fill remaining inner rows (height padding / vertical align) while (rendered < inner_h) : (rendered += 1) { if (sep) try writer.writeByte('\n'); sep = true; try writeContentRowW(writer, style, marg_l, marg_r, content_w, sides.left, sides.right, ""); } } // padding bottom { var r: u16 = 0; while (r < pad_b) : (r += 1) { if (sep) try writer.writeByte('\n'); sep = true; try writeFillRowW(writer, style, marg_l, marg_r, content_w, sides.left, sides.right); } } // border bottom if (sides.bottom) { if (sep) try writer.writeByte('\n'); sep = true; try writeBorderLineW(writer, style, marg_l, marg_r, content_w, sides.left, sides.right, .bottom); } // margin bottom { var r: u16 = 0; while (r < style.margin.bottom) : (r += 1) { if (sep) try writer.writeByte('\n'); sep = true; try writeMargin(writer, style, total_w); } } } /// Encodes `cp` as UTF-8 and writes it `count` times. Invalid code points /// fall back to a space. fn writeRepeatCp(writer: *Writer, cp: u21, count: u16) Writer.Error!void { if (count == 0) return; var buf: [4]u8 = undefined; const len: usize = std.unicode.utf8Encode(cp, &buf) catch blk: { buf[0] = ' '; break :blk 1; }; var i: u16 = 0; while (i < count) : (i += 1) try writer.writeAll(buf[0..len]); } fn writeMargin(writer: *Writer, style: Style, count: u16) Writer.Error!void { if (count == 0) return; if (style.margin_background) |c| { try c.writeSgr(writer, .bg); try writeRepeatCp(writer, style.margin_char, count); try writer.writeAll("\x1b[0m"); } else { try writeRepeatCp(writer, style.margin_char, count); } } fn writeBorderPiece(writer: *Writer, piece: []const u8, fg_color: ?Color, bg_color: ?Color) Writer.Error!void { const styled = fg_color != null or bg_color != null; if (fg_color) |c| try c.writeSgr(writer, .fg); if (bg_color) |c| try c.writeSgr(writer, .bg); try writer.writeAll(piece); if (styled) try writer.writeAll("\x1b[0m"); } const BorderRow = enum { top, bottom }; fn writeOsc8Open(writer: *Writer, url: []const u8, params: ?[]const u8) Writer.Error!void { try writer.writeAll("\x1b]8;"); if (params) |p| try writer.writeAll(p); try writer.writeByte(';'); try writer.writeAll(url); try writer.writeAll("\x1b\\"); } fn writeOsc8Close(writer: *Writer) Writer.Error!void { try writer.writeAll("\x1b]8;;\x1b\\"); } fn writeUnderlineCode(writer: *Writer, kind: Underline) Writer.Error!void { switch (kind) { .none => {}, .single => try writer.writeAll("\x1b[4m"), .double => try writer.writeAll("\x1b[4:2m"), .curly => try writer.writeAll("\x1b[4:3m"), .dotted => try writer.writeAll("\x1b[4:4m"), .dashed => try writer.writeAll("\x1b[4:5m"), } } fn writeSgrOpen(writer: *Writer, style: Style) Writer.Error!void { if (!style.hasAnyStyling()) return; if (style.bold) try writer.writeAll("\x1b[1m"); if (style.faint) try writer.writeAll("\x1b[2m"); if (style.italic) try writer.writeAll("\x1b[3m"); try writeUnderlineCode(writer, style.underline); if (style.blink) try writer.writeAll("\x1b[5m"); if (style.reverse) try writer.writeAll("\x1b[7m"); if (style.strikethrough) try writer.writeAll("\x1b[9m"); if (style.foreground) |color| try color.writeSgr(writer, .fg); if (style.background) |color| try color.writeSgr(writer, .bg); if (style.underline_color) |color| try color.writeUnderlineSgr(writer); } fn writeSgrClose(writer: *Writer, style: Style) Writer.Error!void { if (!style.hasAnyStyling()) return; try writer.writeAll("\x1b[0m"); } /// Opens the SGR sequence for a run of spaces under the space styler. Spaces /// receive the colors plus underline/strikethrough only when requested — not /// bold/italic/etc. Returns whether anything was written. fn writeSpaceSgrOpen(writer: *Writer, style: Style, ul_spaces: bool, st_spaces: bool) Writer.Error!bool { var any = false; if (ul_spaces) { const kind: Underline = if (style.underline == .none) .single else style.underline; try writeUnderlineCode(writer, kind); any = true; } if (st_spaces) { try writer.writeAll("\x1b[9m"); any = true; } if (style.foreground) |color| { try color.writeSgr(writer, .fg); any = true; } if (style.background) |color| { try color.writeSgr(writer, .bg); any = true; } if (style.underline_color) |color| { try color.writeUnderlineSgr(writer); any = true; } return any; } /// Opens the SGR sequence for whitespace (padding, alignment fill). Only /// `reverse` and the background color (when `color_whitespace` is set) bleed /// onto whitespace — text attributes like bold/underline do not. Returns /// whether anything was written, so the caller can pair it with a reset. fn writeWhitespaceOpen(writer: *Writer, style: Style) Writer.Error!bool { var any = false; if (style.reverse) { try writer.writeAll("\x1b[7m"); if (style.foreground) |color| try color.writeSgr(writer, .fg); any = true; } if (style.color_whitespace) { if (style.background) |color| { try color.writeSgr(writer, .bg); any = true; } } return any; } fn writeWhitespaceClose(writer: *Writer, any: bool) Writer.Error!void { if (any) try writer.writeAll("\x1b[0m"); } /// returns style if it has any styling, else null; pub fn maybeStyle(style: Style) ?Style { return if (style.hasAnyStyling()) style else null; } pub fn hasAnyStyling(style: Style) bool { return style.bold or style.italic or style.underline != .none or style.strikethrough or style.reverse or style.blink or style.faint or style.foreground != null or style.background != null or style.underline_color != null; } pub fn isNone(style: Style) bool { return !style.hasAnyStyling(); } fn skipEscape(s: []const u8, index: usize) usize { if (index + 1 >= s.len) return s.len; switch (s[index + 1]) { '[' => { var j = index + 2; while (j < s.len and (s[j] < 0x40 or s[j] > 0x7e)) : (j += 1) {} return if (j < s.len) j + 1 else s.len; }, ']' => { var j = index + 2; while (j < s.len) : (j += 1) { if (s[j] == 0x07) return j + 1; if (s[j] == 0x1b and j + 1 < s.len and s[j + 1] == '\\') return j + 2; } return s.len; }, else => return index + 2, } } fn utf8Len(s: []const u8, i: usize) usize { return std.unicode.utf8ByteSequenceLength(s[i]) catch 1; } /// Visible cell width of `line` with tabs expanded per `tw`, matching the width /// `wrapScanW` uses to size `content_w`. Without this, `writeContentRowW` would /// undercount tab runs and pad the row out too far. fn visibleWidthTab(line: []const u8, tw: ?u8) u16 { var width: u16 = 0; var run_start: usize = 0; var i: usize = 0; while (i < line.len) : (i += 1) { if (line[i] != '\t') continue; width = util.satAdd(width, measure.cellWidth(line[run_start..i])); if (tw == null) { width = util.satAdd(width, 1); } else if (tw.? > 0) { width = util.satAdd(width, tw.?); } run_start = i + 1; } return util.satAdd(width, measure.cellWidth(line[run_start..])); } /// A zero-buffer `Writer` adapter that streams `render`'s output through the /// `max_width` and `max_height` caps, forwarding filtered bytes to `out`. /// `max_width` truncates each line to N visible cells (ANSI-aware: escape /// sequences pass through and are not counted, so trailing resets/links /// survive). `max_height` keeps at most N lines (mirrors lipgloss truncating /// the final string). A cap of `maxInt(u16)` means "no limit". const FilterWriter = struct { out: *Writer, max_w: u16, max_h: u16, visible: u16 = 0, lines: u16 = 0, height_done: bool = false, esc: Esc = .normal, utf8_fwd: u3 = 0, // continuation bytes left to forward for the current cp utf8_drop: u3 = 0, // continuation bytes left to drop for the current cp interface: Writer = .{ .buffer = &.{}, .vtable = &.{ .drain = drain, }, }, const Esc = enum { normal, start, csi, osc, osc_esc }; fn init(writer: *Writer, max_w: u16, max_h: u16) FilterWriter { return .{ .out = writer, .max_w = max_w, .max_h = max_h, .height_done = max_h == 0, }; } fn drain(writer: *Writer, data: []const []const u8, splat: usize) Writer.Error!usize { const self: *FilterWriter = @fieldParentPtr("interface", writer); for (data[0 .. data.len - 1]) |slice| { for (slice) |b| try self.byte(b); } const last = data[data.len - 1]; var r: usize = 0; while (r < splat) : (r += 1) { for (last) |b| try self.byte(b); } return Writer.countSplat(data, splat); } fn byte(self: *FilterWriter, b: u8) Writer.Error!void { if (self.height_done) return; // Continuation bytes belong to a codepoint already decided on. if (self.utf8_fwd > 0) { self.utf8_fwd -= 1; return self.out.writeByte(b); } if (self.utf8_drop > 0) { self.utf8_drop -= 1; return; } // Pass ANSI escape sequences through untouched and uncounted. switch (self.esc) { .start => { self.esc = switch (b) { '[' => .csi, ']' => .osc, else => .normal, }; return self.out.writeByte(b); }, .csi => { if (b >= 0x40 and b <= 0x7e) self.esc = .normal; return self.out.writeByte(b); }, .osc => { if (b == 0x07) self.esc = .normal else if (b == 0x1b) self.esc = .osc_esc; return self.out.writeByte(b); }, .osc_esc => { self.esc = .normal; return self.out.writeByte(b); }, .normal => {}, } if (b == 0x1b) { self.esc = .start; return self.out.writeByte(b); } if (b == '\n') { // Keep at most max_h lines: drop the newline that would open line // max_h + 1, and everything after it. if (self.max_h != std.math.maxInt(u16) and self.lines + 1 >= self.max_h) { self.height_done = true; return; } self.lines += 1; self.visible = 0; return self.out.writeByte(b); } if (self.visible >= self.max_w) { // Past the cut: drop this codepoint (and its continuation bytes). const len = std.unicode.utf8ByteSequenceLength(b) catch 1; self.utf8_drop = @intCast(len - 1); return; } // Control bytes forward without counting (matches lipgloss truncate). if (b < 0x20 or b == 0x7f) return self.out.writeByte(b); const len = std.unicode.utf8ByteSequenceLength(b) catch 1; self.visible += 1; self.utf8_fwd = @intCast(len - 1); return self.out.writeByte(b); } }; /// Like `writeBorderLine` but without the trailing `\n`. fn writeBorderLineW( writer: *Writer, style: Style, marg_l: u16, marg_r: u16, content_w: u16, bl: bool, br: bool, row: BorderRow, ) Writer.Error!void { const border = style.border.?; const corner_l = switch (row) { .top => border.top_left, .bottom => border.bottom_left, }; const corner_r = switch (row) { .top => border.top_right, .bottom => border.bottom_right, }; const edge = switch (row) { .top => border.top, .bottom => border.bottom, }; const fg_color = switch (row) { .top => style.border_top_fg, .bottom => style.border_bottom_fg, }; const bg_color = switch (row) { .top => style.border_top_bg, .bottom => style.border_bottom_bg, }; try writeMargin(writer, style, marg_l); const styled = fg_color != null or bg_color != null; if (fg_color) |c| try c.writeSgr(writer, .fg); if (bg_color) |c| try c.writeSgr(writer, .bg); if (bl) try writer.writeAll(corner_l); var i: u16 = 0; while (i < content_w) : (i += 1) try writer.writeAll(edge); if (br) try writer.writeAll(corner_r); if (styled) try writer.writeAll("\x1b[0m"); try writeMargin(writer, style, marg_r); } /// Like `writeFillRow` but without the trailing `\n`. fn writeFillRowW( writer: *Writer, style: Style, marg_l: u16, marg_r: u16, content_w: u16, bl: bool, br: bool, ) Writer.Error!void { try writeMargin(writer, style, marg_l); if (bl) try writeBorderPiece(writer, style.border.?.left, style.border_left_fg, style.border_left_bg); const ws = try writeWhitespaceOpen(writer, style); try writeRepeatCp(writer, ' ', content_w); try writeWhitespaceClose(writer, ws); if (br) try writeBorderPiece(writer, style.border.?.right, style.border_right_fg, style.border_right_bg); try writeMargin(writer, style, marg_r); } /// Like `writeContentRow` but without the trailing `\n` and with tab expansion. fn writeContentRowW( writer: *Writer, style: Style, marg_l: u16, marg_r: u16, content_w: u16, bl: bool, br: bool, line: []const u8, ) Writer.Error!void { const pad_l = style.padding.left; const pad_r = style.padding.right; const inner_w = content_w -| pad_l -| pad_r; // Tab-aware so it matches the width wrapScanW used to compute content_w. const visible = visibleWidthTab(line, style.tab_width); const fill = inner_w -| visible; const left_fill: u16 = switch (style.align_horizontal) { .right => fill, .center => fill / 2, .left => 0, }; const right_fill = fill - left_fill; try writeMargin(writer, style, marg_l); if (bl) try writeBorderPiece(writer, style.border.?.left, style.border_left_fg, style.border_left_bg); { const ws = try writeWhitespaceOpen(writer, style); try writeRepeatCp(writer, style.padding_char, pad_l); try writeRepeatCp(writer, ' ', left_fill); try writeWhitespaceClose(writer, ws); } const has_link = style.link != null and line.len > 0; if (has_link) try writeOsc8Open(writer, style.link.?, style.link_params); try writeStyledTextW(writer, style, line, inner_w); if (has_link) try writeOsc8Close(writer); { const ws = try writeWhitespaceOpen(writer, style); try writeRepeatCp(writer, ' ', right_fill); try writeRepeatCp(writer, style.padding_char, pad_r); try writeWhitespaceClose(writer, ws); } if (br) try writeBorderPiece(writer, style.border.?.right, style.border_right_fg, style.border_right_bg); try writeMargin(writer, style, marg_r); } /// Like `writeStyledText` but uses `writeTruncatedW` for tab expansion. fn writeStyledTextW(writer: *Writer, style: Style, line: []const u8, max_w: u16) Writer.Error!void { const underline_on = style.underline != .none; const strike_on = style.strikethrough; const ul_spaces = style.underline_spaces orelse underline_on; const st_spaces = style.strikethrough_spaces orelse strike_on; const spaces_differ = (ul_spaces != underline_on) or (st_spaces != strike_on); if (!spaces_differ) { try writeSgrOpen(writer, style); try writeTruncatedW(writer, line, max_w, style.tab_width); try writeSgrClose(writer, style); return; } // Space-differing path: expand tabs as spaces inline. var visible: u16 = 0; var i: usize = 0; while (i < line.len and visible < max_w) { if (line[i] == '\t') { i += 1; const any = try writeSpaceSgrOpen(writer, style, ul_spaces, st_spaces); if (style.tab_width != null and style.tab_width.? > 0) { const n: u16 = style.tab_width.?; var k: u16 = 0; while (k < n and visible < max_w) : (k += 1) { try writer.writeByte(' '); visible += 1; } } else if (style.tab_width == null) { if (visible < max_w) { try writer.writeByte('\t'); visible += 1; } } if (any) try writer.writeAll("\x1b[0m"); continue; } if (line[i] == ' ') { const any = try writeSpaceSgrOpen(writer, style, ul_spaces, st_spaces); while (i < line.len and visible < max_w and line[i] == ' ') { try writer.writeByte(' '); visible += 1; i += 1; } if (any) try writer.writeAll("\x1b[0m"); } else { try writeSgrOpen(writer, style); while (i < line.len and visible < max_w and line[i] != ' ' and line[i] != '\t') { if (line[i] == 0x1b) { const e = skipEscape(line, i); try writer.writeAll(line[i..e]); i = e; continue; } const b = line[i]; if (b < 0x20 or b == 0x7f) { try writer.writeByte(b); i += 1; continue; } const l = utf8Len(line, i); try writer.writeAll(line[i .. i + l]); visible += 1; i += l; } try writeSgrClose(writer, style); } } } /// Like `writeTruncated` but expands tabs according to `tw`. fn writeTruncatedW(writer: *Writer, text: []const u8, max_w: u16, tw: ?u8) Writer.Error!void { if (max_w == 0) return; var visible: u16 = 0; var i: usize = 0; while (i < text.len) { if (text[i] == '\t') { i += 1; if (tw == null) { if (visible >= max_w) { try drainEscapes(writer, text, &i); return; } try writer.writeByte('\t'); visible += 1; } else if (tw.? > 0) { const n: u16 = tw.?; var k: u16 = 0; while (k < n and visible < max_w) : (k += 1) { try writer.writeByte(' '); visible += 1; } } continue; } if (text[i] == 0x1b) { const e = skipEscape(text, i); try writer.writeAll(text[i..e]); i = e; continue; } const b = text[i]; if (b < 0x20 or b == 0x7f) { try writer.writeByte(b); i += 1; continue; } if (visible >= max_w) { // Width exhausted: stop emitting glyphs, but keep writing // zero-width escape sequences (SGR resets) so styles don't leak // into whatever the caller emits next. try drainEscapes(writer, text, &i); return; } const l = utf8Len(text, i); try writer.writeAll(text[i .. i + l]); visible += 1; i += l; } } /// Writes any remaining zero-width escape sequences from `text` starting at /// `i`, advancing `i` past printable content without emitting it. fn drainEscapes(writer: *Writer, text: []const u8, i: *usize) Writer.Error!void { while (i.* < text.len) { if (text[i.*] == 0x1b) { const e = skipEscape(text, i.*); try writer.writeAll(text[i.*..e]); i.* = e; continue; } i.* += utf8Len(text, i.*); } } /// Scan `text` without allocating to determine the number of logical lines and /// the maximum visible line width produced after tab expansion and word wrap. fn wrapScanW(text: []const u8, tw: ?u8, wrap_at: u16) struct { line_count: u16, max_line_w: u16 } { if (wrap_at == 0) { // No wrap: count lines and max width with tab awareness. var max_w: u16 = 0; var line_w: u16 = 0; var line_count: u16 = 1; var i: usize = 0; while (i < text.len) { const c = text[i]; i += 1; if (c == '\r') continue; if (c == '\n') { if (line_w > max_w) max_w = line_w; line_w = 0; line_count = util.satAdd(line_count, 1); continue; } if (c == '\t') { if (tw == null) { line_w = util.satAdd(line_w, 1); } else if (tw.? > 0) { line_w = util.satAdd(line_w, tw.?); } continue; } if (c == 0x1b) { i -= 1; i = skipEscape(text, i); continue; } if (c >= 0x20 and c != 0x7f) { i -= 1; const l = utf8Len(text, i); i += l; line_w = util.satAdd(line_w, 1); } } if (line_w > max_w) max_w = line_w; return .{ .line_count = line_count, .max_line_w = max_w }; } // With wrap: simulate WrapLineIterW to count resulting lines. var iter: WrapLineIterW = .init(text, tw, wrap_at); var line_count: u16 = 0; while (iter.next()) |_| line_count = util.satAdd(line_count, 1); return .{ .line_count = line_count, .max_line_w = wrap_at }; } /// Streaming word-wrap iterator that returns slices of the original `text` /// with no heap allocation. Mirrors the logic of `wrap.wrap` but yields /// `[]const u8` segments instead of building a new string. const WrapLineIterW = struct { text: []const u8, tw: ?u8, wrap_at: u16, pos: usize = 0, seg_start: usize = 0, // byte start of the current line segment to return sp_start: usize = 0, // byte start of the current run of pending spaces pending_sp: u16 = 0, // width of accumulated whitespace not yet committed line_w: u16 = 0, // visible width committed to the current line at_start: bool = true, // true at the beginning of each line // Hard-break continuation state (when a word is wider than wrap_at). hb_pos: usize = 0, hb_end: usize = 0, hb_active: bool = false, done: bool = false, pub fn init(text: []const u8, tw: ?u8, wrap_at: u16) WrapLineIterW { return .{ .text = text, .tw = tw, .wrap_at = wrap_at }; } pub fn next(self: *WrapLineIterW) ?[]const u8 { if (self.done) return null; if (self.hb_active) return self.continueHardBreak(); return self.scanLine(); } fn tabWidth(self: WrapLineIterW) u16 { if (self.tw == null) return 1; if (self.tw.? == 0) return 0; return self.tw.?; } fn scanLine(self: *WrapLineIterW) ?[]const u8 { const text = self.text; while (self.pos < text.len) { const c = text[self.pos]; if (c == '\r') { self.pos += 1; continue; } if (c == '\n') { // Hard newline: yield up to where pending spaces started (trailing // spaces are dropped, matching wrap.zig behaviour). const end = if (self.pending_sp > 0) self.sp_start else self.pos; const seg = text[self.seg_start..end]; self.pos += 1; self.seg_start = self.pos; self.sp_start = self.pos; self.pending_sp = 0; self.line_w = 0; self.at_start = true; return seg; } // Whitespace (spaces and tabs) → accumulate as pending. if (c == ' ' or c == '\t') { if (self.pending_sp == 0) self.sp_start = self.pos; const w: u16 = if (c == ' ') 1 else self.tabWidth(); self.pending_sp +|= w; self.pos += 1; continue; } // ANSI escape: zero width, skip. Flush any pending whitespace first // so a trailing "space + SGR reset" isn't trimmed as trailing // whitespace (which would drop the reset and leak the style). if (c == 0x1b) { if (self.pending_sp > 0) { self.line_w +|= self.pending_sp; self.pending_sp = 0; self.at_start = false; } self.pos = skipEscape(text, self.pos); continue; } // Word: collect a run of non-whitespace, non-newline bytes. const word_start = self.pos; while (self.pos < text.len) { const wc = text[self.pos]; if (wc == ' ' or wc == '\t' or wc == '\n' or wc == '\r') break; if (wc == 0x1b) { self.pos = skipEscape(text, self.pos); continue; } self.pos += utf8Len(text, self.pos); } const word_end = self.pos; const word_w = measure.cellWidth(text[word_start..word_end]); if (self.wrap_at == 0) { // Wrapping disabled: just accumulate width and continue. self.line_w +|= self.pending_sp +| word_w; self.pending_sp = 0; self.at_start = false; continue; } if (self.at_start) { // Keep pending spaces as indentation (wrap.zig semantics). if (self.pending_sp +| word_w <= self.wrap_at) { self.line_w = self.pending_sp +| word_w; self.pending_sp = 0; self.at_start = false; } else if (word_w <= self.wrap_at) { // Indent overshoots with word — drop excess indent, keep word. self.seg_start = word_start; self.sp_start = word_start; self.pending_sp = 0; self.line_w = word_w; self.at_start = false; } else { // Word itself exceeds wrap_at: hard break, emit empty first. const seg = text[self.seg_start..self.sp_start]; self.seg_start = word_start; self.sp_start = word_start; self.pending_sp = 0; self.hb_pos = word_start; self.hb_end = word_end; self.hb_active = true; return seg; } } else { const total: u32 = @as(u32, self.line_w) + self.pending_sp + word_w; if (total <= self.wrap_at) { self.line_w +|= self.pending_sp +| word_w; self.pending_sp = 0; self.at_start = false; } else if (word_w <= self.wrap_at) { // Soft wrap: yield current line, start next at word_start. const seg = text[self.seg_start..self.sp_start]; self.seg_start = word_start; self.sp_start = word_start; self.line_w = word_w; self.pending_sp = 0; self.at_start = false; return seg; } else { // Soft wrap then hard break the oversized word. const seg = text[self.seg_start..self.sp_start]; self.seg_start = word_start; self.sp_start = word_start; self.pending_sp = 0; self.line_w = 0; self.at_start = true; self.hb_pos = word_start; self.hb_end = word_end; self.hb_active = true; return seg; } } } // End of input: yield whatever remains. self.done = true; const end = if (self.pending_sp > 0) self.sp_start else text.len; return text[self.seg_start..end]; } /// Continue hard-breaking a word that exceeds `wrap_at`, one chunk per call. fn continueHardBreak(self: *WrapLineIterW) ?[]const u8 { const text = self.text; if (self.hb_pos >= self.hb_end) { self.hb_active = false; // Resume normal scanning after the hard-broken word. self.seg_start = self.hb_end; self.sp_start = self.hb_end; self.line_w = 0; self.at_start = true; return self.scanLine(); } // Emit up to wrap_at visible cells from hb_pos. var i = self.hb_pos; var w: u16 = 0; while (i < self.hb_end and w < self.wrap_at) { if (text[i] == 0x1b) { i = skipEscape(text, i); continue; } i += utf8Len(text, i); w += 1; } const seg = text[self.hb_pos..i]; self.hb_pos = i; if (self.hb_pos >= self.hb_end) { self.hb_active = false; self.seg_start = self.hb_end; self.sp_start = self.hb_end; self.line_w = w; self.at_start = false; } return seg; } }; // --- tests --- const testing = std.testing; fn renderAllocTest(style: Style, text: []const u8) ![]u8 { return style.renderAlloc(testing.allocator, text); } fn expectRender(expected: []const u8, style: Style, text: []const u8) !void { const got = try renderAllocTest(style, text); defer testing.allocator.free(got); try testing.expectEqualStrings(expected, got); } test "render plain text" { try expectRender("hello", init(.{}), "hello"); } test "render bold + fg" { try expectRender("\x1b[1m\x1b[31mx\x1b[0m", init(.{}).fg(.red).attr(.bold, true), "x"); } test "render fixed width pads right" { try expectRender("ab ", init(.{}).cols(5), "ab"); } test "render padding all = 1" { // content_w = visible(1) + pad_l(1) + pad_r(1) = 3. try expectRender(" \n x \n ", init(.{}).pad(.all, 1), "x"); } test "builder pad" { const style = init(.{}).pad(.all, 2); try testing.expectEqual(@as(u16, 2), style.padding.top); try testing.expectEqual(@as(u16, 2), style.padding.right); try testing.expectEqual(@as(u16, 2), style.padding.bottom); try testing.expectEqual(@as(u16, 2), style.padding.left); } test "render margin all = 1" { // total_w = marg_l(1) + content_w(1) + marg_r(1) = 3. try expectRender(" \n x \n ", init(.{}).mar(.all, 1), "x"); } test "render border normal" { try expectRender("┌─┐\n│x│\n└─┘", init(.{}).box(.normal), "x"); } test "render border top only" { const style = init(.{}).box(.normal).borderSide(.all, false).borderSide(.top, true); try expectRender("─\nx", style, "x"); } test "render border with foreground color" { try expectRender( "\x1b[31m┌─┐\x1b[0m\n\x1b[31m│\x1b[0mx\x1b[31m│\x1b[0m\n\x1b[31m└─┘\x1b[0m", init(.{}).box(.normal).borderFg(.all, .red), "x", ); } test "render underline single" { try expectRender("\x1b[4mx\x1b[0m", init(.{}).ul(.single), "x"); } test "render underline curly" { try expectRender("\x1b[4:3mx\x1b[0m", init(.{}).ul(.curly), "x"); } test "render hyperlink" { try expectRender( "\x1b]8;;http://x\x1b\\y\x1b]8;;\x1b\\", init(.{}).hyperlink("http://x"), "y", ); } test "render inline mode strips newlines and frame" { const style = init(.{}).inlineMode(true).pad(.all, 4).attr(.bold, true); try expectRender("\x1b[1mab\x1b[0m", style, "a\nb"); } test "render padding char" { try expectRender(".x.", init(.{}).pad(.horizontal, 1).paddingChar('.'), "x"); } test "render word wrap" { try expectRender("hello\nworld", init(.{}).cols(5), "hello world"); } test "render tab expansion" { try expectRender("a b", init(.{}).tabWidth(2), "a\tb"); } test "render tab removal" { try expectRender("ab", init(.{}).tabWidth(0), "a\tb"); } test "render max width truncates" { try expectRender("abc", init(.{}).maxWidth(3), "abcdefg"); } test "render max height truncates" { try expectRender("a\nb", init(.{}).maxHeight(2), "a\nb\nc\nd"); } test "render underline spaces disabled" { // Underline on, but spaces opt out: text runs underlined, space run not. try expectRender( "\x1b[4ma\x1b[0m \x1b[4mb\x1b[0m", init(.{}).ul(.single).underlineSpaces(false), "a b", ); } test "render align horizontal center" { try expectRender(" x ", init(.{}).cols(5).alignH(.center), "x"); } test "render align horizontal right" { try expectRender(" x", init(.{}).cols(5).alignH(.right), "x"); } test "render align vertical bottom" { try expectRender(" \n \nx", init(.{}).rows(3).alignV(.bottom), "x"); } fn expectRenderComptime(comptime style: Style, comptime text: []const u8) !void { // `got` is produced entirely in the comptime interpreter; compare it to the // runtime renderer's output for the same style and text. const got = comptime style.renderComptime(text); const want = try renderAllocTest(style, text); defer testing.allocator.free(want); try testing.expectEqualStrings(want, got); } test "renderComptime matches render" { try expectRenderComptime(init(.{}), "hello"); try expectRenderComptime(init(.{}).fg(.red).attr(.bold, true), "x"); try expectRenderComptime(init(.{}).box(.normal).borderFg(.all, .red), "x"); try expectRenderComptime(init(.{}).cols(5).alignH(.center), "x"); try expectRenderComptime(init(.{}).pad(.all, 1), "x"); try expectRenderComptime(init(.{}).cols(5), "hello world"); try expectRenderComptime(init(.{}).maxWidth(3), "abcdefg"); try expectRenderComptime(init(.{}).rows(3).alignV(.bottom), "x"); try expectRenderComptime(init(.{}).ul(.single).underlineSpaces(false), "a b"); try expectRenderComptime(init(.{}).tabWidth(2), "a\tb"); }