bubbles 0.0.5 → 0.1.1

data/lib/bubbles/progress.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "harmonica"
+
+module Bubbles
+  # Progress renders an animated progress bar.
+  #
+  # Example:
+  #   progress = Bubbles::Progress.new
+  #   progress.width = 40
+  #
+  #   # Static rendering
+  #   puts progress.view_as(0.5)  # 50%
+  #
+  #   # Animated rendering (use in bubbletea)
+  #   command = progress.set_percent(0.75)
+  #   # Then in update: progress.update(message)
+  #   puts progress.view
+  #
+  class Progress
+    class FrameMessage < Bubbletea::Message
+      attr_reader :id #: Integer
+      attr_reader :tag #: Integer
+
+      #: (id: Integer, tag: Integer) -> void
+      def initialize(id:, tag:)
+        super()
+        @id = id
+        @tag = tag
+      end
+    end
+
+    FPS = 60 #: Integer
+    DEFAULT_WIDTH = 40 #: Integer
+    SPRING_FREQUENCY = 5.0 #: Float
+    SPRING_DAMPING = 1.0 #: Float
+
+    # rubocop:disable Style/ClassVars
+    @@last_id = 0 #: Integer
+    @@id_mutex = Mutex.new #: Mutex
+
+    #: () -> Integer
+    def self.next_id
+      @@id_mutex.synchronize do
+        @@last_id += 1
+      end
+    end
+    # rubocop:enable Style/ClassVars
+
+    attr_accessor :width #: Integer
+    attr_accessor :full #: String
+    attr_accessor :full_color #: String
+    attr_accessor :empty #: String
+    attr_accessor :empty_color #: String
+    attr_accessor :show_percentage #: bool
+    attr_accessor :percent_format #: String
+    attr_accessor :percent_style #: Lipgloss::Style?
+    attr_accessor :use_gradient #: bool
+    attr_accessor :gradient_a #: String?
+    attr_accessor :gradient_b #: String?
+    attr_accessor :scale_gradient #: bool
+
+    attr_reader :id #: Integer
+
+    #: (?width: Integer, ?gradient: Array[String]?, ?scaled_gradient: Array[String]?, ?solid_fill: String?) -> void
+    def initialize(width: DEFAULT_WIDTH, gradient: nil, scaled_gradient: nil, solid_fill: nil)
+      @id = self.class.next_id
+      @tag = 0
+
+      @width = width
+      @full = "█"
+      @full_color = "#7571F9"
+      @empty = "░"
+      @empty_color = "#606060"
+
+      @show_percentage = true
+      @percent_format = " %3.0f%%"
+      @percent_style = nil
+
+      @percent_shown = 0.0
+      @target_percent = 0.0
+      @velocity = 0.0
+
+      @spring = Harmonica::Spring.new(
+        delta_time: Harmonica.fps(FPS),
+        angular_frequency: SPRING_FREQUENCY,
+        damping_ratio: SPRING_DAMPING
+      )
+
+      @use_gradient = false
+      @gradient_a = nil
+      @gradient_b = nil
+      @scale_gradient = false
+
+      if gradient
+        gradient(gradient[0], gradient[1], scaled: false)
+      elsif scaled_gradient
+        gradient(scaled_gradient[0], scaled_gradient[1], scaled: true)
+      elsif solid_fill
+        @full_color = solid_fill
+        @use_gradient = false
+      end
+    end
+
+    #: () -> nil
+    def init
+      nil
+    end
+
+    #: (Bubbletea::Message) -> [Progress, Bubbletea::Command?]
+    def update(message)
+      command = nil
+
+      case message
+      when FrameMessage
+        if message.id == @id && message.tag == @tag && animating?
+          @percent_shown, @velocity = @spring.update(
+            @percent_shown,
+            @velocity,
+            @target_percent
+          )
+
+          if (@percent_shown - @target_percent).abs < 0.001 && @velocity.abs < 0.001
+            @percent_shown = @target_percent
+            @velocity = 0.0
+          else
+            command = next_frame
+          end
+        end
+      end
+
+      [self, command]
+    end
+
+    #: () -> String
+    def view
+      view_as(@percent_shown)
+    end
+
+    #: (Float) -> String
+    def view_as(percent)
+      percent = percent.clamp(0.0, 1.0)
+
+      percentage_view = render_percentage(percent)
+      bar = render_bar(percent, percentage_view.length)
+
+      "#{bar}#{percentage_view}"
+    end
+
+    #: () -> Float
+    def percent
+      @target_percent
+    end
+
+    #: (Float) -> Bubbletea::Command
+    def set_percent(percent) # rubocop:disable Naming/AccessorMethodName
+      @target_percent = percent.clamp(0.0, 1.0)
+      @tag += 1
+
+      next_frame
+    end
+
+    #: (?Float) -> Bubbletea::Command
+    def increment_percent(amount = 1.0)
+      set_percent(percent + amount)
+    end
+
+    #: (?Float) -> Bubbletea::Command
+    def decrement_percent(amount = 1.0)
+      set_percent(percent - amount)
+    end
+
+    #: () -> bool
+    def animating?
+      (@percent_shown - @target_percent).abs >= 0.001
+    end
+
+    #: (String, String, ?scaled: bool) -> void
+    def gradient(color_a, color_b, scaled: false)
+      @use_gradient = true
+      @gradient_a = color_a
+      @gradient_b = color_b
+      @scale_gradient = scaled
+    end
+
+    private
+
+    #: () -> Bubbletea::Command
+    def next_frame
+      id = @id
+      tag = @tag
+      interval = 1.0 / FPS
+
+      Bubbletea.tick(interval) do
+        FrameMessage.new(id: id, tag: tag)
+      end
+    end
+
+    #: (Float, Integer) -> String
+    def render_bar(percent, text_width)
+      total_width = [@width - text_width, 0].max
+      filled_width = (total_width * percent).round
+      filled_width = filled_width.clamp(0, total_width)
+      empty_width = [total_width - filled_width, 0].max
+
+      filled = if @use_gradient && @gradient_a && @gradient_b
+                 render_gradient_fill(filled_width, total_width)
+               else
+                 render_solid_fill(filled_width)
+               end
+
+      empty = render_empty_fill(empty_width)
+
+      "#{filled}#{empty}"
+    end
+
+    #: (Integer) -> String
+    def render_solid_fill(width)
+      return "" if width <= 0
+
+      char = @full * width
+      colorize(char, @full_color)
+    end
+
+    #: (Integer) -> String
+    def render_empty_fill(width)
+      return "" if width <= 0
+
+      char = @empty * width
+      colorize(char, @empty_color)
+    end
+
+    #: (Integer, Integer) -> String
+    def render_gradient_fill(filled_width, total_width)
+      return "" if filled_width <= 0
+
+      result = ""
+
+      filled_width.times do |i|
+        p = if filled_width == 1
+              0.5
+            elsif @scale_gradient
+              i.to_f / (filled_width - 1)
+            else
+              i.to_f / [total_width - 1, 1].max
+            end
+
+        color = blend_colors(@gradient_a, @gradient_b, p)
+        result += colorize(@full, color)
+      end
+
+      result
+    end
+
+    #: (Float) -> String
+    def render_percentage(percent)
+      return "" unless @show_percentage
+
+      text = format(@percent_format, percent * 100)
+      (style = @percent_style) ? style.render(text) : text
+    end
+
+    #: (String, String) -> String
+    def colorize(text, color)
+      Lipgloss::Style.new.foreground(color).render(text)
+    end
+
+    #: (String?, String?, Float) -> String
+    def blend_colors(color_a, color_b, ratio)
+      a = color_a || @full_color
+      b = color_b || @full_color
+      Lipgloss::ColorBlend.blend(a, b, ratio)
+    end
+  end
+end

data/lib/bubbles/spinner/spinners.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Bubbles
+  module Spinners
+    LINE = {
+      frames: ["|", "/", "-", "\\"],
+      fps: 0.1,
+    }.freeze #: Hash[Symbol, Array[String] | Float]
+
+    DOT = {
+      frames: ["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"],
+      fps: 0.1,
+    }.freeze #: Hash[Symbol, Array[String] | Float]
+
+    MINI_DOT = {
+      frames: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
+      fps: 0.083,
+    }.freeze #: Hash[Symbol, Array[String] | Float]
+
+    JUMP = {
+      frames: ["⢄", "⢂", "⢁", "⡁", "⡈", "⡐", "⡠"],
+      fps: 0.1,
+    }.freeze #: Hash[Symbol, Array[String] | Float]
+
+    PULSE = {
+      frames: ["█", "▓", "▒", "░"],
+      fps: 0.125,
+    }.freeze #: Hash[Symbol, Array[String] | Float]
+
+    POINTS = {
+      frames: ["∙∙∙", "●∙∙", "∙●∙", "∙∙●"],
+      fps: 0.143,
+    }.freeze #: Hash[Symbol, Array[String] | Float]
+
+    GLOBE = {
+      frames: ["🌍", "🌎", "🌏"],
+      fps: 0.25,
+    }.freeze #: Hash[Symbol, Array[String] | Float]
+
+    MOON = {
+      frames: ["🌑", "🌒", "🌓", "🌔", "🌕", "🌖", "🌗", "🌘"],
+      fps: 0.125,
+    }.freeze #: Hash[Symbol, Array[String] | Float]
+
+    MONKEY = {
+      frames: ["🙈", "🙉", "🙊"],
+      fps: 0.333,
+    }.freeze #: Hash[Symbol, Array[String] | Float]
+
+    METER = {
+      frames: [
+        "▱▱▱",
+        "▰▱▱",
+        "▰▰▱",
+        "▰▰▰",
+        "▰▰▱",
+        "▰▱▱",
+        "▱▱▱",
+      ],
+      fps: 0.143,
+    }.freeze #: Hash[Symbol, Array[String] | Float]
+
+    HAMBURGER = {
+      frames: ["☱", "☲", "☴", "☲"],
+      fps: 0.333,
+    }.freeze #: Hash[Symbol, Array[String] | Float]
+
+    ELLIPSIS = {
+      frames: ["", ".", "..", "..."],
+      fps: 0.333,
+    }.freeze #: Hash[Symbol, Array[String] | Float]
+
+    # @rbs DEFAULT:
+    DEFAULT = LINE #: Hash[Symbol, Array[String] | Float]
+  end
+end

data/lib/bubbles/spinner.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require_relative "spinner/spinners"
+
+module Bubbles
+  # Spinner is an animated activity indicator component.
+  #
+  # Example:
+  #   spinner = Bubbles::Spinner.new(spinner: Bubbles::Spinners::DOT)
+  #   spinner.style = Lipgloss::Style.new.foreground("205")
+  #
+  #   # In your model's init:
+  #   def init
+  #     [self, @spinner.tick]
+  #   end
+  #
+  #   # In your model's update:
+  #   def update(message)
+  #     case message
+  #     when Bubbles::Spinner::TickMessage
+  #       @spinner, command = @spinner.update(message)
+  #       [self, command]
+  #     end
+  #   end
+  #
+  #   # In your model's view:
+  #   def view
+  #     "#{@spinner.view} Loading..."
+  #   end
+  #
+  class Spinner
+    class TickMessage < Bubbletea::Message
+      attr_reader :id #: Integer
+      attr_reader :tag #: Integer
+
+      #: (id: Integer, tag: Integer) -> void
+      def initialize(id:, tag:)
+        super()
+
+        @id = id
+        @tag = tag
+      end
+    end
+
+    # @rbs self.@next_id: Integer
+    # @rbs self.@id_mutex: Mutex
+    @next_id = 0
+    @id_mutex = Mutex.new
+
+    class << self
+      #: () -> Integer
+      def next_id
+        @id_mutex.synchronize do
+          @next_id += 1
+        end
+      end
+    end
+
+    attr_reader :id #: Integer
+    attr_accessor :spinner #: Hash[Symbol, untyped]
+    attr_accessor :style #: Lipgloss::Style?
+
+    #: (?spinner: Hash[Symbol, untyped], ?style: Lipgloss::Style?) -> void
+    def initialize(spinner: Spinners::DEFAULT, style: nil)
+      @spinner = spinner
+      @style = style
+      @frame = 0
+      @id = self.class.next_id
+      @tag = 0
+    end
+
+    #: () -> [Spinner, Bubbletea::Command]
+    def init
+      [self, tick]
+    end
+
+    #: (Bubbletea::Message) -> [Spinner, Bubbletea::Command?]
+    def update(message)
+      case message
+      when TickMessage
+        return [self, nil] if message.id.positive? && message.id != @id
+        return [self, nil] if message.tag.positive? && message.tag != @tag
+
+        @frame = (@frame + 1) % frames.length
+        @tag += 1
+
+        [self, tick]
+      else
+        [self, nil]
+      end
+    end
+
+    #: () -> String
+    def view
+      return "(error)" if @frame >= frames.length
+
+      frame_str = frames[@frame]
+      (style = @style) ? style.render(frame_str) : frame_str
+    end
+
+    #: () -> Bubbletea::Command
+    def tick
+      current_id = @id
+      current_tag = @tag
+
+      Bubbletea.tick(fps) { TickMessage.new(id: current_id, tag: current_tag) }
+    end
+
+    private
+
+    #: () -> Array[String]
+    def frames
+      @spinner[:frames] || Spinners::DEFAULT[:frames]
+    end
+
+    #: () -> Float
+    def fps
+      @spinner[:fps] || Spinners::DEFAULT[:fps]
+    end
+  end
+end

data/lib/bubbles/stopwatch.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Bubbles
+  # Stopwatch is an elapsed time counter component.
+  #
+  # Example:
+  #   stopwatch = Bubbles::Stopwatch.new
+  #
+  #   # In your model's init:
+  #   def init
+  #     [self, @stopwatch.init]
+  #   end
+  #
+  #   # In your model's update:
+  #   def update(message)
+  #     case message
+  #     when Bubbles::Stopwatch::TickMessage, Bubbles::Stopwatch::StartStopMessage, Bubbles::Stopwatch::ResetMessage
+  #       @stopwatch, command = @stopwatch.update(message)
+  #
+  #       [self, command]
+  #     end
+  #   end
+  #
+  class Stopwatch
+    class TickMessage < Bubbletea::Message
+      attr_reader :id #: Integer
+      attr_reader :tag #: Integer
+
+      #: (id: Integer, tag: Integer) -> void
+      def initialize(id:, tag:)
+        super()
+
+        @id = id
+        @tag = tag
+      end
+    end
+
+    class StartStopMessage < Bubbletea::Message
+      attr_reader :id #: Integer
+      attr_reader :running #: bool
+
+      #: (id: Integer, running: bool) -> void
+      def initialize(id:, running:)
+        super()
+
+        @id = id
+        @running = running
+      end
+    end
+
+    class ResetMessage < Bubbletea::Message
+      attr_reader :id #: Integer
+
+      #: (id: Integer) -> void
+      def initialize(id:)
+        super()
+
+        @id = id
+      end
+    end
+
+    # @rbs self.@next_id: Integer
+    # @rbs self.@id_mutex: Mutex
+    @next_id = 0
+    @id_mutex = Mutex.new
+
+    class << self
+      #: () -> Integer
+      def next_id
+        @id_mutex.synchronize do
+          @next_id += 1
+        end
+      end
+    end
+
+    attr_reader :elapsed #: Float
+    attr_reader :interval #: Float
+    attr_reader :id #: Integer
+
+    #: (?interval: Float) -> void
+    def initialize(interval: 1.0)
+      @elapsed = 0.0
+      @interval = interval.to_f
+      @id = self.class.next_id
+      @tag = 0
+      @running = false
+    end
+
+    #: () -> Bubbletea::Command
+    def init
+      start
+    end
+
+    #: () -> bool
+    def running?
+      @running
+    end
+
+    #: (Bubbletea::Message) -> [Stopwatch, Bubbletea::Command?]
+    def update(message)
+      case message
+      when StartStopMessage
+        return [self, nil] if message.id.positive? && message.id != @id
+
+        @running = message.running
+
+        [self, @running ? tick : nil]
+      when ResetMessage
+        return [self, nil] if message.id.positive? && message.id != @id
+
+        @elapsed = 0.0
+
+        [self, nil]
+      when TickMessage
+        return [self, nil] unless @running
+        return [self, nil] if message.id.positive? && message.id != @id
+        return [self, nil] if message.tag.positive? && message.tag != @tag
+
+        @elapsed += @interval
+        @tag += 1
+
+        [self, tick]
+      else
+        [self, nil]
+      end
+    end
+
+    #: () -> String
+    def view
+      format_duration(@elapsed)
+    end
+
+    #: () -> Bubbletea::Command
+    def start
+      current_id = @id
+      current_tag = @tag
+
+      Bubbletea.sequence(
+        Bubbletea.send_message(StartStopMessage.new(id: current_id, running: true)),
+        Bubbletea.tick(@interval) { TickMessage.new(id: current_id, tag: current_tag) }
+      )
+    end
+
+    #: () -> Bubbletea::Command
+    def stop
+      current_id = @id
+      Bubbletea.send_message(StartStopMessage.new(id: current_id, running: false))
+    end
+
+    #: () -> Bubbletea::Command
+    def toggle
+      running? ? stop : start
+    end
+
+    #: () -> Bubbletea::Command
+    def reset
+      current_id = @id
+      Bubbletea.send_message(ResetMessage.new(id: current_id))
+    end
+
+    private
+
+    #: () -> Bubbletea::Command?
+    def tick
+      return nil unless running?
+
+      current_id = @id
+      current_tag = @tag
+
+      Bubbletea.tick(@interval) { TickMessage.new(id: current_id, tag: current_tag) }
+    end
+
+    #: (Float) -> String
+    def format_duration(seconds)
+      total_seconds = seconds.to_i
+      hours = total_seconds / 3600
+      minutes = (total_seconds % 3600) / 60
+      secs = total_seconds % 60
+      ms = ((seconds - total_seconds) * 100).to_i
+
+      if hours.positive?
+        format("%<hours>d:%<minutes>02d:%<secs>02d.%<ms>02d", hours: hours, minutes: minutes, secs: secs, ms: ms)
+      else
+        format("%<minutes>d:%<secs>02d.%<ms>02d", minutes: minutes, secs: secs, ms: ms)
+      end
+    end
+  end
+end