ratatat 1.0.0

data/lib/ratatat/widgets/spinner.rb

@@ -0,0 +1,93 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Ratatat
+  # Animated loading spinner widget
+  class Spinner < Widget
+    extend T::Sig
+
+    STYLES = T.let({
+      dots: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
+      line: ["-", "\\", "|", "/"],
+      blocks: ["▏", "▎", "▍", "▌", "▋", "▊", "▉", "█"],
+      arrows: ["←", "↖", "↑", "↗", "→", "↘", "↓", "↙"],
+      bounce: ["⠁", "⠂", "⠄", "⠂"],
+      pulse: ["◐", "◓", "◑", "◒"]
+    }.freeze, T::Hash[Symbol, T::Array[String]])
+
+    DEFAULT_FRAMES = T.let(STYLES[:dots] || [], T::Array[String])
+
+    sig { returns(T::Array[String]) }
+    attr_reader :frames
+
+    sig { returns(Float) }
+    attr_reader :speed
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :text
+
+    reactive :frame_index, default: 0, repaint: true
+
+    sig { params(frames: T.nilable(T::Array[String]), style: T.nilable(Symbol), speed: Float, text: T.nilable(String), id: T.nilable(String), classes: T::Array[String]).void }
+    def initialize(frames: nil, style: nil, speed: 0.1, text: nil, id: nil, classes: [])
+      super(id: id, classes: classes)
+      @frames = T.let(
+        frames || (style ? (STYLES[style] || DEFAULT_FRAMES) : DEFAULT_FRAMES),
+        T::Array[String]
+      )
+      @speed = speed
+      @text = text
+      @frame_index = 0
+      @spinning = T.let(false, T::Boolean)
+      @timer_id = T.let(nil, T.nilable(Integer))
+    end
+
+    sig { returns(String) }
+    def current_frame
+      @frames[@frame_index] || @frames.first || " "
+    end
+
+    sig { void }
+    def advance
+      @frame_index = (@frame_index + 1) % @frames.length
+    end
+
+    sig { returns(T::Boolean) }
+    def spinning?
+      @spinning
+    end
+
+    sig { void }
+    def start
+      return if @spinning
+
+      @spinning = true
+      app_instance = app
+      return unless app_instance
+
+      @timer_id = app_instance.set_interval(@speed) { advance }
+    end
+
+    sig { void }
+    def stop
+      return unless @spinning
+
+      @spinning = false
+      app_instance = app
+      return unless app_instance || @timer_id.nil?
+
+      app_instance&.cancel_timer(T.must(@timer_id)) if @timer_id
+      @timer_id = nil
+    end
+
+    sig { params(buffer: Buffer, x: Integer, y: Integer, width: Integer, height: Integer).void }
+    def render(buffer, x:, y:, width:, height:)
+      output = if @text
+                 "#{current_frame} #{@text}"
+               else
+                 current_frame
+               end
+      buffer.put_string(x, y, output[0, width] || "")
+    end
+  end
+end

data/lib/ratatat/widgets/static.rb

@@ -0,0 +1,23 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Ratatat
+  # Simple text display widget
+  class Static < Widget
+    extend T::Sig
+
+    reactive :text, default: "", repaint: true
+
+    sig { params(text: String, id: T.nilable(String), classes: T::Array[String], styles: T.nilable(T::Hash[Symbol, T.untyped])).void }
+    def initialize(text = "", id: nil, classes: [], styles: nil)
+      super(id: id, classes: classes, styles: styles)
+      @text = text
+    end
+
+    sig { params(buffer: Buffer, x: Integer, y: Integer, width: Integer, height: Integer).void }
+    def render(buffer, x:, y:, width:, height:)
+      display_text = text[0, width] || ""
+      buffer.put_string(x, y, display_text)
+    end
+  end
+end

data/lib/ratatat/widgets/tabbed_content.rb

@@ -0,0 +1,114 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Ratatat
+  # Tabbed content container with switchable panes
+  class TabbedContent < Widget
+    extend T::Sig
+
+    CAN_FOCUS = true
+
+    class TabChanged < Message
+      extend T::Sig
+
+      sig { returns(Integer) }
+      attr_reader :index
+
+      sig { returns(String) }
+      attr_reader :label
+
+      sig { params(sender: Widget, index: Integer, label: String).void }
+      def initialize(sender:, index:, label:)
+        super(sender: sender)
+        @index = index
+        @label = label
+      end
+    end
+
+    sig { returns(T::Array[String]) }
+    attr_reader :labels
+
+    reactive :active_tab, default: 0, repaint: true
+
+    sig { params(id: T.nilable(String), classes: T::Array[String]).void }
+    def initialize(id: nil, classes: [])
+      super(id: id, classes: classes)
+      @labels = T.let([], T::Array[String])
+      @panes = T.let([], T::Array[Widget])
+      @active_tab = 0
+    end
+
+    sig { params(label: String, content: Widget).void }
+    def add_tab(label, content)
+      @labels << label
+      @panes << content
+      mount(content)
+    end
+
+    sig { returns(Integer) }
+    def tab_count
+      @labels.length
+    end
+
+    sig { returns(T.nilable(String)) }
+    def active_label
+      @labels[@active_tab]
+    end
+
+    sig { returns(T.nilable(Widget)) }
+    def active_pane
+      @panes[@active_tab]
+    end
+
+    sig { params(message: Key).void }
+    def on_key(message)
+      case message.key
+      when "left", "shift+tab"
+        switch_tab(-1)
+        message.stop
+      when "right", "tab"
+        switch_tab(1)
+        message.stop
+      end
+    end
+
+    sig { params(buffer: Buffer, x: Integer, y: Integer, width: Integer, height: Integer).void }
+    def render(buffer, x:, y:, width:, height:)
+      return if height < 2
+
+      # Render tab bar
+      render_tab_bar(buffer, x, y, width)
+
+      # Render active pane content
+      pane = active_pane
+      pane&.render(buffer, x: x, y: y + 1, width: width, height: height - 1) if pane.respond_to?(:render)
+    end
+
+    private
+
+    sig { params(delta: Integer).void }
+    def switch_tab(delta)
+      return if @labels.empty?
+
+      old_tab = @active_tab
+      @active_tab = (@active_tab + delta) % @labels.length
+      return if old_tab == @active_tab
+
+      parent&.dispatch(TabChanged.new(sender: self, index: @active_tab, label: active_label || ""))
+    end
+
+    sig { params(buffer: Buffer, x: Integer, y: Integer, width: Integer).void }
+    def render_tab_bar(buffer, x, y, width)
+      pos = x
+      @labels.each_with_index do |label, i|
+        break if pos >= x + width
+
+        prefix = i == @active_tab ? "[" : " "
+        suffix = i == @active_tab ? "]" : " "
+        text = "#{prefix}#{label}#{suffix}"
+        buffer.put_string(pos, y, text[0, width - (pos - x)])
+        pos += text.length + 1
+      end
+    end
+  end
+end

data/lib/ratatat/widgets/text_area.rb

@@ -0,0 +1,183 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Ratatat
+  # Multi-line text input widget
+  class TextArea < Widget
+    extend T::Sig
+
+    CAN_FOCUS = true
+
+    class Changed < Message
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :value
+
+      sig { params(sender: Widget, value: String).void }
+      def initialize(sender:, value:)
+        super(sender: sender)
+        @value = value
+      end
+    end
+
+    reactive :value, default: "", repaint: true
+
+    sig { returns(Integer) }
+    attr_reader :cursor_row, :cursor_col
+
+    sig { params(value: String, id: T.nilable(String), classes: T::Array[String]).void }
+    def initialize(value: "", id: nil, classes: [])
+      super(id: id, classes: classes)
+      @value = value
+      @cursor_row = T.let(0, Integer)
+      @cursor_col = T.let(value.split("\n").first&.length || 0, Integer)
+    end
+
+    sig { returns(T::Array[String]) }
+    def lines
+      @value.split("\n", -1)
+    end
+
+    sig { params(message: Key).void }
+    def on_key(message)
+      case message.key
+      when "up"
+        move_cursor_vertical(-1)
+        message.stop
+      when "down"
+        move_cursor_vertical(1)
+        message.stop
+      when "left"
+        move_cursor_horizontal(-1)
+        message.stop
+      when "right"
+        move_cursor_horizontal(1)
+        message.stop
+      when "home"
+        @cursor_col = 0
+        message.stop
+      when "end"
+        @cursor_col = current_line.length
+        message.stop
+      when "enter"
+        insert_newline
+        message.stop
+      when "backspace"
+        delete_backward
+        message.stop
+      when "delete"
+        delete_forward
+        message.stop
+      else
+        insert_char(message.key) if message.key.length == 1
+        message.stop
+      end
+    end
+
+    sig { params(buffer: Buffer, x: Integer, y: Integer, width: Integer, height: Integer).void }
+    def render(buffer, x:, y:, width:, height:)
+      lines.each_with_index do |line, i|
+        break if i >= height
+
+        buffer.put_string(x, y + i, line[0, width] || "")
+      end
+    end
+
+    private
+
+    sig { returns(String) }
+    def current_line
+      lines[@cursor_row] || ""
+    end
+
+    sig { params(delta: Integer).void }
+    def move_cursor_vertical(delta)
+      new_row = (@cursor_row + delta).clamp(0, [lines.length - 1, 0].max)
+      @cursor_row = new_row
+      @cursor_col = [@cursor_col, current_line.length].min
+    end
+
+    sig { params(delta: Integer).void }
+    def move_cursor_horizontal(delta)
+      @cursor_col = (@cursor_col + delta).clamp(0, current_line.length)
+    end
+
+    sig { params(char: String).void }
+    def insert_char(char)
+      current_lines = lines
+      line = current_lines[@cursor_row] || ""
+      new_line = line.dup
+      new_line.insert(@cursor_col, char)
+      current_lines[@cursor_row] = new_line
+      @cursor_col += 1
+      self.value = current_lines.join("\n")
+      emit_changed
+    end
+
+    sig { void }
+    def insert_newline
+      current_lines = lines
+      line = current_lines[@cursor_row] || ""
+      before = line[0, @cursor_col] || ""
+      after = line[@cursor_col..] || ""
+      current_lines[@cursor_row] = before
+      current_lines.insert(@cursor_row + 1, after)
+      @cursor_row += 1
+      @cursor_col = 0
+      self.value = current_lines.join("\n")
+      emit_changed
+    end
+
+    sig { void }
+    def delete_backward
+      if @cursor_col > 0
+        current_lines = lines
+        line = current_lines[@cursor_row] || ""
+        new_line = line.dup
+        new_line.slice!(@cursor_col - 1)
+        current_lines[@cursor_row] = new_line
+        @cursor_col -= 1
+        self.value = current_lines.join("\n")
+        emit_changed
+      elsif @cursor_row > 0
+        # Merge with previous line
+        current_lines = lines
+        prev_line = current_lines[@cursor_row - 1] || ""
+        curr_line = current_lines[@cursor_row] || ""
+        @cursor_col = prev_line.length
+        current_lines[@cursor_row - 1] = prev_line + curr_line
+        current_lines.delete_at(@cursor_row)
+        @cursor_row -= 1
+        self.value = current_lines.join("\n")
+        emit_changed
+      end
+    end
+
+    sig { void }
+    def delete_forward
+      current_lines = lines
+      line = current_lines[@cursor_row] || ""
+
+      if @cursor_col < line.length
+        new_line = line.dup
+        new_line.slice!(@cursor_col)
+        current_lines[@cursor_row] = new_line
+        self.value = current_lines.join("\n")
+        emit_changed
+      elsif @cursor_row < current_lines.length - 1
+        # Merge with next line
+        next_line = current_lines[@cursor_row + 1] || ""
+        current_lines[@cursor_row] = line + next_line
+        current_lines.delete_at(@cursor_row + 1)
+        self.value = current_lines.join("\n")
+        emit_changed
+      end
+    end
+
+    sig { void }
+    def emit_changed
+      parent&.dispatch(Changed.new(sender: self, value: @value))
+    end
+  end
+end

data/lib/ratatat/widgets/text_input.rb

@@ -0,0 +1,143 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Ratatat
+  # Single-line text input widget
+  class TextInput < Widget
+    extend T::Sig
+
+    CAN_FOCUS = true
+
+    # Emitted when value changes
+    class Changed < Message
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :value
+
+      sig { params(sender: Widget, value: String).void }
+      def initialize(sender:, value:)
+        super(sender: sender)
+        @value = value
+      end
+    end
+
+    # Emitted when Enter is pressed
+    class Submitted < Message
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :value
+
+      sig { params(sender: Widget, value: String).void }
+      def initialize(sender:, value:)
+        super(sender: sender)
+        @value = value
+      end
+    end
+
+    reactive :value, default: "", repaint: true
+    reactive :placeholder, default: "", repaint: true
+
+    sig { returns(Integer) }
+    attr_reader :cursor
+
+    sig do
+      params(
+        value: String,
+        placeholder: String,
+        id: T.nilable(String),
+        classes: T::Array[String]
+      ).void
+    end
+    def initialize(value: "", placeholder: "", id: nil, classes: [])
+      super(id: id, classes: classes)
+      @value = value
+      @placeholder = placeholder
+      @cursor = T.let(value.length, Integer)
+    end
+
+    sig { params(message: Key).void }
+    def on_key(message)
+      case message.key
+      when "backspace"
+        delete_backward
+        message.stop
+      when "delete"
+        delete_forward
+        message.stop
+      when "left"
+        move_cursor(-1)
+        message.stop
+      when "right"
+        move_cursor(1)
+        message.stop
+      when "home"
+        @cursor = 0
+        message.stop
+      when "end"
+        @cursor = value.length
+        message.stop
+      when "enter"
+        submit
+        message.stop
+      else
+        insert_char(message.key) if message.key.length == 1
+        message.stop
+      end
+    end
+
+    sig { params(buffer: Buffer, x: Integer, y: Integer, width: Integer, height: Integer).void }
+    def render(buffer, x:, y:, width:, height:)
+      display = value.empty? ? placeholder : value
+      buffer.put_string(x, y, display[0, width] || "")
+    end
+
+    private
+
+    sig { params(char: String).void }
+    def insert_char(char)
+      new_value = value.dup
+      new_value.insert(@cursor, char)
+      @cursor += 1
+      self.value = new_value
+      emit_changed
+    end
+
+    sig { void }
+    def delete_backward
+      return if @cursor == 0
+
+      new_value = value.dup
+      new_value.slice!(@cursor - 1)
+      @cursor -= 1
+      self.value = new_value
+      emit_changed
+    end
+
+    sig { void }
+    def delete_forward
+      return if @cursor >= value.length
+
+      new_value = value.dup
+      new_value.slice!(@cursor)
+      self.value = new_value
+      emit_changed
+    end
+
+    sig { params(delta: Integer).void }
+    def move_cursor(delta)
+      @cursor = (@cursor + delta).clamp(0, value.length)
+    end
+
+    sig { void }
+    def emit_changed
+      parent&.dispatch(Changed.new(sender: self, value: value))
+    end
+
+    sig { void }
+    def submit
+      parent&.dispatch(Submitted.new(sender: self, value: value))
+    end
+  end
+end

data/lib/ratatat/widgets/toast.rb

@@ -0,0 +1,55 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Ratatat
+  # Toast notification widget
+  class Toast < Widget
+    extend T::Sig
+
+    ICONS = T.let({
+      info: "ℹ",
+      success: "✓",
+      warning: "⚠",
+      error: "✗"
+    }.freeze, T::Hash[Symbol, String])
+
+    sig { returns(String) }
+    attr_reader :message
+
+    sig { returns(Symbol) }
+    attr_reader :severity
+
+    sig { returns(Float) }
+    attr_reader :duration
+
+    reactive :visible, default: true, repaint: true
+
+    sig { params(message: String, severity: Symbol, duration: Float, id: T.nilable(String), classes: T::Array[String]).void }
+    def initialize(message:, severity: :info, duration: 5.0, id: nil, classes: [])
+      super(id: id, classes: classes)
+      @message = message
+      @severity = severity
+      @duration = duration
+      @visible = true
+    end
+
+    sig { void }
+    def show
+      @visible = true
+    end
+
+    sig { void }
+    def hide
+      @visible = false
+    end
+
+    sig { params(buffer: Buffer, x: Integer, y: Integer, width: Integer, height: Integer).void }
+    def render(buffer, x:, y:, width:, height:)
+      return unless @visible
+
+      icon = ICONS[@severity] || ICONS[:info]
+      text = "#{icon} #{@message}"
+      buffer.put_string(x, y, text[0, width] || "")
+    end
+  end
+end

data/lib/ratatat/widgets/tooltip.rb

@@ -0,0 +1,66 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Ratatat
+  # Floating tooltip widget
+  class Tooltip < Widget
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_reader :text
+
+    sig { returns(Integer) }
+    attr_reader :anchor_x, :anchor_y
+
+    reactive :visible, default: false, repaint: true
+
+    sig { params(text: String, anchor_x: Integer, anchor_y: Integer, id: T.nilable(String), classes: T::Array[String]).void }
+    def initialize(text:, anchor_x: 0, anchor_y: 0, id: nil, classes: [])
+      super(id: id, classes: classes)
+      @text = text
+      @anchor_x = anchor_x
+      @anchor_y = anchor_y
+      @visible = false
+    end
+
+    sig { void }
+    def show
+      @visible = true
+    end
+
+    sig { void }
+    def hide
+      @visible = false
+    end
+
+    sig { params(new_x: Integer, new_y: Integer).void }
+    def move_to(new_x, new_y)
+      @anchor_x = new_x
+      @anchor_y = new_y
+      refresh
+    end
+
+    sig { params(buffer: Buffer, x: Integer, y: Integer, width: Integer, height: Integer).void }
+    def render(buffer, x:, y:, width:, height:)
+      return unless @visible
+      return if height < 3
+
+      text_width = @text.length
+      box_width = [text_width + 4, width].min
+      box_height = 3
+
+      # Draw top border
+      top = "┌#{"─" * (box_width - 2)}┐"
+      buffer.put_string(x, y, top[0, width])
+
+      # Draw middle with text
+      padding = (box_width - 2 - text_width) / 2
+      middle = "│#{" " * padding}#{@text}#{" " * (box_width - 3 - padding - text_width)}│"
+      buffer.put_string(x, y + 1, middle[0, width])
+
+      # Draw bottom border
+      bottom = "└#{"─" * (box_width - 2)}┘"
+      buffer.put_string(x, y + 2, bottom[0, width])
+    end
+  end
+end