chamomile-petals 0.1.0

data/lib/petals/progress.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module Petals
+  ProgressFrameMsg = Data.define(:id, :tag)
+
+  # Animated progress bar with spring-based animation and optional gradient.
+  class Progress
+    DEFAULT_WIDTH = 40
+    FULL_CHAR  = "\u2588"
+    EMPTY_CHAR = "\u2591"
+
+    # Spring constants
+    FREQUENCY = 14.0
+    DAMPING   = 2.2
+    EPSILON   = 0.001
+    FPS       = 60
+
+    @next_id = 0
+    @id_mutex = Mutex.new
+    @id_pid = Process.pid
+
+    def self.next_id
+      @id_mutex.synchronize do
+        if Process.pid != @id_pid
+          @id_pid = Process.pid
+          @next_id = 0
+          @id_mutex = Mutex.new
+        end
+        @next_id += 1
+        "#{@id_pid}-pg-#{@next_id}"
+      end
+    end
+
+    attr_reader :id, :percent, :frequency, :damping
+    attr_accessor :width, :full_char, :empty_char, :show_percentage,
+                  :percentage_format, :full_color, :empty_color, :gradient
+
+    def initialize(width: DEFAULT_WIDTH, show_percentage: true, percentage_format: " %3.0f%%",
+                   full_char: FULL_CHAR, empty_char: EMPTY_CHAR,
+                   full_color: nil, empty_color: nil, gradient: nil,
+                   frequency: FREQUENCY, damping: DAMPING)
+      @id = self.class.next_id
+      @width = width
+      @full_char = full_char
+      @empty_char = empty_char
+      @show_percentage = show_percentage
+      @percentage_format = percentage_format
+      @full_color = full_color
+      @empty_color = empty_color
+      @gradient = gradient
+      @frequency = frequency.to_f
+      @damping = damping.to_f
+      @percent = 0.0
+      @target = 0.0
+      @velocity = 0.0
+      @tag = 0
+      @animating = false
+    end
+
+    def set_percent(p)
+      @target = p.to_f.clamp(0.0, 1.0)
+      start_animation
+    end
+
+    def incr_percent(v)
+      set_percent(@target + v)
+    end
+
+    def decr_percent(v)
+      set_percent(@target - v)
+    end
+
+    def set_spring_options(frequency, damping)
+      @frequency = frequency.to_f
+      @damping = damping.to_f
+    end
+
+    def animating?
+      @animating
+    end
+
+    def update(msg)
+      return unless msg.is_a?(ProgressFrameMsg)
+      return unless msg.id == @id && msg.tag == @tag
+
+      dt = 1.0 / FPS
+      force = (@target - @percent) * @frequency
+      @velocity = (@velocity + (force * dt)) * (1.0 / (1.0 + (@damping * dt)))
+      @percent += @velocity * dt
+      @percent = @percent.clamp(0.0, 1.0)
+
+      if (@percent - @target).abs < EPSILON && @velocity.abs < EPSILON
+        @percent = @target
+        @velocity = 0.0
+        @animating = false
+        @tag += 1
+        nil
+      else
+        @tag += 1
+        frame_cmd
+      end
+    end
+
+    def view
+      render_bar(@percent)
+    end
+
+    def view_as(percent)
+      render_bar(percent.to_f.clamp(0.0, 1.0))
+    end
+
+    private
+
+    def start_animation
+      @tag += 1
+      if @animating
+        @velocity = 0.0
+        return frame_cmd
+      end
+
+      @animating = true
+      frame_cmd
+    end
+
+    def frame_cmd
+      captured_id = @id
+      captured_tag = @tag
+      -> {
+        sleep(1.0 / FPS)
+        ProgressFrameMsg.new(id: captured_id, tag: captured_tag)
+      }
+    end
+
+    def render_bar(pct)
+      pct_text = @show_percentage ? format(@percentage_format, pct * 100) : ""
+      bar_width = [@width - pct_text.length, 0].max
+
+      filled_width = (pct * bar_width).round
+      empty_width = bar_width - filled_width
+
+      bar = if @gradient && @gradient.length >= 2
+              render_gradient_bar(pct, filled_width, empty_width)
+            elsif @full_color || @empty_color
+              render_colored_bar(filled_width, empty_width)
+            else
+              (@full_char * filled_width) + (@empty_char * empty_width)
+            end
+
+      bar + pct_text
+    end
+
+    def render_colored_bar(filled_width, empty_width)
+      result = ""
+      if @full_color && filled_width.positive?
+        r, g, b = @full_color
+        result += "\e[38;2;#{r};#{g};#{b}m#{@full_char * filled_width}\e[0m"
+      else
+        result += @full_char * filled_width
+      end
+      if @empty_color && empty_width.positive?
+        r, g, b = @empty_color
+        result += "\e[38;2;#{r};#{g};#{b}m#{@empty_char * empty_width}\e[0m"
+      else
+        result += @empty_char * empty_width
+      end
+      result
+    end
+
+    def render_gradient_bar(_pct, filled_width, empty_width)
+      return @empty_char * @width if filled_width.zero?
+
+      chars = filled_width.times.map do |i|
+        t = filled_width > 1 ? i.to_f / (filled_width - 1) : 0.0
+        r, g, b = lerp_color(t)
+        "\e[38;2;#{r};#{g};#{b}m#{@full_char}\e[0m"
+      end
+      chars.join + (@empty_char * empty_width)
+    end
+
+    def lerp_color(t)
+      colors = @gradient
+      return colors[0] if t <= 0.0
+      return colors[-1] if t >= 1.0
+
+      scaled = t * (colors.length - 1)
+      idx = scaled.floor
+      idx = [idx, colors.length - 2].min
+      frac = scaled - idx
+
+      c1 = colors[idx]
+      c2 = colors[idx + 1]
+      [
+        (c1[0] + ((c2[0] - c1[0]) * frac)).round,
+        (c1[1] + ((c2[1] - c1[1]) * frac)).round,
+        (c1[2] + ((c2[2] - c1[2]) * frac)).round,
+      ]
+    end
+  end
+end

data/lib/petals/render_cache.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Petals
+  # Mixin for render result caching keyed on content hash.
+  # Include in components whose render output depends only on their data and dimensions.
+  module RenderCache
+    def cached_render(width:, height:, cache_key:)
+      key = [width, height, cache_key]
+      return @render_cache if @render_cache_key == key
+
+      @render_cache_key = key
+      @render_cache = yield
+    end
+  end
+end

data/lib/petals/spinner/types.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Petals
+  SpinnerType = Data.define(:frames, :fps)
+
+  module Spinners
+    LINE      = SpinnerType.new(frames: %w[| / - \\], fps: 10)
+    DOT       = SpinnerType.new(frames: %w[⣾ ⣽ ⣻ ⢿ ⡿ ⣟ ⣯ ⣷], fps: 10)
+    MINI_DOT  = SpinnerType.new(frames: %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏], fps: 12)
+    JUMP      = SpinnerType.new(frames: %w[⢄ ⢂ ⢁ ⡁ ⡈ ⡐ ⡠], fps: 10)
+    PULSE     = SpinnerType.new(frames: %w[█ ▓ ▒ ░], fps: 8)
+    POINTS    = SpinnerType.new(frames: ["∙∙∙", "●∙∙", "∙●∙", "∙∙●"], fps: 7)
+    GLOBE     = SpinnerType.new(frames: %w[🌍 🌎 🌏], fps: 4)
+    MOON      = SpinnerType.new(frames: %w[🌑 🌒 🌓 🌔 🌕 🌖 🌗 🌘], fps: 8)
+    MONKEY    = SpinnerType.new(frames: %w[🙈 🙉 🙊], fps: 3)
+    METER     = SpinnerType.new(frames: ["▱▱▱", "▰▱▱", "▰▰▱", "▰▰▰", "▰▰▱", "▰▱▱", "▱▱▱"], fps: 7)
+    HAMBURGER = SpinnerType.new(frames: %w[☱ ☲ ☴ ☲], fps: 3)
+    ELLIPSIS  = SpinnerType.new(frames: ["", ".", "..", "..."], fps: 3)
+  end
+end

data/lib/petals/spinner.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Petals
+  SpinnerTickMsg = Data.define(:id, :tag, :time)
+
+  # Animated spinner with configurable frame types and tick-based updates.
+  class Spinner
+    @next_id = 0
+    @id_mutex = Mutex.new
+    @id_pid = Process.pid
+
+    def self.next_id
+      @id_mutex.synchronize do
+        if Process.pid != @id_pid
+          @id_pid = Process.pid
+          @next_id = 0
+          @id_mutex = Mutex.new
+        end
+        @next_id += 1
+        "#{@id_pid}-#{@next_id}"
+      end
+    end
+
+    attr_reader :id, :spinner_type
+
+    def initialize(type: Spinners::LINE)
+      @id = self.class.next_id
+      @spinner_type = type
+      @frame = 0
+      @tag = 0
+    end
+
+    # Returns a command that sleeps for the frame interval then produces a SpinnerTickMsg.
+    def tick_cmd
+      captured_id = @id
+      captured_tag = @tag
+      fps = @spinner_type.fps
+      -> {
+        sleep(1.0 / fps)
+        SpinnerTickMsg.new(id: captured_id, tag: captured_tag, time: Time.now)
+      }
+    end
+
+    # Advance frame if msg is a matching SpinnerTickMsg; return cmd or nil.
+    def update(msg)
+      return unless msg.is_a?(SpinnerTickMsg)
+      return unless msg.id == @id && msg.tag == @tag
+
+      @frame = (@frame + 1) % @spinner_type.frames.size
+      @tag += 1
+      tick_cmd
+    end
+
+    # Current frame string.
+    def view
+      @spinner_type.frames[@frame]
+    end
+
+    # Reset to first frame, invalidate in-flight ticks.
+    def reset
+      @frame = 0
+      @tag += 1
+      self
+    end
+
+    # Change spinner type, reset frame, invalidate in-flight ticks.
+    def spinner_type=(type)
+      @spinner_type = type
+      @frame = 0
+      @tag += 1
+    end
+  end
+end

data/lib/petals/stopwatch.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Petals
+  StopwatchTickMsg = Data.define(:id, :tag, :time)
+
+  # Count-up stopwatch with start/stop/reset and tick-based updates.
+  class Stopwatch
+    @next_id = 0
+    @id_mutex = Mutex.new
+    @id_pid = Process.pid
+
+    def self.next_id
+      @id_mutex.synchronize do
+        if Process.pid != @id_pid
+          @id_pid = Process.pid
+          @next_id = 0
+          @id_mutex = Mutex.new
+        end
+        @next_id += 1
+        "#{@id_pid}-sw-#{@next_id}"
+      end
+    end
+
+    attr_reader :id, :interval, :elapsed
+
+    def initialize(interval: 1.0)
+      @id = self.class.next_id
+      @interval = interval
+      @elapsed = 0.0
+      @tag = 0
+      @running = false
+    end
+
+    def start_cmd
+      return nil if @running
+
+      @running = true
+      tick_cmd
+    end
+
+    def stop
+      @running = false
+      @tag += 1
+      self
+    end
+
+    def toggle
+      if @running
+        stop
+        nil
+      else
+        start_cmd
+      end
+    end
+
+    def reset
+      @elapsed = 0.0
+      @running = false
+      @tag += 1
+      self
+    end
+
+    def running?
+      @running
+    end
+
+    def update(msg)
+      return unless msg.is_a?(StopwatchTickMsg)
+      return unless msg.id == @id && msg.tag == @tag
+
+      @elapsed += @interval
+      @tag += 1
+      tick_cmd
+    end
+
+    def view
+      total = @elapsed.ceil.to_i
+      hours = total / 3600
+      minutes = (total % 3600) / 60
+      seconds = total % 60
+
+      if hours.positive?
+        format("%d:%02d:%02d", hours, minutes, seconds)
+      else
+        format("%02d:%02d", minutes, seconds)
+      end
+    end
+
+    private
+
+    def tick_cmd
+      captured_id = @id
+      captured_tag = @tag
+      interval = @interval
+      -> {
+        sleep(interval)
+        StopwatchTickMsg.new(id: captured_id, tag: captured_tag, time: Time.now)
+      }
+    end
+  end
+end

data/lib/petals/table/key_map.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Petals
+  class Table
+    DEFAULT_KEY_MAP = KeyBinding.normalize({
+                                             up: [[:up, []], ["k", []]],
+                                             down: [[:down, []], ["j", []]],
+                                             page_up: [[:page_up, []]],
+                                             page_down: [[:page_down, []]],
+                                             goto_top: [["g", []]],
+                                             goto_bottom: [["G", [:shift]]],
+                                           })
+  end
+end

data/lib/petals/table.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module Petals
+  # Tabular data display with selection, scrolling, and focus gating.
+  class Table
+    Column = Data.define(:title, :width)
+
+    attr_accessor :columns, :key_map, :height
+    attr_reader :cursor, :rows
+
+    def initialize(columns: [], rows: [], height: 10, key_map: DEFAULT_KEY_MAP)
+      @columns = columns
+      @rows = rows
+      @height = height
+      @key_map = key_map
+      @cursor = 0
+      @offset = 0
+      @focused = false
+    end
+
+    def rows=(rows)
+      @rows = rows
+      @cursor = @cursor.clamp(0, [row_count - 1, 0].max)
+      clamp_offset
+    end
+
+    def selected_row
+      return nil if @rows.empty?
+
+      @rows[@cursor]
+    end
+
+    def move_up(n = 1)
+      @cursor = (@cursor - n).clamp(0, [row_count - 1, 0].max)
+      clamp_offset
+    end
+
+    def move_down(n = 1)
+      @cursor = (@cursor + n).clamp(0, [row_count - 1, 0].max)
+      clamp_offset
+    end
+
+    def goto_top
+      @cursor = 0
+      clamp_offset
+    end
+
+    def goto_bottom
+      @cursor = [row_count - 1, 0].max
+      clamp_offset
+    end
+
+    def cursor=(n)
+      @cursor = n.clamp(0, [row_count - 1, 0].max)
+      clamp_offset
+    end
+
+    def focus
+      @focused = true
+      self
+    end
+
+    def blur
+      @focused = false
+      self
+    end
+
+    def focused?
+      @focused
+    end
+
+    def update(msg)
+      return unless @focused
+
+      case msg
+      when Chamomile::KeyMsg
+        handle_key(msg)
+      end
+
+      nil
+    end
+
+    def view
+      header = render_header
+      separator = render_separator
+      body = render_body
+
+      [header, separator, body].compact.join("\n")
+    end
+
+    private
+
+    def row_count
+      @rows.length
+    end
+
+    def handle_key(msg)
+      kb = KeyBinding
+      if kb.key_matches?(msg, @key_map, :up)
+        move_up
+      elsif kb.key_matches?(msg, @key_map, :down)
+        move_down
+      elsif kb.key_matches?(msg, @key_map, :page_up)
+        move_up(@height)
+      elsif kb.key_matches?(msg, @key_map, :page_down)
+        move_down(@height)
+      elsif kb.key_matches?(msg, @key_map, :goto_top)
+        goto_top
+      elsif kb.key_matches?(msg, @key_map, :goto_bottom)
+        goto_bottom
+      end
+    end
+
+    def render_header
+      return "" if @columns.empty?
+
+      @columns.map { |col| truncate_pad(col.title, col.width) }.join(" ")
+    end
+
+    def render_separator
+      return "" if @columns.empty?
+
+      @columns.map { |col| "\u2500" * col.width }.join(" ")
+    end
+
+    def render_body
+      return "" if @rows.empty?
+
+      visible = @rows[@offset, @height] || []
+      lines = visible.each_with_index.map do |row, i|
+        idx = @offset + i
+        line = render_row(row)
+        if idx == @cursor
+          "\e[7m#{line}\e[0m"
+        else
+          line
+        end
+      end
+      lines.join("\n")
+    end
+
+    def render_row(row)
+      @columns.each_with_index.map do |col, i|
+        cell = row[i].to_s
+        truncate_pad(cell, col.width)
+      end.join(" ")
+    end
+
+    def truncate_pad(text, width)
+      if text.length > width
+        width > 1 ? "#{text[0, width - 1]}\u2026" : text[0, width]
+      else
+        text.ljust(width)
+      end
+    end
+
+    def clamp_offset
+      return if @rows.empty?
+
+      @offset = @cursor if @cursor < @offset
+      @offset = @cursor - @height + 1 if @cursor >= @offset + @height
+      @offset = [0, @offset].max
+    end
+  end
+end

data/lib/petals/text_area/key_map.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Petals
+  class TextArea
+    DEFAULT_KEY_MAP = KeyBinding.normalize({
+                                             character_forward: [[:right, []], ["f", [:ctrl]]],
+                                             character_backward: [[:left, []], ["b", [:ctrl]]],
+                                             word_forward: [[:right, [:alt]], [:right, [:ctrl]], ["f", [:alt]]],
+                                             word_backward: [[:left, [:alt]], [:left, [:ctrl]], ["b", [:alt]]],
+                                             delete_word_backward: [[:backspace, [:alt]], ["w", [:ctrl]]],
+                                             delete_word_forward: [[:delete, [:alt]], ["d", [:alt]]],
+                                             delete_after_cursor: [["k", [:ctrl]]],
+                                             delete_before_cursor: [["u", [:ctrl]]],
+                                             delete_char_backward: [[:backspace, []], ["h", [:ctrl]]],
+                                             delete_char_forward: [[:delete, []], ["d", [:ctrl]]],
+                                             line_start: [[:home, []], ["a", [:ctrl]]],
+                                             line_end: [[:end_key, []], ["e", [:ctrl]]],
+                                             line_up: [[:up, []]],
+                                             line_down: [[:down, []]],
+                                             new_line: [[:enter, []]],
+                                             input_begin: [[:home, [:ctrl]]],
+                                             input_end: [[:end_key, [:ctrl]]],
+                                             page_up: [[:page_up, []]],
+                                             page_down: [[:page_down, []]],
+                                           })
+  end
+end