tuile 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e96464e067ccbb78bd11cf6639b53dc4f53de48519f7e47143a594b520bb99c
-  data.tar.gz: 668bd3ac1b4130919949dce95867cccfa89dac387b6f164a2c7ea027cf04c1da
+  metadata.gz: fd5711addbd65a00c8d471204d50973da93ac9be65ba197114ac04c94cace526
+  data.tar.gz: 4505d93153dc96fd439e5d69a7b1506e985fc9094f8428fe092ebc6247d62b8a
 SHA512:
-  metadata.gz: 6e9e20049c86bab8649b3d53604a61438f27608ae62d009c6a556fe76b146e186072c46a4c5036173c3b40197d8648dee855dce401d4536060f269e159a40c98
-  data.tar.gz: 2ddccc6f2d1664935ba7c64b523f09b3a1ba9a57c7c356620beef39fd623b4a76a60d7fd1fda109aa11e9a5693a911cc1736d0f07dc99aad507008726d3fd301
+  metadata.gz: 23c69343d8a0cc87143b12cd1a4a9a11862c770debf9c5381cabfcb59b55786f8be143ef362581e0a79bb1dc7f9ce512f47d755f603cb486bf4058b3487d4399
+  data.tar.gz: '0974d322289b63b43bdd498e172f446d7cc56df656645b8e6826fed388154dda4a287110819d305572dbbf1c1ee23011fc4e0cb208f6459d67535e2df5c1d2b1'

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [Unreleased]
 
+## [0.3.0] - 2026-05-18
+
+- Add `Component::TextView` — read-only scrollable wrapped prose with word wrap, incremental append, and a lazy text reader.
+- Add `Tuile::StyledString` for span-modeled ANSI styling, with `#wrap` (span-preserving word wrap), `#ellipsize` (width-bounded truncation), `#with_bg`, and an `EMPTY` shared instance.
+- Model `Label`, `List`, and `TextView` text as `StyledString`; pre-pad clipped/physical lines.
+- Extract `Tuile::Ansi` for shared ANSI helpers.
+- `Window#scrollbar=` accepts any content that exposes `scrollbar_visibility=`.
+- Document `TextView` in the README and `examples/sampler.rb`.
+- Remove `Tuile::Wrap` (superseded by `StyledString#wrap`).
+- Remove `Tuile::Truncate` (superseded by `StyledString#ellipsize`).
+
 ## [0.2.0] - 2026-05-15
 
 - Add `Component::TextArea` with multi-line editing, word navigation, and VT220-style Home/End handling.

data/README.md

@@ -79,7 +79,10 @@ Save it as `hello.rb` and run `ruby hello.rb`. Press `q` or `ESC` to exit.
 
 A larger demo lives in [`examples/file_commander.rb`](examples/file_commander.rb):
 a two-pane file browser with cursor navigation, header label, and a layout
-that follows terminal resize.
+that follows terminal resize. For a tour of every shipped component, run
+[`examples/sampler.rb`](examples/sampler.rb): a two-pane sampler where the
+left pane lists demos and the right pane loads the highlighted one. Tab /
+Shift+Tab move focus between the list and the demo's widgets.
 
 ## How it works
 

data/examples/sampler.rb

@@ -66,6 +66,7 @@ module SamplerExample
       ["Label",        :build_label],
       ["TextField",    :build_text_field],
       ["TextArea",     :build_text_area],
+      ["TextView",     :build_text_view],
       ["Button",       :build_buttons],
       ["List",         :build_list],
       ["Layout",       :build_layout],
@@ -133,6 +134,38 @@ module SamplerExample
       end
     end
 
+    def build_text_view
+      prompt = Tuile::Component::Label.new
+      prompt.text = "Read-only viewer for prose. Word-wraps to width; ANSI formatting passes through.\n" \
+                    "Tab here, then: ↑↓ / jk scroll a line; PgUp/PgDn a page; Ctrl+U/D half a page; " \
+                    "Home/End / g/G jump to the edges."
+      window = Tuile::Component::Window.new("Excerpt")
+      view = Tuile::Component::TextView.new
+      view.text = "#{Rainbow("Tuile").green} is a small component-oriented terminal-UI framework built on top of " \
+                  "the TTY toolkit. Apps build a tree of Components under a singleton Screen; the screen runs " \
+                  "an event loop, dispatches keys and mouse events, and repaints invalidated components in " \
+                  "batch.\n\n" \
+                  "The name is #{Rainbow("French").cyan} for #{Rainbow("\"roof tile\"").yellow} — small pieces " \
+                  "that compose into a larger whole. This excerpt wraps to the viewer's current width; resize " \
+                  "the terminal to see the wrap recompute, and scroll to see the rest.\n\n" \
+                  "Components do not paint immediately. They call invalidate (which records them in the " \
+                  "Screen's pending-repaint set); after an event-loop tick drains the queue, Screen#repaint " \
+                  "walks the set, sorts by depth, and paints parents before children. Popups deliberately " \
+                  "overdraw the tiled tree on top.\n\n" \
+                  "All UI mutations must run on the thread that owns Screen#run_event_loop. Background work " \
+                  "marshals back via screen.event_queue.submit { … }. Most UI methods check the lock and " \
+                  "raise if you violate the contract; FakeScreen short-circuits the check so tests can mutate " \
+                  "freely."
+      window.content = view
+      window.scrollbar = true
+      panel(prompt, window) do |r|
+        inner = inner_rect(r)
+        prompt.rect = Tuile::Rect.new(inner.left, inner.top + 1, inner.width, 2)
+        view_height = [inner.height - 5, 4].max
+        window.rect = Tuile::Rect.new(inner.left, inner.top + 4, inner.width, view_height)
+      end
+    end
+
     def build_buttons
       label = Tuile::Component::Label.new
       label.text = "Buttons fire on Enter, Space, or a left-click. Tab to focus, then activate."

data/lib/tuile/ansi.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Tuile
+  # ANSI escape sequence constants. Tuile emits colors and text attributes
+  # via Rainbow, which produces **SGR** sequences ("Select Graphic
+  # Rendition", `ESC [ <params> m` — e.g. `\e[31m` red, `\e[1m` bold,
+  # `\e[0m` reset).
+  module Ansi
+    # SGR reset (`ESC [ 0 m`). Restores the terminal's default foreground,
+    # background, and text attributes.
+    # @return [String]
+    RESET = "\e[0m"
+  end
+end

data/lib/tuile/component/label.rb

@@ -2,38 +2,66 @@
 
 module Tuile
   class Component
-    # A label which shows static text. No word-wrapping; clips long lines.
+    # A label which shows static text. No word-wrapping; long lines are
+    # truncated with an ellipsis. Text is modeled as a {StyledString};
+    # {#text=} accepts a {String} (parsed via {StyledString.parse}, so
+    # embedded ANSI is honored) or a {StyledString} directly. {#text}
+    # always returns the {StyledString}.
     class Label < Component
       def initialize
         super
-        @lines = []
+        @text = StyledString::EMPTY
         @clipped_lines = []
+        @blank_line = ""
       end
 
-      # @param text [String, nil] draws this text. May contain ANSI formatting.
-      #   Clipped automatically.
+      # @return [StyledString] the current text. Defaults to an empty
+      #   {StyledString}.
+      attr_reader :text
+
+      # Replaces the text. A `String` is parsed via {StyledString.parse}
+      # (embedded ANSI is honored); a `StyledString` is used as-is; `nil` is
+      # coerced to an empty {StyledString}. Lines wider than {#rect} are
+      # truncated with an ellipsis at paint time.
+      # @param value [String, StyledString, nil]
       # @return [void]
-      def text=(text)
-        @lines = text.to_s.split("\n")
+      def text=(value)
+        new_text = StyledString.parse(value)
+        return if @text == new_text
+
+        @text = new_text
         @content_size = nil
-        update_clipped_text
+        update_clipped_lines
+        invalidate
       end
 
-      # @return [Size]
+      # @return [Size] longest hard-line's display width × number of hard
+      #   lines. Reported on the *unclipped* text — sizing is intrinsic to
+      #   the content, not the viewport. Empty text returns `Size.new(0, 0)`.
       def content_size
-        @content_size ||= begin
-          width = @lines.map { |line| Unicode::DisplayWidth.of(Rainbow.uncolor(line)) }.max || 0
-          Size.new(width, @lines.size)
-        end
+        @content_size ||=
+          if @text.empty?
+            Size::ZERO
+          else
+            hard_lines = @text.lines
+            width = hard_lines.map(&:display_width).max || 0
+            Size.new(width, hard_lines.size)
+          end
       end
 
+      # Paints the text into {#rect}.
+      #
+      # Skips the {Component#repaint} default's auto-clear: every row is
+      # painted explicitly (with pre-padded blanks past the last line), so
+      # the "fully draw over your rect" contract is met without an upfront
+      # wipe.
       # @return [void]
       def repaint
-        super
-        height = rect.height.clamp(0, nil)
-        lines_to_print = @clipped_lines.length.clamp(nil, height)
-        (0..lines_to_print - 1).each do |index|
-          screen.print TTY::Cursor.move_to(rect.left, rect.top + index), @clipped_lines[index]
+        return if rect.empty? || rect.left.negative? || rect.top.negative?
+
+        (0...rect.height).each do |row|
+          line = @clipped_lines[row] || @blank_line
+          screen.print TTY::Cursor.move_to(rect.left, rect.top + row), line
         end
       end
 
@@ -42,21 +70,31 @@ module Tuile
       # @return [void]
       def on_width_changed
         super
-        update_clipped_text
+        update_clipped_lines
       end
 
       private
 
+      # Recomputes {@clipped_lines} for the current text and rect width.
+      # Each line is ellipsized to fit, padded with trailing spaces out to
+      # the full width, and pre-rendered to ANSI so {#repaint} is just a
+      # lookup + screen.print per row. {@blank_line} covers rows past the
+      # last text line.
       # @return [void]
-      def update_clipped_text
-        len = rect.width.clamp(0, nil)
-        clipped = @lines.map do |line|
-          Truncate.truncate(line, length: len)
-        end
-        return if @clipped_lines == clipped
+      def update_clipped_lines
+        width = rect.width.clamp(0, nil)
+        @blank_line = " " * width
+        @clipped_lines = @text.lines.map { |line| pad_to(line.ellipsize(width), width).to_ansi }
+      end
 
-        @clipped_lines = clipped
-        invalidate
+      # @param line [StyledString]
+      # @param width [Integer]
+      # @return [StyledString]
+      def pad_to(line, width)
+        diff = width - line.display_width
+        return line if diff <= 0
+
+        line + StyledString.plain(" " * diff)
       end
     end
   end

data/lib/tuile/component/list.rb

@@ -2,20 +2,31 @@
 
 module Tuile
   class Component
-    # A scrollable list of String items with cursor support.
+    # A scrollable list of items with cursor support.
     #
-    # Items are lines painted directly into the component's {#rect}. Lines are
-    # automatically clipped horizontally. Vertical scrolling is supported via
-    # {#top_line}; the list can also automatically scroll to the bottom if
-    # {#auto_scroll} is enabled.
+    # Items are modeled as {StyledString}s and painted directly into the
+    # component's {#rect}. Lines wider than the viewport are ellipsized via
+    # {StyledString#ellipsize} (span styles are preserved across the cut —
+    # unlike the older ANSI-as-bytes truncation, color does *not* get
+    # dropped on the surviving characters). Vertical scrolling is supported
+    # via {#top_line}; the list can also automatically scroll to the bottom
+    # if {#auto_scroll} is enabled.
     #
     # Cursor is supported; call {#cursor=} to change cursor behavior. The
-    # cursor responds to arrows, `jk`, Home/End, Ctrl+U/D and scrolls the list
-    # automatically.
+    # cursor responds to arrows, `jk`, Home/End, Ctrl+U/D and scrolls the
+    # list automatically. The cursor highlight overlays a dark background
+    # while preserving each span's foreground color.
     class List < Component
+      # 256-color SGR index for the cursor-row background highlight. Matches
+      # what `Rainbow(...).bg(:darkslategray)` emits.
+      # @return [Integer]
+      CURSOR_BG = 59
+
       def initialize
         super
         @lines = []
+        @padded_lines = []
+        @blank_padded = StyledString::EMPTY
         @auto_scroll = false
         @top_line = 0
         @cursor = Cursor::None.new
@@ -28,19 +39,19 @@ module Tuile
 
       # @return [Proc, nil] callback fired when an item is chosen — by pressing
       #   Enter on the cursor's item, or by left-clicking an item. Called as
-      #   `proc.call(index, line)` with the chosen 0-based index and its line.
-      #   Never fires when the cursor's position is outside the content (e.g.
-      #   {Cursor::None}, or empty content).
+      #   `proc.call(index, line)` with the chosen 0-based index and its
+      #   {StyledString} line. Never fires when the cursor's position is
+      #   outside the content (e.g. {Cursor::None}, or empty content).
       attr_accessor :on_item_chosen
 
       # @return [Proc, nil] callback fired when the `(index, line)` tuple under
       #   the cursor changes. Called as `proc.call(index, line)` where `line`
-      #   is `nil` when the cursor is off-content ({Cursor::None}, empty list,
-      #   or `index` past the last line). Fires on cursor moves (key, mouse,
-      #   search), on {#cursor=}, and on {#lines=}/{#add_lines} when the line
-      #   at the cursor's index changes (or its in-range/out-of-range status
-      #   flips). Useful for keeping a details pane in sync with the
-      #   highlighted row.
+      #   is the {StyledString} at the cursor, or `nil` when the cursor is
+      #   off-content ({Cursor::None}, empty list, or `index` past the last
+      #   line). Fires on cursor moves (key, mouse, search), on {#cursor=},
+      #   and on {#lines=}/{#add_lines} when the line at the cursor's index
+      #   changes (or its in-range/out-of-range status flips). Useful for
+      #   keeping a details pane in sync with the highlighted row.
       attr_accessor :on_cursor_changed
 
       # @return [Boolean] if true and a line is added or new content is set,
@@ -77,6 +88,7 @@ module Tuile
         return if @scrollbar_visibility == value
 
         @scrollbar_visibility = value
+        rebuild_padded_lines
         invalidate
       end
 
@@ -109,16 +121,22 @@ module Tuile
         invalidate
       end
 
-      # Sets new lines. Each entry is coerced via `#to_s`, split on `\n` into
-      # separate lines, and trailing whitespace stripped — symmetric with
-      # {#add_lines}, so the stored `@lines` is always `Array<String>`.
-      # @param lines [Array] new lines. Entries need only respond to `#to_s`.
+      # Sets new lines. Each entry is coerced into a {StyledString} (a
+      # `String` is parsed via {StyledString.parse}, so embedded ANSI is
+      # honored; a {StyledString} is used as-is; anything else is stringified
+      # via `#to_s` first), then split on `\n` into separate lines via
+      # {StyledString#lines}, with trailing empty pieces dropped and trailing
+      # ASCII whitespace stripped — symmetric with {#add_lines}, so the
+      # stored `@lines` is always `Array<StyledString>`.
+      # @param lines [Array] entries are `String`, `StyledString`, or anything
+      #   that responds to `#to_s`.
       # @return [void]
       def lines=(lines)
         raise TypeError, "expected Array, got #{lines.inspect}" unless lines.is_a? Array
 
-        @lines = lines.flat_map { it.to_s.split("\n") }.map(&:rstrip)
+        @lines = parse_input_lines(lines)
         @content_size = nil
+        rebuild_padded_lines
         update_top_line_if_auto_scroll
         notify_cursor_changed
         invalidate
@@ -132,9 +150,11 @@ module Tuile
       # end
       # ```
       # @yield [buffer]
-      # @yieldparam buffer [Array<String>] mutable buffer to push lines into.
+      # @yieldparam buffer [Array] mutable buffer to push lines into. Each
+      #   entry is parsed the same way as the items passed to {#lines=}.
       # @yieldreturn [void]
-      # @return [Array<String>] current lines (when called without a block).
+      # @return [Array<StyledString>] current lines (when called without a
+      #   block).
       def lines
         return @lines unless block_given?
 
@@ -144,21 +164,24 @@ module Tuile
       end
 
       # Adds a line.
-      # @param line [String]
+      # @param line [String, StyledString, #to_s]
       # @return [void]
       def add_line(line)
         add_lines [line]
       end
 
-      # Appends given lines. Each entry is coerced via `#to_s`, split on `\n`
-      # into separate lines, and trailing whitespace stripped — symmetric with
-      # {#lines=}.
-      # @param lines [Array] entries need only respond to `#to_s`.
+      # Appends given lines. Each entry is parsed the same way as in
+      # {#lines=}: coerced to a {StyledString}, split on `\n`, with trailing
+      # empty pieces dropped and trailing ASCII whitespace stripped.
+      # @param lines [Array] entries are `String`, `StyledString`, or anything
+      #   that responds to `#to_s`.
       # @return [void]
       def add_lines(lines)
         screen.check_locked
-        @lines += lines.flat_map { it.to_s.split("\n") }.map(&:rstrip)
+        new_lines = parse_input_lines(lines)
+        @lines += new_lines
         @content_size = nil
+        @padded_lines += new_lines.map { |line| pad_to_row(line) }
         update_top_line_if_auto_scroll
         notify_cursor_changed
         invalidate
@@ -167,8 +190,8 @@ module Tuile
       # @return [Size]
       def content_size
         @content_size ||= begin
-          content_width = @lines.map { |line| Unicode::DisplayWidth.of(Rainbow.uncolor(line)) }.max || 0
-          width = @lines.empty? ? 0 : content_width + 2
+          content_w = @lines.map(&:display_width).max || 0
+          width = @lines.empty? ? 0 : content_w + 2
           Size.new(width, @lines.size)
         end
       end
@@ -206,6 +229,8 @@ module Tuile
       # Moves the cursor to the next line whose text contains `query`
       # (case-insensitive substring match). Search wraps around the end of the
       # list. Only lines reachable by the current {#cursor} are considered.
+      # Matching uses the line's plain text — span styles do not affect the
+      # match.
       #
       # @param query [String] substring to match. Empty query never matches.
       # @param include_current [Boolean] when true, the current cursor position
@@ -250,21 +275,19 @@ module Tuile
       # Paints the list items into {#rect}.
       #
       # Skips the {Component#repaint} default's auto-clear: every row of
-      # {#rect} is painted below (with padded content past the last item),
+      # {#rect} is painted below (with blank padding past the last item),
       # so the parent contract — "fully draw over your rect" — is met
       # without an upfront wipe.
       # @return [void]
       def repaint
         return if rect.empty?
 
-        width = rect.width
         scrollbar = if scrollbar_visible?
                       VerticalScrollBar.new(rect.height, line_count: @lines.size, top_line: @top_line)
                     end
-        (0..(rect.height - 1)).each do |line_no|
-          line_index = line_no + @top_line
-          line = paintable_line(line_index, line_no, width, scrollbar)
-          screen.print TTY::Cursor.move_to(rect.left, line_no + rect.top), line
+        (0...rect.height).each do |row|
+          line = paintable_line(row + @top_line, row, scrollbar)
+          screen.print TTY::Cursor.move_to(rect.left, row + rect.top), line
         end
       end
 
@@ -453,8 +476,56 @@ module Tuile
         end
       end
 
+      protected
+
+      # Rebuilds pre-padded lines when the wrap width changes. The wrap width
+      # depends on {#rect}`.width` and the scrollbar gutter, both of which
+      # trigger this hook.
+      # @return [void]
+      def on_width_changed
+        super
+        rebuild_padded_lines
+      end
+
       private
 
+      # Coerces and flattens a list of input entries into trimmed
+      # {StyledString} lines. Each entry becomes a {StyledString} (String
+      # via {StyledString.parse}, StyledString passed through, anything else
+      # via `#to_s`), then split on `\n` via {StyledString#lines} — with
+      # trailing empty pieces dropped (matching `String#split("\n")`'s
+      # default behavior, so `add_line ""` is a no-op) — and trailing ASCII
+      # whitespace stripped on each resulting line.
+      # @param entries [Array]
+      # @return [Array<StyledString>]
+      def parse_input_lines(entries)
+        entries.flat_map { |entry| split_to_lines(entry) }
+      end
+
+      # @param entry [Object]
+      # @return [Array<StyledString>]
+      def split_to_lines(entry)
+        styled = entry.is_a?(StyledString) ? entry : StyledString.parse(entry.to_s)
+        parts = styled.lines
+        parts.pop while parts.last && parts.last.empty?
+        parts.map { |line| rstrip_styled(line) }
+      end
+
+      # Returns `line` with trailing ASCII whitespace (space/tab) dropped,
+      # preserving span styles on the surviving prefix. Whitespace chars are
+      # all single-column ASCII, so byte-count delta equals column-count
+      # delta and {StyledString#slice} can do the cut.
+      # @param line [StyledString]
+      # @return [StyledString]
+      def rstrip_styled(line)
+        plain = line.to_s
+        trailing = plain.length - plain.rstrip.length
+        return line if trailing.zero?
+        return StyledString::EMPTY if trailing == plain.length
+
+        line.slice(0, line.display_width - trailing)
+      end
+
       # @return [Boolean] true if the cursor sits on a real content line.
       def cursor_on_item?
         pos = @cursor.position
@@ -469,8 +540,9 @@ module Tuile
         @on_item_chosen&.call(pos, @lines[pos])
       end
 
-      # @return [Array((Integer, String, nil))] `[position, line_at_position]`,
-      #   with `line` nil when the cursor is off-content.
+      # @return [Array((Integer, StyledString, nil))]
+      #   `[position, line_at_position]`, with `line` nil when the cursor is
+      #   off-content.
       def cursor_state
         pos = @cursor.position
         line = pos >= 0 && pos < @lines.size ? @lines[pos] : nil
@@ -500,7 +572,7 @@ module Tuile
 
         ordered = order_for_search(candidates, @cursor.position, include_current: include_current, reverse: reverse)
         query_lc = query.downcase
-        match = ordered.find { |idx| Rainbow.uncolor(@lines[idx]).downcase.include?(query_lc) }
+        match = ordered.find { |idx| @lines[idx].to_s.downcase.include?(query_lc) }
         return false unless match
 
         @cursor.go(match)
@@ -584,42 +656,56 @@ module Tuile
         @scrollbar_visibility == :visible
       end
 
-      # Trims string exactly to `width` columns.
-      # @param str [String]
-      # @param width [Integer]
-      # @return [String]
-      def trim_to(str, width)
-        return " " * width if str.empty?
+      # @return [Integer] column width available for line content (rect width
+      #   minus the scrollbar gutter, when visible). `0` when {#rect}'s width
+      #   is non-positive.
+      def content_width
+        return 0 if rect.width <= 0
 
-        truncated_line = Truncate.truncate(str, length: width)
-        return truncated_line unless truncated_line == str
+        rect.width - (scrollbar_visible? ? 1 : 0)
+      end
+
+      # Recomputes {@padded_lines} for the current rect width and scrollbar
+      # visibility. Each line is ellipsized to fit and pre-padded with
+      # single-space gutters on each side, so {#paintable_line} only has to
+      # apply the cursor highlight (if any) and append the scrollbar glyph.
+      # @return [void]
+      def rebuild_padded_lines
+        @padded_lines = @lines.map { |line| pad_to_row(line) }
+        @blank_padded = pad_to_row(StyledString::EMPTY)
+      end
 
-        length = Unicode::DisplayWidth.of(Rainbow.uncolor(str))
-        str += " " * (width - length) if length < width
-        str
+      # Pads `line` to one full row of the viewport (scrollbar gutter
+      # excluded). Lines wider than the content area are ellipsized via
+      # {StyledString#ellipsize} (span styles survive the cut); shorter
+      # lines are padded with default-styled spaces.
+      # @param line [StyledString]
+      # @return [StyledString] exactly {#content_width} display columns wide
+      #   (or {StyledString::EMPTY} when content_width is non-positive).
+      def pad_to_row(line)
+        cw = content_width
+        return StyledString::EMPTY if cw <= 0
+        return StyledString.plain(" " * cw) if cw < 2
+
+        text_width = cw - 2
+        body = line.ellipsize(text_width)
+        fill = cw - 2 - body.display_width
+        StyledString.plain(" ") + body + StyledString.plain(" " * (fill + 1))
       end
 
       # @param index [Integer] 0-based index into {#lines}.
       # @param row_in_viewport [Integer] 0-based row within the viewport.
-      # @param width [Integer] number of columns the line should occupy.
-      # @param scrollbar [VerticalScrollBar, nil] scrollbar instance, or nil if
-      #   not shown.
-      # @return [String] paintable line exactly `width` columns wide;
-      #   highlighted if cursor is here.
-      def paintable_line(index, row_in_viewport, width, scrollbar)
-        content_width = scrollbar ? width - 1 : width
-        line = @lines[index] || ""
-        line = trim_to(line, content_width - 2)
-        line = " #{line} "
+      # @param scrollbar [VerticalScrollBar, nil] scrollbar instance, or nil
+      #   if not shown.
+      # @return [String] paintable ANSI-encoded line exactly `rect.width`
+      #   columns wide; highlighted if cursor is here.
+      def paintable_line(index, row_in_viewport, scrollbar)
+        base = index < @lines.size ? @padded_lines[index] : @blank_padded
         is_cursor = (active? || @show_cursor_when_inactive) && index < @lines.size && @cursor.position == index
-        line = if is_cursor
-                 Rainbow(Rainbow.uncolor(line)).bg(:darkslategray)
-               else
-                 line
-               end
-        return line unless scrollbar
-
-        line + scrollbar.scrollbar_char(row_in_viewport)
+        styled = is_cursor ? base.with_bg(CURSOR_BG) : base
+        out = styled.to_ansi
+        out += scrollbar.scrollbar_char(row_in_viewport) if scrollbar
+        out
       end
     end
   end

data/lib/tuile/component/text_area.rb

@@ -138,8 +138,6 @@ module Tuile
       ACTIVE_BG_SGR = TextField::ACTIVE_BG_SGR
       # @return [String]
       INACTIVE_BG_SGR = TextField::INACTIVE_BG_SGR
-      # @return [String]
-      SGR_RESET = TextField::SGR_RESET
 
       # @return [void]
       def repaint
@@ -156,7 +154,7 @@ module Tuile
                    chunk = @text[r[:start], r[:length]] || ""
                    chunk + (" " * (rect.width - r[:length]))
                  end
-          screen.print TTY::Cursor.move_to(rect.left, rect.top + screen_row), bg, line, SGR_RESET
+          screen.print TTY::Cursor.move_to(rect.left, rect.top + screen_row), bg, line, Ansi::RESET
         end
       end
 

data/lib/tuile/component/text_field.rb

@@ -158,9 +158,6 @@ module Tuile
       # (terminal black), so we emit the escape directly to reach the ramp.
       # @return [String]
       INACTIVE_BG_SGR = "\e[48;5;238m"
-      # SGR reset.
-      # @return [String]
-      SGR_RESET = "\e[0m"
 
       # @return [void]
       def repaint
@@ -168,7 +165,7 @@ module Tuile
 
         bg = active? ? ACTIVE_BG_SGR : INACTIVE_BG_SGR
         padded = @text + (" " * (rect.width - @text.length))
-        screen.print TTY::Cursor.move_to(rect.left, rect.top), bg, padded, SGR_RESET
+        screen.print TTY::Cursor.move_to(rect.left, rect.top), bg, padded, Ansi::RESET
       end
 
       protected