grmenu 4.1.0 → 5.0.0

data/grmenu/widgets/input.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+class GRmenu
+  # Solicita una entrada de texto interactiva en la consola con diseño encapsulado en caja.
+  #
+  # Soporta modo contraseña (ocultando caracteres con asteriscos), configuración de
+  # colores ANSI o modo Chroma/RGB dinámico, y respeta la configuración global de temas
+  # definida en la sección "input".
+  #
+  # @param prompt_or_title [String, nil] Título o prompt inicial por compatibilidad.
+  # @param title [String, nil] Título superior de la caja de diálogo.
+  # @param label [String, nil] Etiqueta que acompaña al campo de texto.
+  # @param default [String] Valor precargado en el campo.
+  # @param password [Boolean] Si es true, muestra '*' en lugar de los caracteres reales.
+  # @param color [String, Symbol, nil] Color general de la caja.
+  # @param border_color [String, Symbol, nil] Color específico para los bordes.
+  # @param title_color [String, Symbol, nil] Color para el texto del título.
+  # @param label_color [String, Symbol, nil] Color para la etiqueta del campo.
+  # @param style [Integer, nil] Estilo de borde (1 al 12).
+  # @param width [Integer, nil] Ancho forzado de la caja.
+  # @return [String] El texto final ingresado por el usuario.
+  def self.input(prompt_or_title = nil, title: nil, label: nil, default: "", password: false, color: nil, border_color: nil, title_color: nil, label_color: nil, style: nil, width: nil)
+    # Extraemos la sección de configuración de tema global si está presente
+    input_theme = (@@global_theme.is_a?(Hash) && @@global_theme.dig(:sections, "input")) || {}
+    border_style = (style || input_theme["style"] || 3).to_i
+    border_chars = BORDERS[border_style] || BORDERS[3]
+
+    horizontal_top    = border_chars[:ht] || border_chars[:h]
+    horizontal_bottom = border_chars[:hb] || border_chars[:h]
+    vertical_left     = border_chars[:vl] || border_chars[:v]
+    vertical_right    = border_chars[:vr] || border_chars[:v]
+
+    # Resolvemos el título de la caja considerando los diferentes parámetros aceptados
+    box_title = if title && !title.to_s.empty?
+                  title.to_s
+                elsif prompt_or_title && !label
+                  prompt_or_title.to_s
+                else
+                  input_theme["title"] || "Entrada de Datos"
+                end
+
+    # Etiqueta que precede al cursor donde el usuario escribe
+    input_label = if label && !label.to_s.empty?
+                    label.to_s
+                  elsif prompt_or_title && title
+                    prompt_or_title.to_s
+                  elsif input_theme["label"]
+                    input_theme["label"].to_s
+                  else
+                    "Valor:"
+                  end
+
+    # Resolución de paleta de colores para bordes, título y texto
+    border_color_name = (border_color || color || input_theme["border_color"] || input_theme["color"] || "cyan").to_s
+    title_color_name  = (title_color || input_theme["title_color"] || "yellow").to_s
+    label_color_name  = (label_color || input_theme["label_color"] || "white").to_s
+
+    is_rgb = (border_color_name.downcase == "rgb" || border_color_name.downcase == "rainbow" || border_color_name.downcase == "chroma")
+
+    # Buffer mutable donde iremos acumulando las pulsaciones del usuario
+    buffer_text = String.new(default.to_s)
+    term_width = terminal_width
+    prompt_len = display_width(box_title) + 6
+    content_len = display_width(input_label) + display_width(buffer_text) + 12
+    box_width = width ? width.to_i : [prompt_len, content_len, 48].max
+    box_width = [box_width, term_width - 4].min
+    inner_width = [box_width - 2, 20].max
+
+    drawn_lines = 0
+
+    # Dibuja la caja completa y sobreescribe el cuadro anterior subiendo el cursor
+    render_input = lambda do
+      display_str = password ? ("*" * buffer_text.length) : buffer_text
+      available_width = [inner_width - display_width(input_label) - 4, 4].max
+      # Si el texto es más largo que la ventana disponible, mostramos el final con puntos suspensivos
+      if display_width(display_str) > available_width
+        display_str = "..." + display_str[-[available_width - 3, 1].max..-1]
+      end
+
+      border_code = is_rgb ? "" : ansi_color(border_color_name, 1)
+      title_code  = ansi_color(title_color_name, 2)
+      label_code  = ansi_color(label_color_name, 2)
+      reset_code  = ansi_reset
+
+      clean_title = " #{box_title} "
+      title_w = display_width(clean_title)
+      left_pad  = [(inner_width - title_w) / 2, 0].max
+      right_pad = [inner_width - title_w - left_pad, 0].max
+
+      top_fill_left  = (horizontal_top * left_pad)[0...left_pad]
+      top_fill_right = (horizontal_top * right_pad)[0...right_pad]
+      bottom_fill    = (horizontal_bottom * inner_width)[0...inner_width]
+
+      top_line = if is_rgb
+                   Color.rgb("#{border_chars[:tl]}#{top_fill_left}") + title_code + clean_title + Color.rgb("#{top_fill_right}#{border_chars[:tr]}")
+                 else
+                   "#{border_code}#{border_chars[:tl]}#{top_fill_left}#{reset_code}#{title_code}#{clean_title}#{reset_code}#{border_code}#{top_fill_right}#{border_chars[:tr]}#{reset_code}"
+                 end
+
+      empty_line = if is_rgb
+                     Color.rgb("#{vertical_left}#{' ' * inner_width}#{vertical_right}")
+                   else
+                     "#{border_code}#{vertical_left}#{reset_code}#{' ' * inner_width}#{border_code}#{vertical_right}#{reset_code}"
+                   end
+
+      raw_content = " #{input_label}  #{display_str}█"
+      content_pad = [inner_width - display_width(raw_content), 0].max
+      content_line = if is_rgb
+                       "#{Color.rgb(vertical_left)} #{label_code}#{input_label}#{reset_code}  #{Color.bright_white(display_str)}█#{' ' * content_pad}#{Color.rgb(vertical_right)}"
+                     else
+                       "#{border_code}#{vertical_left}#{reset_code} #{label_code}#{input_label}#{reset_code}  #{Color.bright_white(display_str)}█#{' ' * content_pad}#{border_code}#{vertical_right}#{reset_code}"
+                     end
+
+      bottom_line = if is_rgb
+                      Color.rgb("#{border_chars[:bl]}#{bottom_fill}#{border_chars[:br]}")
+                    else
+                      "#{border_code}#{border_chars[:bl]}#{bottom_fill}#{border_chars[:br]}#{reset_code}"
+                    end
+
+      lines = [top_line, empty_line, content_line, empty_line, bottom_line]
+      frame = lines.join("\r\n") + "\r\n"
+
+      # Rebobinamos el cursor tantas líneas como dibujamos la última vez para no duplicar en pantalla
+      Kernel.print("\e[#{drawn_lines}A\e[J") if drawn_lines > 0
+      Kernel.print(frame)
+      $stdout.flush
+      drawn_lines = lines.length
+    end
+
+    is_tty = $stdin.respond_to?(:tty?) && $stdin.tty?
+
+    begin
+      Kernel.print(HIDE_CURSOR)
+      render_input.call
+
+      reader = lambda do |stream|
+        while (key = GRmenu.read_key_raw(stream))
+          # Salir si el usuario presiona Ctrl+C o Escape
+          break if key == "\x03" || key == "\e"
+
+          if key == "\r" || key == "\n"
+            # Confirmar y salir con el valor escrito
+            break
+          elsif key == "\x7f" || key == "\b" || key == "\x08"
+            # Backspace: borrar el último caracter
+            buffer_text.chop!
+            render_input.call
+          elsif key == "\x15"
+            # Ctrl+U: limpiar todo el campo de entrada
+            buffer_text.clear
+            render_input.call
+          elsif key =~ /^[[:print:]]$/
+            # Caracter imprimible: lo agregamos si cabe dentro del ancho interno
+            buffer_text << key if display_width(buffer_text) < (inner_width - display_width(input_label) - 6)
+            render_input.call
+          end
+        end
+      end
+
+      if is_tty
+        $stdin.raw { |s| reader.call(s) }
+      else
+        reader.call($stdin)
+      end
+    ensure
+      Kernel.print(SHOW_CURSOR)
+    end
+
+    buffer_text
+  end
+end

data/grmenu/widgets/modal.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+# ==============================================================================
+# GRmenu::Widgets::Modal - Ventana flotante emergente con sombra proyectada 3D.
+# Soporta botones de accion, ajuste de texto, Drop Shadow y temas CSS .gr.
+# ==============================================================================
+
+class GRmenu
+  # Renderiza una ventana modal flotante interactiva con sombra proyectada 3D.
+  # Admite botones interactivos, centrado en pantalla y soporte completo de color.
+  def self.modal(title_or_content = nil, content_arg = nil, title: nil, content: nil, buttons: ["Aceptar"], color: nil, border_color: nil, title_color: nil, content_color: nil, style: 3, width: nil, shadow: true, shadow_char: "▒", shadow_color: "gray", center: true)
+    modal_theme = (@@global_theme.is_a?(Hash) && (@@global_theme.dig(:sections, "modal") || @@global_theme.dig(:sections, "card"))) || {}
+    actual_title = title || (content_arg ? title_or_content : nil) || modal_theme["title"]
+    actual_content = (content || (content_arg ? content_arg : title_or_content) || "").to_s
+
+    style_num = (style || modal_theme["style"] || 3).to_i
+    border_cfg = BORDERS[style_num] || BORDERS[3]
+
+    brd_color_name = (border_color || color || modal_theme["border_color"] || modal_theme["color"] || "cyan").to_s
+    tit_color_name = (title_color || modal_theme["title_color"] || "yellow").to_s
+    cnt_color_name = (content_color || modal_theme["content_color"] || "white").to_s
+    shd_color_name = (shadow_color || "gray").to_s
+
+    is_rgb = (brd_color_name.downcase == "rgb" || brd_color_name.downcase == "rainbow" || brd_color_name.downcase == "chroma")
+
+    btn_list = if buttons.is_a?(Array)
+                 buttons.map(&:to_s)
+               elsif buttons
+                 [buttons.to_s]
+               else
+                 []
+               end
+    selected_btn_idx = 0
+
+    raw_lines = actual_content.split("\n")
+    term_w = terminal_width
+    content_max_w = raw_lines.map { |l| display_width(l) }.max || 0
+    title_w = actual_title ? display_width(actual_title) + 6 : 0
+    btns_total_w = btn_list.map { |b| display_width(b) + 8 }.sum + (btn_list.length * 2)
+
+    box_w = width ? width.to_i : [content_max_w + 6, title_w, btns_total_w, 42].max
+    box_w = [box_w, term_w - 6].min
+    inner_w = [box_w - 2, 20].max
+
+    wrapped_lines = []
+    raw_lines.each do |raw_l|
+      if display_width(raw_l) <= (inner_w - 2)
+        wrapped_lines << raw_l
+      else
+        curr = String.new("")
+        raw_l.split(" ").each do |w|
+          if curr.empty?
+            curr << w
+          elsif display_width("#{curr} #{w}") <= (inner_w - 2)
+            curr << " " << w
+          else
+            wrapped_lines << curr
+            curr = String.new(w)
+          end
+        end
+        wrapped_lines << curr unless curr.empty?
+      end
+    end
+
+    tl = border_cfg[:tl] || "╔"
+    tr = border_cfg[:tr] || "╗"
+    bl = border_cfg[:bl] || "╚"
+    br = border_cfg[:br] || "╝"
+    h_char = border_cfg[:ht] || border_cfg[:h] || "═"
+    v_char = border_cfg[:vl] || border_cfg[:v] || "║"
+
+    left_margin_len = center ? [((term_w - (box_w + (shadow ? 2 : 0))) / 2), 0].max : 0
+    margin = " " * left_margin_len
+
+    drawn_lines = 0
+
+    render_modal = lambda do
+      brd_code = is_rgb ? "" : ansi_color(brd_color_name, 1)
+      tit_code = ansi_color(tit_color_name, 2)
+      cnt_code = ansi_color(cnt_color_name, 1)
+      shd_code = ansi_color(shd_color_name, 1)
+      rst      = ansi_reset
+      shd_char = shadow ? (shadow_char || "▒") : ""
+
+      lines = []
+
+      top_title_str = if actual_title && !actual_title.empty?
+                        t_clean = " #{actual_title} "
+                        t_w = display_width(t_clean)
+                        if t_w > inner_w
+                          t_clean = " #{actual_title[0...[inner_w - 6, 1].max]}... "
+                          t_w = display_width(t_clean)
+                        end
+                        l_len = [(inner_w - t_w) / 2, 0].max
+                        r_len = [inner_w - t_w - l_len, 0].max
+                        (h_char * l_len) + tit_code + t_clean + brd_code + (h_char * r_len)
+                      else
+                        h_char * inner_w
+                      end
+
+      top_line = if is_rgb
+                   Color.rgb("#{tl}#{top_title_str}#{tr}")
+                 else
+                   "#{brd_code}#{tl}#{top_title_str}#{tr}#{rst}"
+                 end
+      lines << "#{margin}#{top_line}"
+
+      wrapped_lines.each do |w_line|
+        pad_text = pad_to_width(" " + w_line, inner_w)
+        mid_line = if is_rgb
+                     "#{Color.rgb(v_char)}#{cnt_code}#{pad_text}#{rst}#{Color.rgb(v_char)}"
+                   else
+                     "#{brd_code}#{v_char}#{rst}#{cnt_code}#{pad_text}#{rst}#{brd_code}#{v_char}#{rst}"
+                   end
+        r_shadow = shadow ? "#{shd_code}#{shd_char * 2}#{rst}" : ""
+        lines << "#{margin}#{mid_line}#{r_shadow}"
+      end
+
+      if !btn_list.empty?
+        lines << "#{margin}#{brd_code}#{v_char}#{rst}#{' ' * inner_w}#{brd_code}#{v_char}#{rst}#{shadow ? "#{shd_code}#{shd_char * 2}#{rst}" : ""}"
+
+        rendered_btns = btn_list.each_with_index.map do |btn, idx|
+          if idx == selected_btn_idx
+            Color.bright_green("> [ #{btn} ] <")
+          else
+            Color.gray("  [ #{btn} ]  ")
+          end
+        end.join("   ")
+
+        vis_btn_w = display_width(rendered_btns)
+        btn_pad_total = [inner_w - vis_btn_w, 0].max
+        btn_l_pad = " " * (btn_pad_total / 2)
+        btn_r_pad = " " * (btn_pad_total - (btn_pad_total / 2))
+
+        btn_row = if is_rgb
+                    "#{Color.rgb(v_char)}#{btn_l_pad}#{rendered_btns}#{btn_r_pad}#{Color.rgb(v_char)}"
+                  else
+                    "#{brd_code}#{v_char}#{rst}#{btn_l_pad}#{rendered_btns}#{btn_r_pad}#{brd_code}#{v_char}#{rst}"
+                  end
+        r_shadow = shadow ? "#{shd_code}#{shd_char * 2}#{rst}" : ""
+        lines << "#{margin}#{btn_row}#{r_shadow}"
+      end
+
+      bot_line = if is_rgb
+                   Color.rgb("#{bl}#{h_char * inner_w}#{br}")
+                 else
+                   "#{brd_code}#{bl}#{h_char * inner_w}#{br}#{rst}"
+                 end
+      r_shadow = shadow ? "#{shd_code}#{shd_char * 2}#{rst}" : ""
+      lines << "#{margin}#{bot_line}#{r_shadow}"
+
+      if shadow
+        lines << "#{margin}  #{shd_code}#{shd_char * box_w}#{rst}"
+      end
+
+      frame = lines.join("\r\n") + "\r\n"
+      Kernel.print("\e[#{drawn_lines}A\e[J") if drawn_lines > 0
+      Kernel.print(frame)
+      $stdout.flush
+      drawn_lines = lines.length
+    end
+
+    is_tty = $stdin.respond_to?(:tty?) && $stdin.tty?
+    result = nil
+
+    begin
+      Kernel.print(HIDE_CURSOR)
+      render_modal.call
+
+      if btn_list.empty?
+        continue
+        result = true
+      else
+        reader = lambda do |stream|
+          while (key = GRmenu.read_key_raw(stream))
+            if key == "\e" || key == "q" || key == "Q" || key == "\x03"
+              result = nil
+              break
+            elsif key == "\e[D" || key == "\eOD" || key == "\xe0K" || key == "\e[Z"
+              selected_btn_idx = (selected_btn_idx - 1) % btn_list.length
+              render_modal.call
+            elsif key == "\e[C" || key == "\eOC" || key == "\xe0M" || key == "\t"
+              selected_btn_idx = (selected_btn_idx + 1) % btn_list.length
+              render_modal.call
+            elsif key == "\r" || key == "\n" || key == " "
+              result = btn_list.length == 1 ? true : btn_list[selected_btn_idx]
+              break
+            end
+          end
+        end
+
+        if is_tty
+          $stdin.raw { |s| reader.call(s) }
+        else
+          reader.call($stdin)
+        end
+      end
+    ensure
+      Kernel.print(SHOW_CURSOR)
+    end
+
+    result
+  end
+
+  class << self
+    alias_method :popup, :modal
+    alias_method :dialog, :modal
+  end
+end

data/grmenu/widgets/progress.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+class GRmenu
+  # Barra de progreso visual con marco decorativo, porcentaje numerico y mensaje de estado.
+  class ProgressBar
+    attr_reader :total, :current, :title, :status
+
+    # Inicializa una nueva barra de progreso
+    def initialize(total = 100, title: nil, color: "cyan", level: 2, style: 3, width: nil)
+      @total   = [total.to_i, 1].max
+      @current = 0
+      @title   = title
+      @status  = String.new("")
+      @color   = color.to_s.downcase
+      @level   = level.to_i
+      @style   = style.to_i
+      @width   = width
+      @closed  = false
+      @drawn_lines_count = 0
+    end
+
+    # Incrementa el progreso actual en un paso y actualiza opcionalmente el mensaje de estado
+    def advance(step = 1, status: nil)
+      return if @closed
+      @current = [(@current + step), @total].min
+      @status = status.to_s if status
+      render
+    end
+    alias_method :increment, :advance
+    alias_method :step, :advance
+
+    # Fija el progreso a un valor numerico absoluto
+    def set(value, status: nil)
+      return if @closed
+      @current = [[value.to_i, 0].max, @total].min
+      @status = status.to_s if status
+      render
+    end
+
+    # Renderiza la barra en la terminal reemplazando las lineas anteriores
+    def render
+      term_w = GRmenu.terminal_width
+      box_w = @width || [term_w - 4, 60].min
+      box_w = [box_w, 36].max
+
+      is_rgb = (@color == "rgb" || @color == "rainbow" || @color == "chroma")
+      # Angulo en radianes (0 a 2*pi = 6.2831853) para desplazar el color en modo RGB segun el avance
+      tick = (@current.to_f / @total) * 6.2831853
+
+      border_cfg = GRmenu::BORDERS[@style] || GRmenu::BORDERS[3]
+      v_l = border_cfg[:vl] || border_cfg[:v]
+      v_r = border_cfg[:vr] || border_cfg[:v]
+      h_t = border_cfg[:ht] || border_cfg[:h]
+      h_b = border_cfg[:hb] || border_cfg[:h]
+
+      top_fill = (h_t * ((box_w - 2).to_f / h_t.length).ceil)[0...(box_w - 2)]
+      bot_fill = (h_b * ((box_w - 2).to_f / h_b.length).ceil)[0...(box_w - 2)]
+
+      pct = ((@current.to_f / @total) * 100).round
+      pct_str = "#{pct}% (#{@current}/#{@total})"
+
+      inner_w = box_w - 4
+      bar_w = [inner_w - pct_str.length - 3, 10].max
+      filled_len = ((@current.to_f / @total) * bar_w).round
+      empty_len  = bar_w - filled_len
+
+      lines = []
+      if is_rgb
+        v_r_col = Color.rgb(v_r, tick + (inner_w + 1) * 0.12)
+        lines << Color.rgb("#{border_cfg[:tl]}#{top_fill}#{border_cfg[:tr]}", tick)
+        if @title && !@title.empty?
+          t_str = @title.to_s
+          if GRmenu.display_width(t_str) > inner_w
+            t_str = t_str[0...[inner_w - 3, 1].max] + "..."
+          end
+          pad_t = [inner_w - GRmenu.display_width(t_str), 0].max
+          l_p = " " * (pad_t / 2)
+          r_p = " " * (pad_t - (pad_t / 2))
+          lines << "#{Color.rgb(v_l, tick)} #{l_p}#{Color.rgb(t_str, tick + 2 * 0.12)}#{r_p} #{v_r_col}"
+          lines << Color.rgb("#{v_l}#{top_fill}#{v_r}", tick)
+        end
+
+        filled_part = Color.rgb("█" * filled_len, tick + 2 * 0.12)
+        empty_part  = Color.gray("░" * empty_len)
+        bar_raw_len = 2 + filled_len + empty_len + 1 + pct_str.length
+        pad_bar_len = [inner_w - bar_raw_len, 0].max
+        bar_line = "[#{filled_part}#{empty_part}] #{Color.bright_white(pct_str)}" + (" " * pad_bar_len)
+
+        lines << "#{Color.rgb(v_l, tick)} #{bar_line} #{v_r_col}"
+        if @status && !@status.empty?
+          st_str = @status.to_s
+          if GRmenu.display_width(st_str) > inner_w
+            st_str = st_str[0...[inner_w - 3, 1].max] + "..."
+          end
+          pad_st = [inner_w - GRmenu.display_width(st_str), 0].max
+          st_line = st_str + (" " * pad_st)
+          lines << "#{Color.rgb(v_l, tick)} #{Color.gray(st_line)} #{v_r_col}"
+        end
+        lines << Color.rgb("#{border_cfg[:bl]}#{bot_fill}#{border_cfg[:br]}", tick)
+      else
+        color_code = GRmenu.ansi_color(@color, @level)
+        reset_code = GRmenu.ansi_reset
+
+        bar_str = "[#{"█" * filled_len}#{"░" * empty_len}] #{pct_str}"
+        pad_bar_len = [inner_w - GRmenu.display_width(bar_str), 0].max
+        bar_line = bar_str + (" " * pad_bar_len)
+
+        lines << "#{color_code}#{border_cfg[:tl]}#{top_fill}#{border_cfg[:tr]}#{reset_code}"
+        if @title && !@title.empty?
+          t_str = @title.to_s
+          if GRmenu.display_width(t_str) > inner_w
+            t_str = t_str[0...[inner_w - 3, 1].max] + "..."
+          end
+          pad_t = [inner_w - GRmenu.display_width(t_str), 0].max
+          l_p = " " * (pad_t / 2)
+          r_p = " " * (pad_t - (pad_t / 2))
+          lines << "#{color_code}#{v_l}#{reset_code} #{l_p}#{t_str}#{r_p} #{color_code}#{v_r}#{reset_code}"
+          lines << "#{color_code}#{v_l}#{top_fill}#{v_r}#{reset_code}"
+        end
+        lines << "#{color_code}#{v_l}#{reset_code} #{color_code}#{bar_line}#{reset_code} #{color_code}#{v_r}#{reset_code}"
+        if @status && !@status.empty?
+          st_str = @status.to_s
+          if GRmenu.display_width(st_str) > inner_w
+            st_str = st_str[0...[inner_w - 3, 1].max] + "..."
+          end
+          pad_st = [inner_w - GRmenu.display_width(st_str), 0].max
+          st_line = st_str + (" " * pad_st)
+          lines << "#{color_code}#{v_l}#{reset_code} #{Color.gray(st_line)} #{color_code}#{v_r}#{reset_code}"
+        end
+        lines << "#{color_code}#{border_cfg[:bl]}#{bot_fill}#{border_cfg[:br]}#{reset_code}"
+      end
+
+      frame = lines.join("\r\n") + "\r\n"
+
+      # Si ya habiamos dibujado lineas, subimos el cursor para sobreescribirlas
+      if @drawn_lines_count && @drawn_lines_count > 0
+        Kernel.print("\e[#{@drawn_lines_count}A\e[J")
+      end
+      Kernel.print(frame)
+      $stdout.flush
+      @drawn_lines_count = lines.length
+    end
+
+    # Cierra y finaliza la barra de progreso
+    def finish(status: "¡Completado!")
+      return if @closed
+      set(@total, status: status)
+      @closed = true
+      Kernel.print(GRmenu::SHOW_CURSOR)
+    end
+  end
+
+  # Muestra un spinner animado en un hilo de fondo mientras ejecuta el bloque de codigo proporcionado
+  def self.spinner(message_arg = nil, message: nil, color: "cyan", level: 2, delay: 0.08, &block)
+    actual_message = message || message_arg || "Cargando..."
+    # Caracteres Braille giratorios para el spinner
+    frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+    is_rgb = (color.to_s.downcase == "rgb" || color.to_s.downcase == "rainbow" || color.to_s.downcase == "chroma")
+    color_code = is_rgb ? "" : ansi_color(color, level)
+    reset_code = ansi_reset
+
+    stop_spinner = false
+    spinner_thread = Thread.new do
+      frame_idx = 0
+      while !stop_spinner
+        f = frames[frame_idx % frames.length]
+        f_color = is_rgb ? rgb_color(frame_idx * 0.3) : color_code
+        msg_out = is_rgb ? Color.rgb(actual_message, frame_idx * 0.1) : actual_message
+        Kernel.print("\r\e[K#{f_color}#{f}#{reset_code} #{msg_out}")
+        $stdout.flush
+        frame_idx += 1
+        sleep(delay)
+      end
+    end
+
+    begin
+      Kernel.print(HIDE_CURSOR)
+      result = block ? block.call : nil
+      stop_spinner = true
+      spinner_thread.join
+      success_color = ansi_color("green", 2)
+      Kernel.print("\r\e[K#{success_color}[OK]#{reset_code} #{actual_message} #{Color.gray("Listo!")}\r\n")
+      result
+    rescue Exception => e
+      stop_spinner = true
+      spinner_thread.join rescue nil
+      error_color = ansi_color("red", 2)
+      Kernel.print("\r\e[K#{error_color}[ERROR]#{reset_code} #{actual_message} #{Color.bright_red("(Error: #{e.message})")}\r\n")
+      raise e
+    ensure
+      stop_spinner = true
+      Kernel.print(SHOW_CURSOR)
+    end
+  end
+
+  # Ejecuta un bloque proporcionandole un objeto ProgressBar para reportar tareas largas
+  def self.progress(total_arg = nil, total: nil, title: nil, color: "cyan", level: 2, style: 3, width: nil, &block)
+    actual_total = total || total_arg || 100
+    bar = ProgressBar.new(actual_total, title: title, color: color, level: level, style: style, width: width)
+    Kernel.print(HIDE_CURSOR)
+    bar.render
+    begin
+      result = block ? block.call(bar) : bar
+      bar.finish
+      result
+    ensure
+      Kernel.print(SHOW_CURSOR)
+    end
+  end
+end