tui_tui 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 499d4c344b19e2fca357f58d50471d80033b99b5fb94f32943f70383dd4eceaa
-  data.tar.gz: 31b39eb3d5d3de1361a9f3679277f4ea859b0fc5b7a5bd9a78bb6d69e250adf7
+  metadata.gz: 509e482a4d22483da9840ee1ea39021f27f747f2c6919d7782e46f41dbfdfea0
+  data.tar.gz: 731b150add99bd21eafef87e2a33c36679eb5998f01a78bf317217a1c7ee428a
 SHA512:
-  metadata.gz: 74c01a1dc4fc3d95568bb9c4fde27bb43b6047f2ea17547342df2ec051e159a6b8aabaa7380039d87aa763dea0d61c24e0e7736ce9d9b29091dabe78cec041ab
-  data.tar.gz: 5241bf9a256248c5da1430f67068d74639dfd44fce1be034b20736f4f55d0334ab4ad296a232a9433b2d53ba9c2054a60c509b9ee765d667e74d67fe9915c6cf
+  metadata.gz: '068472d5d8dd0c5ae371ffe2516bbe1f1a548d3d55c97e85b898e821640ed6a64b0e8005fa3e8c219c20cfae79e1e86efafbb2f851f7dbbc6830e5ec2e59c455'
+  data.tar.gz: 37e91b9643cc30df3a887e90004859cc37035c52882f353a66148fce585d47c1ba1075af142650fad597e3d34652b9a1983a11f2c19019163740920cff4afadf

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## [0.3.0] - 2026-06-22
+
+### Added
+- `Pager` accepts styled lines for coloring: each line may be a plain `String`,
+  a `Line`, or an array of `Span`s, so a log / diff / error view can color whole
+  lines or runs within them. Unstyled spans fall back to `theme.muted`.
+- `Line.coerce(content, style = nil)`: shared `String` / `Span` / `Span`-array /
+  `Line` → `Line` conversion, used by `List`, `TextView`, and `Pager`.
+- `CommandPalette`: a fuzzy-filtered command palette modal (type to narrow,
+  arrows or Ctrl-N/Ctrl-P to move, Enter to pick, Esc to cancel). Items are
+  arbitrary objects with an optional label block; resolves to the chosen item.
+- Per-frame mouse-reporting toggle: an app may implement `wants_mouse?` and the
+  `Runtime` applies it each frame (via `Screen#mouse=` / `TerminalSession#mouse=`),
+  so it can release the mouse for a native terminal selection and recapture it.
+
+### Fixed
+- Raw mode now keeps the interrupt/quit/suspend characters live (`raw!(intr:
+  true)`), so Ctrl-C raises `SIGINT` (a real force-quit, restored by the INT
+  trap) instead of arriving as a byte.
+
 ## [0.2.0] - 2026-06-17
 
 ### Added

data/examples/file_browser.rb

@@ -10,11 +10,11 @@
 #
 # Keys: j/k (or ↑/↓) move, l/Enter/→ open dir, h/←/Backspace up, g/G top/bottom,
 # Tab switch pane, J/K (or mouse wheel) scroll the preview, w wrap, t theme, </> divider, / fuzzy find,
-# y copy the path (OSC 52), m actions menu, ? help, q (or Ctrl-C) quit.
+# y copy the path (OSC 52), : command palette, m actions menu, ? help, q (or Ctrl-C) quit.
 #
 # `/` is an incremental fuzzy finder built on TuiTui::Fuzzy (type to narrow,
 # matched characters highlighted, ↑↓ to navigate, Enter to open, Esc to cancel).
-# The m / ? / q modals are TuiTui widgets (Select, Help, Confirm).
+# The : / m / ? / q modals are TuiTui widgets (CommandPalette, Select, Help, Confirm).
 
 require "strscan"
 require_relative "../lib/tui_tui"
@@ -177,6 +177,7 @@ module FileBrowserSample
     ["t", "cycle theme (cool / warm / mono, follows light/dark)"],
     ["/", "fuzzy find (↑↓ navigate, Enter open, Esc cancel)"],
     ["y", "copy path to clipboard"],
+    [":", "command palette (fuzzy-run any command)"],
     ["m", "actions menu"],
     ["?", "this help"],
     ["q", "quit"],
@@ -184,6 +185,20 @@ module FileBrowserSample
 
   ACTIONS = [["Up to parent", :parent], ["Refresh", :refresh], ["Quit", :quit]].freeze
 
+  # Commands surfaced in the ":" command palette. Each is [label, action]; the
+  # palette ranks by the label and resolves to the chosen pair (see run_command).
+  COMMANDS = [
+    ["Open selected entry", :open],
+    ["Up to parent directory", :parent],
+    ["Refresh listing", :refresh],
+    ["Toggle preview wrap", :wrap],
+    ["Cycle theme", :theme],
+    ["Copy path to clipboard", :copy],
+    ["Fuzzy find", :find],
+    ["Keyboard help", :help],
+    ["Quit", :quit],
+  ].freeze
+
   # The app: responds to view(size) -> Canvas and update(event) -> self | :quit,
   # which is all TuiTui::Runtime asks of it.
   class Browser
@@ -348,13 +363,39 @@ module FileBrowserSample
       end
     end
 
+    def open_help = open_modal(TuiTui::Help.new("Keys", HELP, theme: @theme)) { nil }
+
+    # The ":" command palette: a fuzzy-filtered list of every command. The palette
+    # ranks by the label and resolves to the chosen [label, action] pair (or
+    # :cancel on Esc), which run_command dispatches.
+    def open_palette
+      open_modal(TuiTui::CommandPalette.new(COMMANDS, theme: @theme) { |label, _action| label }) do |chosen|
+        run_command(chosen.last) if chosen.is_a?(Array)
+      end
+    end
+
+    def run_command(action)
+      case action
+      when :open then open_entry
+      when :parent then up_dir
+      when :refresh then load_entries
+      when :wrap then toggle_preview_wrap
+      when :theme then cycle_theme
+      when :copy then copy_path
+      when :find then enter_finder
+      when :help then open_help # palettes can chain into another modal
+      when :quit then :quit
+      end
+    end
+
     # --- input ---
 
     def handle_key(key)
       case key
       when "q", TuiTui::KeyCode::CTRL_C then confirm_quit
-      when "?" then open_modal(TuiTui::Help.new("Keys", HELP, theme: @theme)) { nil }
+      when "?" then open_help
       when "/" then enter_finder
+      when ":" then open_palette
       when "m" then open_actions
       when "l", "\r", :right then open_entry
       when "h", :left, TuiTui::KeyCode::BACKSPACE then up_dir # h / ← / Backspace
@@ -631,7 +672,7 @@ module FileBrowserSample
 
     def draw_status(canvas, rect)
       left = @finder ? " > #{@finder}" : " #{@dir}"
-      hints = @finder ? "Esc=cancel  Enter=open" : "?=help  /=find  m=menu  t=#{THEMES[@theme_i]}  q=quit"
+      hints = @finder ? "Esc=cancel  Enter=open" : "?=help  /=find  :=cmds  m=menu  t=#{THEMES[@theme_i]}  q=quit"
       right = "#{@list.cursor + 1}/#{@entries.size}  #{hints} "
       TuiTui::StatusBar.draw(canvas, rect, left: left, right: right, style: @styles[:bar])
     end

data/lib/tui_tui/box_prober.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "box_chrome"
+require_relative "clock"
 
 module TuiTui
   # Measures how many columns a string of box-drawing glyphs actually occupies on
@@ -35,10 +36,10 @@ module TuiTui
     end
 
     def read_column(input)
-      deadline = monotonic + @timeout
+      deadline = Clock.monotonic + @timeout
       buf = +""
       loop do
-        remaining = deadline - monotonic
+        remaining = deadline - Clock.monotonic
         break if remaining <= 0
         break unless @wait.call(input, remaining)
 
@@ -55,7 +56,5 @@ module TuiTui
     end
 
     def wait_readable(io, timeout) = io.wait_readable(timeout)
-
-    def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
   end
 end

data/lib/tui_tui/clock.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module TuiTui
+  # The single source of monotonic time, so timers and timeouts never depend on
+  # wall-clock adjustments. Injected as a callable where tests need to control it.
+  module Clock
+    module_function
+
+    def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+end

data/lib/tui_tui/command_palette.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require_relative "display_text"
+require_relative "text_sanitizer"
+require_relative "style"
+require_relative "scroll_list"
+require_relative "list"
+require_relative "line"
+require_relative "span"
+require_relative "rect"
+require_relative "modal"
+require_relative "fuzzy"
+require_relative "key_code"
+
+module TuiTui
+  # Fuzzy-filtered command palette modal (think Ctrl-P): type to narrow a list of
+  # commands, arrows or Ctrl-N/Ctrl-P to move, Enter to pick, Esc to cancel.
+  #
+  # Items are arbitrary objects; pass a block to derive each one's display label
+  # (defaults to #to_s). Resolves to the chosen item on Enter and :cancel on
+  # escape; stays open (nil) while the query has no matches.
+  #
+  #   host.open(CommandPalette.new(commands) { |c| c.title }) { |cmd| cmd.run; self }
+  class CommandPalette < Modal
+    MAX_ROWS = 10
+    MIN_INNER = 28
+    WHEEL = 3
+
+    def initialize(items, prompt: "> ", placeholder: "Type to search…", theme: Theme::DEFAULT, &label)
+      @items = items.to_a
+      @label = label || :to_s.to_proc
+      @prompt = DisplayText.new(prompt)
+      @placeholder = DisplayText.new(placeholder)
+      @theme = theme
+      @graphemes = []
+      @list = ScrollList.new(0)
+      refilter
+    end
+
+    def query = @graphemes.join
+
+    # The original item under the cursor, or nil when nothing matches.
+    def selection = @filtered[@list.cursor]&.first
+
+    def handle(key)
+      case key
+      when "\r"
+        selection
+      when :escape, KeyCode::CTRL_C
+        :cancel
+      when :up, KeyCode::CTRL_P
+        move(-1)
+      when :down, KeyCode::CTRL_N
+        move(1)
+      when :home
+        move_to(0)
+      when :end
+        move_to(@list.last)
+      when KeyCode::BACKSPACE, :backspace
+        edit { @graphemes.pop }
+      when String
+        edit { @graphemes.concat(key.grapheme_clusters) if TextSanitizer.printable?(key) }
+      end
+    end
+
+    # Wheel scrolls the highlight; a click on a row picks it (returns the item),
+    # otherwise nil to stay open.
+    def handle_mouse(event)
+      case event.action
+      when :wheel
+        move(event.button == :wheel_up ? -WHEEL : WHEEL)
+      when :press
+        click(event)
+      end
+    end
+
+    def draw(canvas, size)
+      rows = visible_rows(size)
+      inner = [MIN_INNER, *@filtered.map { |_item, label, _pos| label.width }].max
+      rect, col = panel(canvas, inner: inner, body_rows: rows + 2)
+
+      draw_query(canvas, rect.row + 1, col, inner)
+      draw_items(canvas, rect.row + 3, col, inner, rows)
+      canvas
+    end
+
+    private
+
+    def move(delta)
+      @list.move(delta)
+      nil
+    end
+
+    def move_to(index)
+      @list.go_to(index)
+      nil
+    end
+
+    # Apply a query edit, then refilter. Returns nil so the modal stays open.
+    def edit
+      yield
+      refilter
+      nil
+    end
+
+    # Recompute the visible list: fuzzy-ranked (best first, with matched positions
+    # for highlighting) while querying, otherwise the items in their given order.
+    # Each entry is [item, DisplayText(label), positions]; the cursor resets so a
+    # narrowed query always lands on the top match.
+    def refilter
+      @filtered =
+        if @graphemes.empty?
+          @items.map { |item| [item, label_text(item), []] }
+        else
+          Fuzzy.new(query).rank(@items) { |item| @label.call(item).to_s }
+               .map { |item, found| [item, label_text(item), found.positions] }
+        end
+      @list.count = @filtered.size
+      @list.go_to(0)
+    end
+
+    def label_text(item) = DisplayText.new(@label.call(item).to_s)
+
+    def visible_rows(size)
+      room = [size.rows - 4, 1].max
+      [[@filtered.size, 1].max, MAX_ROWS, room].min
+    end
+
+    def draw_query(canvas, row, col, inner)
+      canvas.text(row, col, @prompt, theme.accent)
+      text_col = col + @prompt.width
+      budget = inner - @prompt.width
+      if @graphemes.empty?
+        canvas.text(row, text_col, @placeholder.truncate(budget), theme.muted)
+      else
+        canvas.text(row, text_col, DisplayText.new(query).truncate(budget), theme.text)
+      end
+    end
+
+    def draw_items(canvas, row, col, inner, rows)
+      @items_rect = Rect.new(row: row, col: col, rows: rows, cols: inner)
+      if @filtered.empty?
+        canvas.text(row, col, DisplayText.new("No matches").truncate(inner), theme.muted)
+        return
+      end
+
+      List.new(@list).draw(canvas, @items_rect, highlight: theme.selection) do |index, focused|
+        _item, label, positions = @filtered[index]
+        base = focused ? theme.selection : theme.text
+        # Keep the focused row a single style; highlight matches with accent only
+        # on unfocused rows so the selection bar stays legible.
+        match = focused ? base : theme.accent
+        styled_line(label.to_s, positions, base, match)
+      end
+    end
+
+    # The label as a Line with matched graphemes in `match` and the rest in `base`;
+    # runs of the same style coalesce into one Span (grapheme indices line up with
+    # Fuzzy#positions).
+    def styled_line(label, positions, base, match)
+      return Line[Span[label, base]] if positions.empty?
+
+      spans = []
+      run = +""
+      run_style = nil
+      label.grapheme_clusters.each_with_index do |grapheme, i|
+        style = positions.include?(i) ? match : base
+        if style != run_style && !run.empty?
+          spans << Span[run, run_style]
+          run = +""
+        end
+        run_style = style
+        run << grapheme
+      end
+      spans << Span[run, run_style] unless run.empty?
+      Line.new(spans)
+    end
+
+    # The item under a click, picked, or nil if the click missed the list.
+    def click(event)
+      return nil unless @items_rect
+
+      index = List.new(@list).index_at(@items_rect, event)
+      return nil if index.nil?
+
+      @list.go_to(index)
+      selection
+    end
+  end
+end

data/lib/tui_tui/key_code.rb

@@ -4,6 +4,9 @@ module TuiTui
   module KeyCode
     ESCAPE = "\e"
     CTRL_C = "\u0003"
+    CTRL_L = "\u000C"
+    CTRL_N = "\u000E"
+    CTRL_P = "\u0010"
     BACKSPACE = "\u007F"
   end
 end

data/lib/tui_tui/line.rb

@@ -10,6 +10,17 @@ module TuiTui
     # Convenience constructor: Line[Span["a", s1], Span["b", s2]].
     def self.[](*spans) = new(spans)
 
+    # Coerce loose content into a Line: a Line passes through, a Span or an Array
+    # of Spans is wrapped, and anything else is one Span (in `style`, when given).
+    def self.coerce(content, style = nil)
+      case content
+      when Line then content
+      when Span then new([content])
+      when Array then new(content)
+      else Line[Span[content.to_s, style]]
+      end
+    end
+
     def initialize(spans = [])
       @spans = spans
     end

data/lib/tui_tui/list.rb

@@ -21,7 +21,7 @@ module TuiTui
         row = body.row + offset
         selected = index == @scroll.cursor
         canvas.fill(Rect.new(row: row, col: body.col, rows: 1, cols: body.cols), highlight) if highlight && selected
-        canvas.line(row, body.col, as_line(yield(index, selected)).truncate(body.cols))
+        canvas.line(row, body.col, Line.coerce(yield(index, selected)).truncate(body.cols))
       end
 
       draw_scrollbar(canvas, gutter, scrollbar) if gutter
@@ -53,7 +53,5 @@ module TuiTui
         thumb_style: theme.scroll_thumb
       )
     end
-
-    def as_line(content) = content.is_a?(Line) ? content : Line.new(Array(content))
   end
 end

data/lib/tui_tui/pager.rb

@@ -2,6 +2,8 @@
 
 require_relative "display_text"
 require_relative "style"
+require_relative "span"
+require_relative "line"
 require_relative "rect"
 require_relative "modal"
 require_relative "key_intent"
@@ -12,13 +14,16 @@ module TuiTui
     MARGIN = 2
     WHEEL = 3
 
+    # Each line may be a plain String, a `Line`, or an array of `Span`s, so a
+    # log/diff/error view can color whole lines or runs within them. Spans
+    # without a style fall back to theme.muted.
     def initialize(title, lines, start: 0, close_keys: [], theme: Theme::DEFAULT)
       @title = title
-      @lines = lines.map { |line| DisplayText.new(line) }
+      @theme = theme
+      @lines = lines.map { |line| normalize_line(line) }
       @top = start
       @page = 1
       @close_keys = close_keys
-      @theme = theme
     end
 
     def handle(key)
@@ -60,7 +65,7 @@ module TuiTui
         line = @lines[@top + offset]
         next if line.nil?
 
-        canvas.text(rect.row + 3 + offset, rect.col + 2, line.truncate(inner), theme.muted)
+        canvas.line(rect.row + 3 + offset, rect.col + 2, line.truncate(inner))
       end
 
       canvas
@@ -68,6 +73,13 @@ module TuiTui
 
     private
 
+    # -> Line. Accepts a String, a Line, or a Span array; spans left unstyled
+    # default to theme.muted so a bare line still reads as muted body text.
+    def normalize_line(line)
+      spans = Line.coerce(line).spans.map { |span| Span[span.text, span.style || theme.muted] }
+      Line.new(spans)
+    end
+
     def paginate(key)
       case key
       when " ", :pgdn

data/lib/tui_tui/prompt.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "display_text"
+require_relative "text_sanitizer"
 require_relative "style"
 require_relative "modal"
 require_relative "key_code"
@@ -38,7 +39,7 @@ module TuiTui
       when :end
         edit { @pos = @graphemes.length }
       when String
-        edit { insert(key) if printable?(key) }
+        edit { insert(key) if TextSanitizer.printable?(key) }
       end
     end
 
@@ -103,9 +104,5 @@ module TuiTui
     def delete_forward
       @graphemes.delete_at(@pos) if @pos < @graphemes.length
     end
-
-    def printable?(string)
-      string.bytes.all? { |byte| byte >= 0x20 && byte != 0x7F }
-    end
   end
 end

data/lib/tui_tui/runtime.rb

@@ -26,6 +26,7 @@ module TuiTui
 
           @app = result
           flush_clipboard(screen)
+          flush_mouse(screen)
           screen.render(view(screen))
         end
       end
@@ -47,6 +48,14 @@ module TuiTui
       screen.copy(text) if text
     end
 
+    # Apps may release/recapture the mouse per frame (e.g. to allow a native
+    # terminal selection while a read-only pane is open).
+    def flush_mouse(screen)
+      return unless @app.respond_to?(:wants_mouse?)
+
+      screen.mouse = @app.wants_mouse?
+    end
+
     def wants_redraw?(event)
       @app.respond_to?(:redraw?) && @app.redraw?(event)
     end

data/lib/tui_tui/screen.rb

@@ -52,6 +52,14 @@ module TuiTui
 
     attr_reader :events, :chrome
 
+    # Toggle mouse reporting mid-session (so an app can release the mouse for a
+    # native terminal selection while a read-only pane is open).
+    def mouse=(enabled)
+      @session.mouse = enabled
+    end
+
+    def mouse = @session.mouse
+
     def start
       @session.start
       # Probe box-drawing support once, after raw mode + alt screen, before the

data/lib/tui_tui/select.rb

@@ -91,11 +91,10 @@ module TuiTui
 
     # The item under a click, picked, or nil if the click missed the list.
     def click(event)
-      rect = @items_rect
-      return nil unless rect && event.col.between?(rect.col, rect.col + rect.cols - 1)
+      return nil unless @items_rect
 
-      index = @list.top + (event.row - rect.row)
-      return nil unless (event.row - rect.row).between?(0, rect.rows - 1) && !@list.empty? && index <= @list.last
+      index = List.new(@list).index_at(@items_rect, event)
+      return nil if index.nil?
 
       @list.go_to(index)
       @list.cursor

data/lib/tui_tui/terminal_session.rb

@@ -16,7 +16,8 @@ module TuiTui
     end
 
     def start
-      @console.raw!
+      # `intr: true` keeps the interrupt/quit/suspend characters live in raw mode, so Ctrl-C raises SIGINT.
+      @console.raw!(intr: true)
       @output.write(Ansi::ALT_ON + Ansi::HIDE + Ansi::CLEAR + (@mouse ? Ansi::MOUSE_ON : ""))
       @output.flush
       @prev_winch = trap("WINCH") { @events.resized! }
@@ -24,6 +25,20 @@ module TuiTui
       at_exit { close }
     end
 
+    attr_reader :mouse
+
+    # Toggle mouse reporting mid-session. Releasing it (false) lets the user
+    # make a native terminal selection (drag to select / copy) over the alternate
+    # screen; re-enabling restores in-app mouse events. No-op if unchanged.
+    def mouse=(enabled)
+      enabled = !!enabled
+      return if @closed || enabled == @mouse
+
+      @output.write(enabled ? Ansi::MOUSE_ON : Ansi::MOUSE_OFF)
+      @output.flush
+      @mouse = enabled
+    end
+
     def close
       # Close is called from ensure, at_exit, and signal traps.
       return if @closed

data/lib/tui_tui/text_sanitizer.rb

@@ -1,13 +1,21 @@
 # frozen_string_literal: true
 
 module TuiTui
-  # Normalizes text before rendering so malformed input bytes are displayed
-  # safely instead of raising encoding errors.
+  # Character-level text hygiene: keeps malformed or control bytes out of the
+  # render/input pipeline so they are displayed safely (or rejected as input)
+  # instead of raising encoding errors or emitting raw control codes.
   module TextSanitizer
     module_function
 
     def sanitize(string)
       string.valid_encoding? ? string : string.scrub("?")
     end
+
+    # Whether `string` is safe to insert as literal text: every byte is a
+    # printable character (no C0 controls and no DEL). Multibyte UTF-8 passes,
+    # since its bytes are all >= 0x80.
+    def printable?(string)
+      string.bytes.all? { |byte| byte >= 0x20 && byte != 0x7F }
+    end
   end
 end

data/lib/tui_tui/text_view.rb

@@ -21,7 +21,7 @@ module TuiTui
         content = lines ? lines[index] : yield(index)
         next if content.nil?
 
-        canvas.line(body.row + offset, body.col, as_line(content, style).truncate(body.cols))
+        canvas.line(body.row + offset, body.col, Line.coerce(content, style).truncate(body.cols))
       end
 
       draw_scrollbar(canvas, gutter, top, total || lines&.length, body.rows, scrollbar) if gutter
@@ -41,16 +41,5 @@ module TuiTui
         thumb_style: theme.scroll_thumb
       )
     end
-
-    def as_line(content, style)
-      case content
-      when Line
-        content
-      when Array
-        Line.new(content)
-      else
-        Line[Span[content.to_s, style]]
-      end
-    end
   end
 end

data/lib/tui_tui/toast.rb

@@ -2,6 +2,7 @@
 
 require_relative "display_text"
 require_relative "style"
+require_relative "clock"
 
 module TuiTui
   # A transient notification overlay.
@@ -22,7 +23,7 @@ module TuiTui
       bottom_right: [:bottom, :right],
       center: [:middle, :center]
     }.freeze
-    MONOTONIC = -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
+    MONOTONIC = -> { Clock.monotonic }
 
     def initialize(message, seconds: DEFAULT_SECONDS, position: DEFAULT_POSITION, clock: MONOTONIC)
       @message = DisplayText.new(message)

data/lib/tui_tui/version.rb

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

data/lib/tui_tui.rb

@@ -2,6 +2,7 @@
 
 require_relative "tui_tui/version"
 
+require_relative "tui_tui/clock"
 require_relative "tui_tui/width"
 require_relative "tui_tui/text_sanitizer"
 require_relative "tui_tui/display_text"
@@ -38,6 +39,7 @@ 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/command_palette"
 require_relative "tui_tui/help"
 require_relative "tui_tui/prompt"
 require_relative "tui_tui/pager"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tui_tui
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - takahashim
@@ -39,7 +39,9 @@ files:
 - lib/tui_tui/canvas.rb
 - lib/tui_tui/canvas_compositor.rb
 - lib/tui_tui/cell.rb
+- lib/tui_tui/clock.rb
 - lib/tui_tui/color_depth.rb
+- lib/tui_tui/command_palette.rb
 - lib/tui_tui/confirm.rb
 - lib/tui_tui/display_text.rb
 - lib/tui_tui/event.rb
@@ -98,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A tiny, dependency-free TUI runtime for modern terminals.
 test_files: []