tui_tui 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 509e482a4d22483da9840ee1ea39021f27f747f2c6919d7782e46f41dbfdfea0
-  data.tar.gz: 731b150add99bd21eafef87e2a33c36679eb5998f01a78bf317217a1c7ee428a
+  metadata.gz: 1b33867fe04eb8d9683aad497f5695c4acd69d73f21c499f0b56f6bb9894ac59
+  data.tar.gz: 63803c2a7b40bcd5ea08a87646ad676566bbfdd25d5dc60003260d9ea65073ee
 SHA512:
-  metadata.gz: '068472d5d8dd0c5ae371ffe2516bbe1f1a548d3d55c97e85b898e821640ed6a64b0e8005fa3e8c219c20cfae79e1e86efafbb2f851f7dbbc6830e5ec2e59c455'
-  data.tar.gz: 37e91b9643cc30df3a887e90004859cc37035c52882f353a66148fce585d47c1ba1075af142650fad597e3d34652b9a1983a11f2c19019163740920cff4afadf
+  metadata.gz: 421ac35ee26b15078161127094d180174bc4268b06e6268ea0c7970ec2fb15bdddda8a1fde6f11b5075f6ba91fcfef75d4e0b60e918c3daf5a7649b86d4203a0
+  data.tar.gz: 1b9049e7b536309c85eff02c8864c6b08d7567b62f359d440ba2aaa07aa5715c2cd1c26fe29fff66b3a8ff7f5097232ab649201e8dcd5a2b309c11616166d037

data/CHANGELOG.md

@@ -1,5 +1,65 @@
 # Changelog
 
+## [0.4.0] - 2026-07-03
+
+### Added
+- `Widget::Table`: a fixed-header table for `ScrollList` — `[label, width]`
+  columns, cell content from the caller's block, width-aware (CJK safe).
+  See `examples/csv_viewer.rb`.
+- `Widget::Tabs`: a one-row tab bar with click hit-testing (`Tabs.draw` /
+  `Tabs.index_at`). See `examples/log_viewer.rb`.
+- `Widget::Spinner` and `Widget::Progress`: a tick-driven frame cycler and a
+  progress bar. See `examples/downloads.rb`.
+- New examples — `downloads.rb`, `log_viewer.rb`, `breakout.rb` — and an
+  `examples/README.md` guide.
+- `Rect#split_rows` / `Rect#split_cols`: split a Rect from a constraint list
+  (Integer = fixed size, Float = fraction, `:rest` = the leftover); an
+  undersized rect clamps trailing segments to 0 instead of raising.
+  `Rect.of(size)` builds the full-screen root Rect.
+- `TuiTui::TestRuntime`: drive an app without a terminal (opt-in via
+  `require "tui_tui/test_runtime"`) — inject `key` / `type` / `tick` /
+  `resize` / `mouse`, then assert on `app`, `commands`, `quit?`, and the
+  rendered `screen` / `canvas`.
+- `TuiTui::Command`: `update` may return `[app, *commands]` to request
+  one-shot effects — `Command::Copy` (clipboard, OSC 52) and
+  `Command::Invalidate` (full repaint). `[:quit, *commands]` performs the
+  commands and then quits.
+- `TextInput`: a single-line, grapheme-aware text-editing model; it now backs
+  `Modal::Prompt` and `Modal::CommandPalette`.
+- `Canvas#to_text`: a style-free string projection of the grid, for snapshot
+  tests.
+
+### Fixed
+- Continuous input (e.g. terminal key repeat) no longer starves `TickEvent`,
+  so holding a key down cannot freeze animations or keep a `Widget::Toast`
+  from expiring — and ticks cannot starve input either.
+- `Modal::Prompt` no longer overflows its field: a long value scrolls
+  horizontally to keep the cursor visible.
+- `Modal::CommandPalette` backspace deletes a whole grapheme (base plus
+  combining marks), not half of one.
+
+### Changed
+- `tick:` is now a period, not an idle timeout: `TickEvent` arrives on a
+  fixed cadence, between input events too.
+- Injectable clocks take a Clock-compatible object (responding to
+  `monotonic`) instead of a callable: `Widget::Toast.new(clock:)` no longer
+  accepts a lambda.
+- Widgets are namespaced under `TuiTui::Widget` (`List`, `ScrollList`,
+  `TextView`, `Scrollbar`, `StatusBar`, `Toast`) and modals under
+  `TuiTui::Modal` (`Confirm`, `Select`, `Prompt`, `Pager`, `Help`,
+  `CommandPalette`).
+- `BoxChrome.resolve` is now `BoxChromeResolver#resolve` (`BoxChrome` is a
+  pure glyph set), and `Canvas`'s row rendering moved to `CanvasRenderer`
+  (`Canvas` is a pure drawing surface).
+
+### Removed
+- `TextSanitizer.printable?` (public since 0.3.0): use `TextInput#type`,
+  which inserts only printable input.
+- The `take_clipboard` hook: return `Command::Copy.new(text)` from `update`
+  instead.
+- The `redraw?(event)` hook: return `Command::Invalidate.new` from `update`
+  instead.
+
 ## [0.3.0] - 2026-06-22
 
 ### Added

data/README.md

@@ -8,7 +8,9 @@ It uses a lightweight, TEA-inspired (MVU) architecture: the app object is the mo
 ## Usage
 
 An app is any object with two methods: `view(size)` returns a `Canvas`, and
-`update(event)` returns the next app (or `:quit`). `Runtime#run` drives the loop.
+`update(event)` returns the next app (or `:quit`). It may also return
+`[app, *commands]` to request one-shot effects (see below). `Runtime#run`
+drives the loop.
 
 ```ruby
 require "tui_tui"
@@ -21,12 +23,10 @@ class Counter
   end
 
   def update(event)
-    return self unless event.is_a?(TuiTui::KeyEvent)
-
-    case event.key
-    when "+", "=" then Counter.new(@count + 1)
-    when "-", "_" then Counter.new(@count - 1)
-    when "q", TuiTui::KeyCode::CTRL_C then :quit
+    case event
+    in TuiTui::KeyEvent(key: "+" | "=") then Counter.new(@count + 1)
+    in TuiTui::KeyEvent(key: "-" | "_") then Counter.new(@count - 1)
+    in TuiTui::KeyEvent(key: "q" | TuiTui::KeyCode::CTRL_C) then :quit
     else self
     end
   end
@@ -35,14 +35,51 @@ end
 TuiTui::Runtime.new(Counter.new).run
 ```
 
-See [`examples/`](examples) for larger apps.
-Each is runnable with `ruby examples/<name>.rb`.
+Events are `Data.define` values, so Ruby's pattern matching (`case`/`in`)
+deconstructs them directly in `update`.
+
+The runtime never inspects the model, only `update`'s return value, so both
+state styles work: the counter above returns a fresh model from each branch;
+`todo.rb` and `file_browser.rb` mutate their state and return `self`. Prefer
+immutability when you want undo or to compare models in tests; prefer
+mutation when the model holds lists, caches, or widget state.
+
+See [`examples/`](./examples/) for larger apps, each runnable with
+`ruby examples/<name>.rb`.
+
+## Commands and subscriptions
+
+Ongoing declarations are predicate methods the runtime polls each frame
+(`wants_tick?`, `wants_mouse?`); one-shot instructions are `TuiTui::Command`
+values returned from `update`, which the runtime executes before rendering.
+
+```ruby
+[self, TuiTui::Command::Copy.new(path)] # write to the clipboard (OSC 52)
+```
+
+`Command::Invalidate` requests a full repaint on the next render.
+Returning `[:quit, *commands]` performs the commands and then quits.
+
+## Testing
+
+`TuiTui::TestRuntime` is the runtime with the screen removed: it folds
+injected events exactly like `Runtime` and renders `view` headless. It is
+opt-in — `require "tui_tui/test_runtime"`.
+
+```ruby
+require "tui_tui/test_runtime"
+
+runtime = TuiTui::TestRuntime.new(Counter.new, rows: 3, cols: 60)
+runtime.key("+").key("+").key("-")
+expect(runtime.screen).to include("count: 1")
+expect(runtime.commands).to eq([])
+expect(runtime.key("q").quit?).to be(true)
+```
 
-- `examples/counter.rb` — the smallest possible app
-- `examples/widgets.rb` — built-in modal widgets
-- `examples/file_browser.rb` — two-pane file browser
-- `examples/todo.rb` — todo list with prompts and filtering
-- `examples/csv_viewer.rb` — fixed-header CSV table viewer
+`screen` returns `Canvas#to_text`, a style-free string projection of the
+grid; `canvas` returns the `Canvas` itself for cell-level style assertions.
+`type("…")` injects a string one grapheme at a time, and `resize` / `tick` /
+`mouse` inject the other event kinds.
 
 ## Non-functional requirements
 

data/examples/README.md

@@ -0,0 +1,28 @@
+# Examples
+
+Each example is a self-contained app, runnable with `ruby examples/<name>.rb`.
+
+## Learning path
+
+Read these in order to learn the app shape:
+
+- [`counter.rb`](counter.rb) — the smallest possible app
+- [`clock.rb`](clock.rb) — the smallest ticking app (`wants_tick?`)
+- [`todo.rb`](todo.rb) — the typical app shape: `ModalHost`, `Theme.auto`, a `ScrollList` view
+- [`file_browser.rb`](file_browser.rb) — a full app: two panes, fuzzy finder, commands, mouse
+
+## Feature showcases
+
+Dip into these per feature:
+
+- [`widgets.rb`](widgets.rb) — the built-in modal widgets
+- [`form.rb`](form.rb) — composing text inputs
+- [`paint.rb`](paint.rb) — mouse drawing and a custom modal
+- [`csv_viewer.rb`](csv_viewer.rb) — `Widget::Table` over real data, with column scrolling
+- [`downloads.rb`](downloads.rb) — a ticking dashboard (`Table` + `Spinner` + `Progress`)
+- [`log_viewer.rb`](log_viewer.rb) — tabbed tail-f log viewer (`Tabs` + `TextView`)
+- [`breakout.rb`](breakout.rb) — a real-time game (60 fps ticks, float physics)
+- [`life.rb`](life.rb) — full-screen updates every frame (the N6 stress test)
+
+A new example earns its place only by demonstrating something none of the
+existing ones do; extending a showcase beats adding a near-duplicate.

data/examples/breakout.rb

@@ -0,0 +1,225 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Breakout: a tick-driven arcade sample. A ball (Float position, so it can move
+# at shallow angles) bounces off the walls, a paddle, and five rows of colored
+# bricks — where it hits the paddle decides the rebound angle, terminal cells
+# are tall so the horizontal speed runs about twice the vertical, and the whole
+# simulation is deterministic (no rand: the serve angle is fixed, so a test can
+# predict the trajectory). Bricks are background-colored spaces, the ball "o",
+# the paddle "=" (ASCII-only glyphs, N7). Resize rebuilds the field and returns
+# the ball to the paddle, keeping score and lives (simple over clever).
+#
+#   ruby examples/breakout.rb
+#
+# Mouse: press/drag to place the paddle under the pointer.
+# Keys: left/right (or h/l) move, Space serve / restart, q (or Ctrl-C) quit.
+
+require_relative "../lib/tui_tui"
+
+module BreakoutSample
+  BAR = TuiTui::Style.new(attrs: [:reverse])
+  # Reverse video fills the ball's whole cell and flips against the terminal
+  # background, so it stays high-contrast on dark and light themes alike.
+  BALL = TuiTui::Style.new(attrs: [:reverse, :bold])
+  # Background-filled like the bricks, so the paddle reads as a solid bar.
+  PADDLE = TuiTui::Style.new(bg: :bright_cyan)
+  MSG = TuiTui::Style.new(fg: :bright_yellow, attrs: [:bold])
+  # Raw domain colors, one per brick row — game colors, not Theme roles.
+  BRICK_ROWS = %i[red yellow green cyan magenta].map { |c| TuiTui::Style.new(bg: c) }.freeze
+  BRICK_W = 4 # cells are ~2x taller than wide, so a 4x1 brick reads as a block
+  PADDLE_W = 10
+  # Cells per key press (and per key-repeat while held).
+  PADDLE_STEP = 4
+  # Vertical cells per tick; horizontal speed scales off this (cell aspect
+  # ratio). Raise it (or lower the Runtime tick below) for a faster game.
+  # Kept small enough that even the sharpest rebound moves less than one cell
+  # per frame, so the ball visits every column instead of skipping.
+  SPEED = 0.28
+  # Sharpest paddle rebound, as a multiple of SPEED (0.98 cells/frame max).
+  MAX_ANGLE = 3.5
+
+  class Breakout
+    def initialize(rows: 24, cols: 80)
+      @score = 0
+      @lives = 3
+      layout(rows, cols)
+    end
+
+    # Only the flying ball needs the timer; serving and game-over screens idle.
+    def wants_tick? = @phase == :play
+
+    def update(event)
+      case event
+      in TuiTui::KeyEvent(key: "q" | TuiTui::KeyCode::CTRL_C) then :quit
+      in TuiTui::KeyEvent(key: :left | "h") then move_paddle(-PADDLE_STEP)
+      in TuiTui::KeyEvent(key: :right | "l") then move_paddle(PADDLE_STEP)
+      in TuiTui::KeyEvent(key: " ") then space
+      in TuiTui::MouseEvent(action: :press | :drag, col:) then follow(col)
+      in TuiTui::ResizeEvent(size:) then layout(size.rows, size.cols)
+      in TuiTui::TickEvent then step
+      else self
+      end
+    end
+
+    def view(ctx)
+      layout(ctx.rows, ctx.cols) if ctx.rows != @view_rows || ctx.cols != @view_cols
+      canvas = ctx.canvas
+      header, field = TuiTui::Rect.of(ctx).split_rows(1, :rest)
+      draw_header(canvas, header)
+      canvas.frame(field) if field.rows >= 2 && field.cols >= 2
+      draw_bricks(canvas, field)
+      draw_paddle(canvas, field)
+      draw_ball(canvas, field)
+      draw_message(canvas, field)
+      canvas
+    end
+
+    private
+
+    # Game coordinates live in the field's interior: (1,1)..(@rows,@cols),
+    # header and frame excluded. Rebuilt whenever the terminal size changes.
+    def layout(rows, cols)
+      @view_rows = rows
+      @view_cols = cols
+      @rows = [rows - 3, 1].max # 1 header row + 2 frame rows
+      @cols = [cols - 2, 1].max
+      @paddle_w = [PADDLE_W, @cols].min
+      @paddle = [((@cols - @paddle_w) / 2) + 1, 1].max
+      @bricks = {} # [row, index] => Style
+      BRICK_ROWS.each_with_index do |style, i|
+        row = 2 + i
+        next if row > @rows - 2 # leave room between bricks and paddle
+
+        (@cols / BRICK_W).times { |b| @bricks[[row, b]] = style }
+      end
+      serve
+      self
+    end
+
+    # Ball waits on the paddle. The launch angle is fixed (dx twice dy — cell
+    # aspect ratio), so the whole game is deterministic.
+    def serve
+      @phase = :serve
+      @bx = @paddle + ((@paddle_w - 1) / 2.0)
+      @by = [@rows - 1, 1].max.to_f
+      @dx = SPEED * 2
+      @dy = -SPEED
+    end
+
+    def space
+      case @phase
+      when :serve then @phase = :play
+      when :over, :clear then restart
+      end
+      self
+    end
+
+    def restart
+      @score = 0
+      @lives = 3
+      layout(@view_rows, @view_cols)
+    end
+
+    def move_paddle(delta)
+      @paddle = (@paddle + delta).clamp(1, [@cols - @paddle_w + 1, 1].max)
+      @bx = @paddle + ((@paddle_w - 1) / 2.0) if @phase == :serve # ball rides along
+      self
+    end
+
+    # Center the paddle under the pointer (screen col -> interior col is -1).
+    def follow(col) = move_paddle((col - 1 - (@paddle_w / 2)) - @paddle)
+
+    # One physics step: advance, bounce off walls, then bricks, then the paddle
+    # (or fall past it and lose a life). All-bricks-gone wins.
+    def step
+      return self unless @phase == :play
+
+      @bx += @dx
+      @by += @dy
+      bounce_walls
+      hit_brick
+      if @dy.positive? && @by >= @rows - 0.5 && over_paddle?
+        reflect_off_paddle
+      elsif @by > @rows
+        drop
+      end
+      @phase = :clear if @phase == :play && @bricks.empty?
+      self
+    end
+
+    def bounce_walls
+      if @bx < 1
+        @bx = 1.0
+        @dx = @dx.abs
+      elsif @bx > @cols
+        @bx = @cols.to_f
+        @dx = -@dx.abs
+      end
+      return unless @by < 1
+
+      @by = 1.0
+      @dy = @dy.abs
+    end
+
+    def hit_brick
+      return unless @bricks.delete([@by.round, (@bx.round - 1) / BRICK_W])
+
+      @score += 10
+      @dy = -@dy
+    end
+
+    def over_paddle? = @bx.round.between?(@paddle, @paddle + @paddle_w - 1)
+
+    # The rebound angle depends on where the ball meets the paddle: dead center
+    # goes straight up, the edges send it out at up to MAX_ANGLE x the
+    # vertical speed.
+    def reflect_off_paddle
+      offset = (@bx - (@paddle + ((@paddle_w - 1) / 2.0))) / [@paddle_w / 2.0, 1.0].max
+      @dx = (offset * MAX_ANGLE * SPEED).clamp(-MAX_ANGLE * SPEED, MAX_ANGLE * SPEED)
+      @dy = -SPEED
+      @by = [@rows - 1, 1].max.to_f
+    end
+
+    def drop
+      @lives -= 1
+      @lives.zero? ? @phase = :over : serve
+    end
+
+    def draw_header(canvas, header)
+      canvas.fill(header, BAR)
+      text = " score #{@score}  lives #{@lives}   arrows/h l=move  Space=serve  q=quit"
+      canvas.text(header.row, header.col, TuiTui::DisplayText.new(text).truncate(header.cols), BAR)
+    end
+
+    def draw_bricks(canvas, field)
+      @bricks.each do |(row, index), style|
+        left = (index * BRICK_W) + 1
+        canvas.text(field.row + row, field.col + left, " " * [BRICK_W, @cols - left + 1].min, style)
+      end
+    end
+
+    def draw_paddle(canvas, field)
+      canvas.text(field.row + @rows, field.col + @paddle, " " * @paddle_w, PADDLE)
+    end
+
+    def draw_ball(canvas, field)
+      return if %i[over clear].include?(@phase)
+
+      canvas.text(field.row + @by.round.clamp(1, @rows), field.col + @bx.round.clamp(1, @cols), "o", BALL)
+    end
+
+    def draw_message(canvas, field)
+      text = {serve: "Space to serve", over: "GAME OVER - Space to restart",
+              clear: "YOU WIN! - Space to restart"}[@phase]
+      return unless text
+
+      row = field.row + (field.rows / 2)
+      canvas.text(row, field.col + [(field.cols - text.length) / 2, 1].max, text, MSG)
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  TuiTui::Runtime.new(BreakoutSample::Breakout.new).run(tick: 0.016)
+end

data/examples/counter.rb

@@ -2,8 +2,9 @@
 # frozen_string_literal: true
 
 # The smallest possible TuiTui app: a counter. It shows the whole contract and
-# nothing else — `view(size) -> Canvas` and `update(event) -> self | :quit` —
-# with no widgets and no layout.
+# nothing else — `view(size) -> Canvas` and `update(event) -> app | :quit` —
+# with no widgets and no layout. Events are `Data.define` values, so `update`
+# dispatches with Ruby's pattern matching (`case`/`in`).
 #
 #   ruby examples/counter.rb
 #
@@ -16,20 +17,18 @@ module CounterSample
   HINT = TuiTui::Style.new(attrs: [:dim])
 
   class Counter
-    def initialize
-      @count = 0
+    def initialize(count = 0)
+      @count = count
     end
 
     def update(event)
-      return self unless event.is_a?(TuiTui::KeyEvent)
-
-      case event.key
-      when "q", TuiTui::KeyCode::CTRL_C then return :quit
-      when "j", "+", :up then @count += 1
-      when "k", "-", :down then @count -= 1
-      when "r" then @count = 0
+      case event
+      in TuiTui::KeyEvent(key: "q" | TuiTui::KeyCode::CTRL_C) then :quit
+      in TuiTui::KeyEvent(key: "j" | "+" | :up) then Counter.new(@count + 1)
+      in TuiTui::KeyEvent(key: "k" | "-" | :down) then Counter.new(@count - 1)
+      in TuiTui::KeyEvent(key: "r") then Counter.new(0)
+      else self
       end
-      self
     end
 
     def view(size)

data/examples/csv_viewer.rb

@@ -46,7 +46,8 @@ module CsvViewerSample
     def initialize(path)
       @path = path
       @header, @rows, @error = load_csv(path)
-      @list = TuiTui::ScrollList.new(@rows.size)
+      @list = TuiTui::Widget::ScrollList.new(@rows.size)
+      @table = TuiTui::Widget::Table.new(@list)
       @col = 0
       @left_col = 0
       @page = 1
@@ -74,9 +75,7 @@ module CsvViewerSample
 
     def view(size)
       canvas = TuiTui::Canvas.blank(size)
-      body, footer = split_footer(size)
-      detail, status = footer.split_h(1)
-      table = body
+      table, detail, status = TuiTui::Rect.of(size).split_rows(:rest, 1, 1)
 
       @page = [table.rows - 1, 1].max
       @list.ensure_visible(@page)
@@ -114,38 +113,36 @@ module CsvViewerSample
     def pad_row(row, width) = row + Array.new(width - row.size, "")
     def default_header(width) = Array.new(width) { |i| "column_#{i + 1}" }
 
-    def split_footer(size)
-      whole = TuiTui::Rect.new(row: 1, col: 1, rows: size.rows, cols: size.cols)
-      return [whole, TuiTui::Rect.new(row: size.rows, col: 1, rows: 0, cols: size.cols)] if size.rows < 3
-
-      whole.split_h(size.rows - 2)
-    end
-
     def draw_table(canvas, rect)
       return if rect.rows <= 0 || rect.cols <= 0
 
-      canvas.fill(TuiTui::Rect.new(row: rect.row, col: rect.col, rows: 1, cols: rect.cols), STYLE[:header])
-      canvas.text(rect.row, rect.col, fit("#", ROW_NUMBER_WIDTH), STYLE[:header])
-      each_visible_column(rect.cols - ROW_NUMBER_WIDTH) do |index, col, width|
-        style = index == @col ? STYLE[:selected_cell] : STYLE[:header]
-        canvas.text(rect.row, col, fit(@header[index], width), style)
-      end
+      @table.draw(canvas, rect,
+                  columns: visible_columns,
+                  header_style: STYLE[:header],
+                  highlight: STYLE[:selected_row]) { |row_index, selected| row_cells(row_index, selected) }
 
-      if @rows.empty?
-        canvas.text(rect.row + 1, rect.col + 1, "No rows", STYLE[:dim]) if rect.rows > 1
-        return
+      canvas.text(rect.row + 1, rect.col + 1, "No rows", STYLE[:dim]) if @rows.empty? && rect.rows > 1
+    end
+
+    # The row-number column plus every data column from the left edge on;
+    # Table clips whatever overflows the rect. The selected column's label
+    # carries its own accent Span.
+    def visible_columns
+      data = (@left_col..last_col).map do |index|
+        label = index == @col ? TuiTui::Span[@header[index], STYLE[:selected_cell]] : @header[index]
+        [label, @widths[index]]
       end
+      [["#", ROW_NUMBER_WIDTH]] + data
+    end
 
-      @list.each_visible([rect.rows - 1, 0].max) do |row_index, offset|
-        row = rect.row + 1 + offset
-        selected = row_index == @list.cursor
-        canvas.fill(TuiTui::Rect.new(row: row, col: rect.col, rows: 1, cols: rect.cols), STYLE[:selected_row]) if selected
-        canvas.text(row, rect.col, fit((row_index + 1).to_s, ROW_NUMBER_WIDTH), selected ? STYLE[:selected_row] : STYLE[:row_number])
-        each_visible_column(rect.cols - ROW_NUMBER_WIDTH) do |index, col, width|
-          style = selected && index == @col ? STYLE[:selected_cell] : (selected ? STYLE[:selected_row] : nil)
-          canvas.text(row, col, fit(@rows[row_index][index], width), style)
-        end
+    def row_cells(row_index, selected)
+      number = (row_index + 1).to_s
+      cells = [selected ? number : TuiTui::Span[number, STYLE[:row_number]]]
+      (@left_col..last_col).each do |index|
+        value = @rows[row_index][index]
+        cells << (selected && index == @col ? TuiTui::Span[value, STYLE[:selected_cell]] : value)
       end
+      cells
     end
 
     def draw_detail(canvas, rect)
@@ -174,19 +171,6 @@ module CsvViewerSample
       canvas.text(rect.row, rect.col + rect.cols - width, right, STYLE[:status])
     end
 
-    def each_visible_column(available)
-      return if available <= 0
-
-      col = ROW_NUMBER_WIDTH + 1
-      @left_col.upto(last_col) do |index|
-        width = @widths[index]
-        break if col + width - 1 > available + ROW_NUMBER_WIDTH
-
-        yield index, col, width
-        col += width
-      end
-    end
-
     def ensure_column_visible(available)
       return if available <= 0
 
@@ -200,7 +184,7 @@ module CsvViewerSample
     def first_hidden_column(available)
       used = 0
       @left_col.upto(last_col) do |index|
-        used += @widths[index]
+        used += @widths[index] + 1 # +1 for Table's column gap
         return index if used > available
       end
       last_col + 1
@@ -216,15 +200,9 @@ module CsvViewerSample
       @header.each_index.map do |index|
         values = [@header[index], *@rows.first(200).map { |row| row[index] }]
         width = values.map { |value| TuiTui::DisplayText.new(value.to_s).width }.max || MIN_COLUMN_WIDTH
-        (width + 2).clamp(MIN_COLUMN_WIDTH, MAX_COLUMN_WIDTH)
+        (width + 1).clamp(MIN_COLUMN_WIDTH, MAX_COLUMN_WIDTH)
       end
     end
-
-    def fit(value, width)
-      text = TuiTui::DisplayText.new(" #{value}")
-      text = text.truncate(width - 1) if text.width >= width
-      text.to_s + (" " * [width - text.width, 0].max)
-    end
   end
 end