tui_tui 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7ad8088986ea6e9bc201be5c89597019f4a256de1531f73184e489233752175
-  data.tar.gz: b08cec47d0355748b9fdf732527f29d2ad2cb104ae1e88c0af5c17a9e488f552
+  metadata.gz: 499d4c344b19e2fca357f58d50471d80033b99b5fb94f32943f70383dd4eceaa
+  data.tar.gz: 31b39eb3d5d3de1361a9f3679277f4ea859b0fc5b7a5bd9a78bb6d69e250adf7
 SHA512:
-  metadata.gz: 4058461db872786a4db951d4b1cd4b789ca7cc5cdfc07eeec8be7c4f2d1290bca30916f2405fe021f870465d74acab0f886128705567aca961346f389a048684
-  data.tar.gz: 3634ec3d3c0da6967adf48af668790559087690e543352a9bb3690d61b435553689e46647cbb13b8619deec409abd19fa95f9bb286d8140baaa1d328237ad114
+  metadata.gz: 74c01a1dc4fc3d95568bb9c4fde27bb43b6047f2ea17547342df2ec051e159a6b8aabaa7380039d87aa763dea0d61c24e0e7736ce9d9b29091dabe78cec041ab
+  data.tar.gz: 5241bf9a256248c5da1430f67068d74639dfd44fce1be034b20736f4f55d0334ab4ad296a232a9433b2d53ba9c2054a60c509b9ee765d667e74d67fe9915c6cf

data/CHANGELOG.md

@@ -0,0 +1,34 @@
+# Changelog
+
+## [0.2.0] - 2026-06-17
+
+### Added
+- Optional Unicode box-drawing chrome: probed once at startup and used only when
+  the terminal renders it at width 1, else ASCII. Override with `TUITUI_BOX`.
+- `RenderContext` passed to `view` (a `Size`-compatible value with a `canvas`
+  factory); legacy `view(size)` apps keep working.
+- `Rect#include?(row, col)` and `Rect#hit?(mouse_event)` for mouse hit-testing.
+- `List#index_at(rect, event, scrollbar:)` to map a click to a list index,
+  accounting for the scroll offset and the scrollbar gutter.
+- `Theme` semantic status roles — `success` / `warning` / `danger` / `info`
+  (background-aware, hue-independent) — plus `Theme#status(kind)` to map
+  symbolic kinds (`:ok`, `:warn`, `:error`, `:info`, with aliases) to a role.
+- `ModalHost`: a host-side helper that owns the current modal widget, routing
+  `MouseEvent`s to `#handle_mouse` and other events to `#handle`, and running an
+  `on_result` callback when the widget resolves.
+- `auto:` option for `List.draw` / `TextView.draw`: reserve the scrollbar gutter
+  only when the content overflows the rect.
+
+### Fixed
+- Silence the "method redefined; discarding old []" warning from `Span` under
+  `-w` by removing the `Data`-generated `.[]` before redefining the convenience
+  constructor.
+
+## [0.1.0] - 2026-06-16
+
+### Added
+- Initial release: a lightweight, dependency-free (io/console only) TEA-inspired
+  (MVU) TUI toolkit — Canvas with per-cell diffing, Theme, layout `Rect`s,
+  widgets (List, TextView, Scrollbar, StatusBar, Toast, Modal, Confirm, Select,
+  Help, Prompt, Pager, Fuzzy), East-Asian-width-aware text, and a `Runtime`
+  event loop.

data/README.md

@@ -84,17 +84,12 @@ Glyphs are clipped at region edges, not split across them.
 Movement and redraw stay responsive, even with large content.
 Only changed rows are repainted, so cost scales with the change, not the screen size.
 
-#### N7: Width-safe UI chrome (ASCII).
+#### N7: Width-safe UI chrome.
 
-Self-drawn chrome uses only ASCII, color, and spacing.
-ASCII characters have a guaranteed width of 1.
-
-Unicode box-drawing characters are never used.
-Their width can vary under CJK terminal settings and break layouts.
-
-Vertical splits are drawn as a colored one-column gutter.
-Rules are drawn with ASCII `-` or a background fill.
-Selection is drawn with `:reverse`.
+Self-drawn chrome defaults to ASCII, color, and spacing, which have a guaranteed
+width of 1. Unicode box-drawing has an ambiguous width that can break layouts under
+CJK terminal settings, so it is only used when the terminal is confirmed to render
+it at width 1; otherwise the chrome falls back to ASCII.
 
 Content text, such as Japanese data, is measured with `Width`.
 It is clipped or padded to fit the available space.
@@ -105,6 +100,7 @@ Environment variables (all optional):
 
 - `TUITUI_MOUSE` — set to `0`/`off`/`false` to disable mouse reporting (on by default).
 - `TUITUI_BACKGROUND` — `light` or `dark` to pick the theme for your terminal background. Without it, `COLORFGBG` is read if present, otherwise `dark` is assumed (reliable auto-detection isn't possible on all terminals).
+- `TUITUI_BOX` — `ascii` / `unicode` / `auto` to force or auto-detect Unicode box-drawing chrome (default `auto`: used only when the terminal renders it at width 1, else ASCII).
 
 ## Installation
 

data/examples/file_browser.rb

@@ -288,8 +288,9 @@ module FileBrowserSample
 
     def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
-    def view(size)
-      canvas = TuiTui::Canvas.blank(size)
+    def view(ctx)
+      size = ctx.size
+      canvas = ctx.canvas
       body, status = split_status(size)
       list_rect, preview_rect = split_panes(body)
       @list_rect = list_rect       # remembered so a click can hit-test the list
@@ -552,10 +553,11 @@ module FileBrowserSample
     # --- drawing ---
 
     # A dim vertical rule in the 1-column gutter between the panes (the column
-    # split_ratio left between list and preview). ASCII "|" (N7), dim like frames.
+    # split_ratio left between list and preview). Follows the canvas chrome:
+    # ASCII "|" by default, "│" when the terminal probed as Unicode-capable.
     def draw_divider(canvas, list_rect)
       col = list_rect.col + list_rect.cols
-      canvas.fill(TuiTui::Rect.new(row: list_rect.row, col: col, rows: list_rect.rows, cols: 1), @styles[:divider], "|")
+      canvas.fill(TuiTui::Rect.new(row: list_rect.row, col: col, rows: list_rect.rows, cols: 1), @styles[:divider], canvas.chrome.v)
     end
 
     def draw_list(canvas, rect)

data/examples/paint.rb

@@ -160,9 +160,10 @@ module PaintSample
       end
     end
 
-    def view(size)
+    def view(ctx)
+      size = ctx.size
       @rows = size.rows
-      canvas = TuiTui::Canvas.blank(size)
+      canvas = ctx.canvas
       @cells.each do |(row, col), color|
         next unless row.between?(PAINT_TOP, size.rows) && col.between?(1, size.cols)
 

data/examples/widgets.rb

@@ -46,8 +46,9 @@ module WidgetsSample
       end
     end
 
-    def view(size)
-      canvas = TuiTui::Canvas.blank(size)
+    def view(ctx)
+      size = ctx.size
+      canvas = ctx.canvas
       canvas.text(2, 3, "TuiTui widget gallery", @theme.title)
       canvas.text(4, 3, "theme: #{THEMES[@theme_i]}", @theme.accent)
       canvas.text(5, 3, "last result: #{@last}", @theme.text)

data/lib/tui_tui/box_chrome.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module TuiTui
+  # The glyph set used to draw chrome (frame borders, dividers, scrollbar track).
+  BoxChrome = Data.define(:tl, :tr, :bl, :br, :h, :v, :lt, :rt, :tt, :bt, :cross, :track)
+
+  class BoxChrome
+    ASCII = new(
+      tl: "+", tr: "+", bl: "+", br: "+",
+      h: "-", v: "|",
+      lt: "+", rt: "+", tt: "+", bt: "+", cross: "+",
+      track: "|"
+    )
+
+    # Single-line box drawing (U+2500..U+253C).
+    UNICODE = new(
+      tl: "┌", tr: "┐", bl: "└", br: "┘",
+      h: "─", v: "│",
+      lt: "├", rt: "┤", tt: "┬", bt: "┴", cross: "┼",
+      track: "│"
+    )
+
+    # The distinct Unicode glyphs chrome can emit, probed as one string.
+    PROBE_GLYPHS = "─│┌┐└┘├┤┬┴┼"
+
+    # Narrower than this and the probe glyphs would wrap at column 1.
+    MIN_PROBE_COLS = 12
+
+    # Resolve an override string to a chrome, or :auto when a probe is needed.
+    def self.from(name)
+      case name.to_s.downcase
+      when "ascii", "0", "off", "false" then ASCII
+      when "unicode", "1", "on", "true" then UNICODE
+      else :auto
+      end
+    end
+
+    # The capability gate: every probed glyph must render at width 1, so the total
+    # advance equals the glyph count.
+    def self.supported?(total_width)
+      total_width == PROBE_GLYPHS.length
+    end
+
+    # Full resolution given a live console. Honors TUITUI_BOX, else probes; falls
+    # back to ASCII when forced off, the terminal is too narrow, or the probe fails.
+    def self.resolve(input:, output:, term_cols:, env: ENV, prober: BoxProber.new)
+      forced = from(env["TUITUI_BOX"].to_s)
+      return forced unless forced == :auto
+      return ASCII if term_cols < MIN_PROBE_COLS
+
+      supported?(prober.measure_all(input: input, output: output)) ? UNICODE : ASCII
+    end
+  end
+end

data/lib/tui_tui/box_prober.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "box_chrome"
+
+module TuiTui
+  # Measures how many columns a string of box-drawing glyphs actually occupies on
+  # the live terminal, by printing them and asking for the cursor position (DSR).
+  class BoxProber
+    # Cursor Position Report: ESC [ row ; col R -> capture the column.
+    CPR = /\e\[\d+;(\d+)R/
+    MAX_REPLY_BYTES = 64
+
+    def initialize(glyphs: BoxChrome::PROBE_GLYPHS, timeout: 0.2, wait: nil)
+      @glyphs = glyphs
+      @timeout = timeout
+      @wait = wait || method(:wait_readable)
+    end
+
+    def measure_all(input:, output:)
+      output.write("\r")     # known baseline: column 1
+      output.write(@glyphs)  # advances by the sum of glyph widths
+      output.write("\e[6n")  # DSR: request cursor position
+      output.flush
+      col = read_column(input)
+      cleanup(output)
+      col.nil? ? -1 : col - 1
+    end
+
+    private
+
+    # Wipe the probe line before the first render (the alt screen stays clean).
+    def cleanup(output)
+      output.write("\r\e[K")
+      output.flush
+    end
+
+    def read_column(input)
+      deadline = monotonic + @timeout
+      buf = +""
+      loop do
+        remaining = deadline - monotonic
+        break if remaining <= 0
+        break unless @wait.call(input, remaining)
+
+        char = input.getc
+        break if char.nil?
+
+        buf << char
+        if (match = CPR.match(buf))
+          return match[1].to_i
+        end
+        break if buf.bytesize > MAX_REPLY_BYTES
+      end
+      nil
+    end
+
+    def wait_readable(io, timeout) = io.wait_readable(timeout)
+
+    def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+end

data/lib/tui_tui/canvas.rb

@@ -5,6 +5,7 @@ require_relative "text_sanitizer"
 require_relative "display_text"
 require_relative "style"
 require_relative "cell"
+require_relative "box_chrome"
 
 module TuiTui
   # Pure drawing surface. Coordinates are 1-origin to match terminal cursor
@@ -14,18 +15,20 @@ module TuiTui
     CONTROL_GLYPH = "?"
     FRAME = Style.new(fg: :bright_black)
 
-    def self.blank(size)
-      new(size.rows, size.cols)
+    def self.blank(size, chrome: BoxChrome::ASCII)
+      new(size.rows, size.cols, chrome: chrome)
     end
 
     attr_reader :rows, :cols
     attr_reader :cursor
+    attr_reader :chrome
 
-    def initialize(rows, cols)
+    def initialize(rows, cols, chrome: BoxChrome::ASCII)
       @rows = rows
       @cols = cols
       @grid = Array.new(rows) { Array.new(cols, Cell::BLANK) }
       @cursor = nil
+      @chrome = chrome
     end
 
     def cursor_at(row, col)
@@ -92,14 +95,14 @@ module TuiTui
       text(row, col, char * len, style)
     end
 
-    def frame(rect, style: FRAME)
+    def frame(rect, style: FRAME, chrome: @chrome)
       fill(rect, nil)
-      bar = "+#{"-" * (rect.cols - 2)}+"
-      text(rect.row, rect.col, bar, style)
-      text(rect.row + rect.rows - 1, rect.col, bar, style)
+      mid = chrome.h * (rect.cols - 2)
+      text(rect.row, rect.col, chrome.tl + mid + chrome.tr, style)
+      text(rect.row + rect.rows - 1, rect.col, chrome.bl + mid + chrome.br, style)
       (1...(rect.rows - 1)).each do |dy|
-        text(rect.row + dy, rect.col, "|", style)
-        text(rect.row + dy, rect.col + rect.cols - 1, "|", style)
+        text(rect.row + dy, rect.col, chrome.v, style)
+        text(rect.row + dy, rect.col + rect.cols - 1, chrome.v, style)
       end
 
       self

data/lib/tui_tui/list.rb

@@ -12,8 +12,10 @@ module TuiTui
       @scroll = scroll
     end
 
-    def draw(canvas, rect, highlight: nil, scrollbar: nil)
-      body, gutter = scrollbar ? rect.split_gutter : [rect, nil]
+    def draw(canvas, rect, highlight: nil, scrollbar: nil, auto: false)
+      # With auto:, reserve the gutter only when the content overflows the rect.
+      show_bar = scrollbar && !(auto && @scroll.count <= rect.rows)
+      body, gutter = show_bar ? rect.split_gutter : [rect, nil]
       @scroll.ensure_visible(body.rows)
       @scroll.each_visible(body.rows) do |index, offset|
         row = body.row + offset
@@ -26,6 +28,18 @@ module TuiTui
       canvas
     end
 
+    # Map a MouseEvent to the list index under it, or nil. Pass the same `rect`
+    # and `scrollbar:` used for `draw` so the gutter column is excluded and the
+    # scroll offset matches what was rendered. Returns nil for clicks outside the
+    # body or below the last item.
+    def index_at(rect, event, scrollbar: nil)
+      body = scrollbar ? rect.split_gutter.first : rect
+      return nil unless body.hit?(event)
+
+      index = @scroll.top + (event.row - body.row)
+      index < @scroll.count ? index : nil
+    end
+
     private
 
     def draw_scrollbar(canvas, gutter, theme)

data/lib/tui_tui/modal_host.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "event"
+
+module TuiTui
+  # Host-side helper for the app that *owns* the current modal widget.
+  #
+  # Centralizes the open + dispatch loop every app with modals otherwise hand
+  # writes: it routes MouseEvents to #handle_mouse and other events to #handle,
+  # honors the "resolved value, or nil to stay open" widget contract, and runs
+  # the caller's on_result callback when the modal resolves.
+  #
+  #   host = TuiTui::ModalHost.new
+  #   host.open(TuiTui::Confirm.new("Quit?")) { |r| :quit if r == :ok }
+  #   # in update(event):
+  #   if host.open?
+  #     outcome = host.handle(event)   # nil while open; on_result value once resolved
+  #     return outcome == :quit ? :quit : self
+  #   end
+  #   # in view(size): host.draw(canvas, size) if host.open?
+  class ModalHost
+    def open(widget, &on_result)
+      @widget = widget
+      @on_result = on_result || ->(result) { result }
+      self
+    end
+
+    def open? = !@widget.nil?
+
+    def close
+      @widget = nil
+      @on_result = nil
+    end
+
+    def draw(canvas, size) = @widget&.draw(canvas, size)
+
+    # Route one event to the modal. Returns nil while the modal stays open
+    # (the event was consumed), or the on_result callback's value once the
+    # widget resolves (e.g. :quit, or a new app model).
+    def handle(event)
+      return nil unless open?
+
+      result = dispatch(event)
+      return nil if result.nil?
+
+      callback = @on_result
+      close
+      callback.call(result)
+    end
+
+    private
+
+    def dispatch(event)
+      case event
+      when MouseEvent then @widget.handle_mouse(event)
+      when KeyEvent then @widget.handle(event.key)
+      else @widget.handle(event)
+      end
+    end
+  end
+end

data/lib/tui_tui/rect.rb

@@ -37,6 +37,14 @@ module TuiTui
       Rect.new(row: row, col: col + by, rows: rows, cols: cols - by)
     end
 
+    # Whether a 1-origin cell (row, col) falls inside this rectangle.
+    def include?(r, c)
+      r.between?(row, row + rows - 1) && c.between?(col, col + cols - 1)
+    end
+
+    # Whether a MouseEvent's cell falls inside this rectangle.
+    def hit?(mouse) = include?(mouse.row, mouse.col)
+
     # Carve `width` columns off the right edge for a scrollbar gutter. Returns
     # [body, gutter]; gutter is nil when the rect is too narrow to spare them.
     def split_gutter(width = 1)

data/lib/tui_tui/render_context.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "canvas"
+
+module TuiTui
+  # What an app's `view` receives: the terminal size plus the resolved chrome
+  RenderContext = Data.define(:size, :chrome) do
+    def rows = size.rows
+    def cols = size.cols
+
+    # A blank canvas already carrying the resolved chrome.
+    def canvas = Canvas.blank(size, chrome: chrome)
+  end
+end

data/lib/tui_tui/runtime.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "screen"
+require_relative "render_context"
 
 module TuiTui
   # Small Elm-style loop: render, read one event, fold it through the app, repeat.
@@ -9,11 +10,11 @@ module TuiTui
       @app = app
     end
 
-    def run(input: $stdin, output: $stdout, depth: ColorDepth.detect, tick: 0.1, mouse: Screen.mouse_default)
-      Screen.run(input: input, output: output, depth: depth, mouse: mouse) do |screen|
+    def run(input: $stdin, output: $stdout, depth: ColorDepth.detect, tick: 0.1, mouse: Screen.mouse_default, box: ENV["TUITUI_BOX"])
+      Screen.run(input: input, output: output, depth: depth, mouse: mouse, box: box) do |screen|
         raise "tui_tui: not a terminal" if screen.nil?
 
-        screen.render(@app.view(screen.size))
+        screen.render(view(screen))
         loop do
           event = screen.events.next_event(tick: tick)
           break if event.is_a?(EofEvent)
@@ -25,13 +26,19 @@ module TuiTui
 
           @app = result
           flush_clipboard(screen)
-          screen.render(@app.view(screen.size))
+          screen.render(view(screen))
         end
       end
     end
 
     private
 
+    # Pass a RenderContext (size + resolved chrome + canvas factory). It is
+    # Size-compatible, so legacy `view(size)` apps keep working (ASCII).
+    def view(screen)
+      @app.view(RenderContext.new(size: screen.size, chrome: screen.chrome))
+    end
+
     def flush_clipboard(screen)
       # Clipboard writes stay an effect of the loop, requested by the app.
       return unless @app.respond_to?(:take_clipboard)

data/lib/tui_tui/screen.rb

@@ -5,6 +5,8 @@ require "io/console"
 require_relative "ansi"
 require_relative "size"
 require_relative "color_depth"
+require_relative "box_chrome"
+require_relative "box_prober"
 require_relative "canvas_compositor"
 require_relative "terminal_size"
 require_relative "event_stream"
@@ -15,12 +17,12 @@ module TuiTui
   class Screen
     DEFAULT_SIZE = Size.new(rows: 24, cols: 80)
 
-    def self.run(input: $stdin, output: $stdout, depth: ColorDepth.detect, mouse: mouse_default)
+    def self.run(input: $stdin, output: $stdout, depth: ColorDepth.detect, mouse: mouse_default, box: ENV["TUITUI_BOX"])
       console = IO.console
       # Let callers provide a non-interactive fallback for piped output.
       return yield(nil) if console.nil? || !output.tty?
 
-      screen = new(console, input, output, depth, mouse: mouse)
+      screen = new(console, input, output, depth, mouse: mouse, box: box)
       screen.start
       begin
         yield screen
@@ -33,8 +35,12 @@ module TuiTui
       !%w[0 off false].include?(ENV["TUITUI_MOUSE"])
     end
 
-    def initialize(console, input, output, depth, mouse: true)
+    def initialize(console, input, output, depth, mouse: true, box: nil)
+      @input = input
       @output = output
+      @box_override = box
+      # ASCII until start probes a real TTY; safe for non-TTY/StringIO callers.
+      @chrome = BoxChrome::ASCII
       @compositor = CanvasCompositor.new(depth: depth)
       @term_size = TerminalSize.new(console, default: DEFAULT_SIZE)
       @events = EventStream.new(input: input, size: @term_size)
@@ -44,9 +50,19 @@ module TuiTui
       @cursor = nil
     end
 
-    attr_reader :events
-
-    def start = @session.start
+    attr_reader :events, :chrome
+
+    def start
+      @session.start
+      # Probe box-drawing support once, after raw mode + alt screen, before the
+      # first render/next_event so the DSR reply never reaches the key reader.
+      @chrome = BoxChrome.resolve(
+        input: @input,
+        output: @output,
+        term_cols: size.cols,
+        env: {"TUITUI_BOX" => @box_override}
+      )
+    end
 
     def size = @term_size.size
 

data/lib/tui_tui/scrollbar.rb

@@ -13,9 +13,10 @@ module TuiTui
     TRACK = Theme::DEFAULT.scroll_track
     THUMB = Theme::DEFAULT.scroll_thumb
 
-    def draw(canvas, rect, top:, visible:, total:, track: "|", thumb: " ", track_style: TRACK, thumb_style: THUMB)
+    def draw(canvas, rect, top:, visible:, total:, track: nil, thumb: " ", track_style: TRACK, thumb_style: THUMB)
       return canvas if rect.rows <= 0
 
+      track ||= canvas.chrome.track
       length, offset = geometry(rect.rows, top, visible, total)
       rect.rows.times do |i|
         in_thumb = i >= offset && i < offset + length

data/lib/tui_tui/span.rb

@@ -6,6 +6,11 @@ module TuiTui
   # A run of text sharing one Style.
   # Width is terminal-column aware via DisplayText.
   Span = Data.define(:text, :style) do
+    # Data.define auto-generates Span.[] as an alias of .new. Remove it before
+    # redefining so our convenience form (style optional, text coerced) does not
+    # print a "method redefined" warning under -w.
+    singleton_class.send(:remove_method, :[])
+
     # Convenience constructor: Span["hi", style] (style optional).
     def self.[](text, style = nil) = new(text: text.to_s, style: style)
 

data/lib/tui_tui/text_view.rb

@@ -10,8 +10,12 @@ module TuiTui
   module TextView
     module_function
 
-    def draw(canvas, rect, lines = nil, top: 0, style: nil, scrollbar: nil, total: nil)
-      body, gutter = scrollbar ? rect.split_gutter : [rect, nil]
+    def draw(canvas, rect, lines = nil, top: 0, style: nil, scrollbar: nil, total: nil, auto: false)
+      # With auto:, reserve the gutter only when the content overflows the rect.
+      # When the total is unknown (lazy block, no total:), the bar is kept.
+      count = total || lines&.length
+      show_bar = scrollbar && !(auto && count && count <= rect.rows)
+      body, gutter = show_bar ? rect.split_gutter : [rect, nil]
       body.rows.times do |offset|
         index = top + offset
         content = lines ? lines[index] : yield(index)

data/lib/tui_tui/theme.rb

@@ -22,23 +22,47 @@ module TuiTui
     :bar,
     :cursor,
     :scroll_track,
-    :scroll_thumb
+    :scroll_thumb,
+    # semantic status roles (hue-independent, background-aware)
+    :success,
+    :warning,
+    :danger,
+    :info
   )
 
   class Theme
+    # Map a symbolic status to its semantic role Style (with common aliases).
+    def status(kind)
+      case kind
+      when :ok, :success then success
+      when :warn, :warning then warning
+      when :error, :danger then danger
+      when :info then info
+      else text
+      end
+    end
+
     # Background-dependent neutral roles.
     SURFACES = {
       dark: {
         text: Style.new,
         muted: Style.new(fg: 245),
         bar: Style.new(fg: 252, bg: 238),
-        selection_dim: Style.new(fg: 247, bg: 238)
+        selection_dim: Style.new(fg: 247, bg: 238),
+        success: Style.new(fg: 71),
+        warning: Style.new(fg: 179),
+        danger: Style.new(fg: 167),
+        info: Style.new(fg: 110)
       },
       light: {
         text: Style.new,
         muted: Style.new(fg: 240),
         bar: Style.new(fg: 16, bg: 252),
-        selection_dim: Style.new(fg: 240, bg: 252)
+        selection_dim: Style.new(fg: 240, bg: 252),
+        success: Style.new(fg: 28),
+        warning: Style.new(fg: 130),
+        danger: Style.new(fg: 124),
+        info: Style.new(fg: 25)
       }
     }.freeze
 
@@ -79,7 +103,11 @@ module TuiTui
         bar: surface[:bar],
         cursor: selection,
         scroll_track: Style.new(fg: a[:line]),
-        scroll_thumb: Style.new(bg: a[:sel][1])
+        scroll_thumb: Style.new(bg: a[:sel][1]),
+        success: surface[:success],
+        warning: surface[:warning],
+        danger: surface[:danger],
+        info: surface[:info]
       )
     end
 

data/lib/tui_tui/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TuiTui
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/tui_tui.rb

@@ -9,6 +9,8 @@ require_relative "tui_tui/span"
 require_relative "tui_tui/line"
 require_relative "tui_tui/ansi"
 require_relative "tui_tui/color_depth"
+require_relative "tui_tui/box_chrome"
+require_relative "tui_tui/box_prober"
 require_relative "tui_tui/palette"
 require_relative "tui_tui/style"
 require_relative "tui_tui/theme"
@@ -16,6 +18,7 @@ require_relative "tui_tui/size"
 require_relative "tui_tui/rect"
 require_relative "tui_tui/cell"
 require_relative "tui_tui/canvas"
+require_relative "tui_tui/render_context"
 require_relative "tui_tui/canvas_compositor"
 require_relative "tui_tui/event"
 require_relative "tui_tui/key_code"
@@ -32,6 +35,7 @@ require_relative "tui_tui/toast"
 require_relative "tui_tui/focus_ring"
 require_relative "tui_tui/fuzzy"
 require_relative "tui_tui/modal"
+require_relative "tui_tui/modal_host"
 require_relative "tui_tui/confirm"
 require_relative "tui_tui/select"
 require_relative "tui_tui/help"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tui_tui
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - takahashim
@@ -19,6 +19,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".github/workflows/ci.yml"
+- CHANGELOG.md
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -33,6 +34,8 @@ files:
 - examples/widgets.rb
 - lib/tui_tui.rb
 - lib/tui_tui/ansi.rb
+- lib/tui_tui/box_chrome.rb
+- lib/tui_tui/box_prober.rb
 - lib/tui_tui/canvas.rb
 - lib/tui_tui/canvas_compositor.rb
 - lib/tui_tui/cell.rb
@@ -50,10 +53,12 @@ files:
 - lib/tui_tui/line.rb
 - lib/tui_tui/list.rb
 - lib/tui_tui/modal.rb
+- lib/tui_tui/modal_host.rb
 - lib/tui_tui/pager.rb
 - lib/tui_tui/palette.rb
 - lib/tui_tui/prompt.rb
 - lib/tui_tui/rect.rb
+- lib/tui_tui/render_context.rb
 - lib/tui_tui/runtime.rb
 - lib/tui_tui/screen.rb
 - lib/tui_tui/scroll_list.rb
@@ -78,6 +83,7 @@ metadata:
   allowed_push_host: https://rubygems.org
   homepage_uri: https://github.com/takahashim/tui_tui
   source_code_uri: https://github.com/takahashim/tui_tui
+  changelog_uri: https://github.com/takahashim/tui_tui/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib