grmenu 4.1.0 → 5.0.0

data/grmenu/widgets/slider.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+class GRmenu
+  # Widget de barra deslizante (slider) interactiva para la terminal.
+  #
+  # Permite al usuario seleccionar valores numéricos continuos o discretos dentro
+  # de un rango mínimo y máximo, con teclas de dirección izquierda/derecha (paso simple)
+  # y arriba/abajo (paso rápido de x5).
+  #
+  # @param prompt_arg [String, nil] Texto explicativo posicional.
+  # @param prompt [String, nil] Texto explicativo nominal.
+  # @param min [Numeric] Valor mínimo del rango.
+  # @param max [Numeric] Valor máximo del rango.
+  # @param step [Numeric] Incremento/decremento por pulsación de tecla.
+  # @param default [Numeric, nil] Valor inicial predeterminado.
+  # @param unit [String] Unidad de medida mostrada junto al número (ej: "%", "px", "MB").
+  # @param color [String, Symbol, nil] Color del marco o tema.
+  # @param style [Integer, nil] Estilo de borde (1 al 12).
+  # @param width [Integer] Ancho deseado de la caja.
+  # @return [Integer, Float] El valor final seleccionado.
+  def self.slider(prompt_arg = nil, prompt: nil, min: 0, max: 100, step: 1, default: nil, unit: "", color: nil, style: nil, width: 46)
+    actual_prompt = prompt || prompt_arg || "Selecciona un valor:"
+    slider_theme = (@@global_theme.is_a?(Hash) && @@global_theme.dig(:sections, "slider")) || {}
+    current_value = (default || min).to_f.clamp(min.to_f, max.to_f)
+    step_val = [step.to_f, 0.001].max
+    drawn_lines = 0
+    rgb_tick = 0.0
+    slider_color = (color || slider_theme["color"] || "cyan").to_s
+    border_style = (style || slider_theme["style"] || 3).to_i
+    is_rgb = (slider_color.downcase == "rgb" || slider_color.downcase == "rainbow" || slider_color.downcase == "chroma")
+
+    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]
+
+    render_slider = lambda do
+      term_w = terminal_width
+      box_w = [width, term_w - 4, display_width(actual_prompt) + 8, 38].max
+      box_w = [box_w, term_w - 2].min
+      inner_w = box_w - 4
+
+      top_fill = (horizontal_top * ((box_w - 2).to_f / horizontal_top.length).ceil)[0...(box_w - 2)]
+      bot_fill = (horizontal_bottom * ((box_w - 2).to_f / horizontal_bottom.length).ceil)[0...(box_w - 2)]
+
+      # Mostramos números enteros limpios si no hay decimales
+      val_display = (current_value % 1 == 0) ? current_value.to_i.to_s : current_value.round(2).to_s
+      val_str = unit.to_s.empty? ? val_display : "#{val_display} #{unit}"
+
+      range_span = (max - min).to_f
+      range_span = 1.0 if range_span <= 0
+      fraction = ((current_value - min).to_f / range_span).clamp(0.0, 1.0)
+
+      # Determinamos cuántos bloques llenos (█) y vacíos (░) corresponden al porcentaje actual
+      avail_bar_w = [inner_w - display_width(val_str) - 4, 6].max
+      filled_len = (fraction * avail_bar_w).round
+      empty_len = [avail_bar_w - filled_len, 0].max
+
+      p_clean = actual_prompt.to_s
+      p_clean = p_clean[0...[inner_w - 3, 1].max] + "..." if display_width(p_clean) > inner_w
+      pad_p = [inner_w - display_width(p_clean), 0].max
+      prompt_line = (" " * (pad_p / 2)) + p_clean + (" " * (pad_p - (pad_p / 2)))
+
+      instruction_text = (inner_w >= 30) ? "← / → Ajustar | Enter Guardar" : "←/→: Ajustar | Enter: Ok"
+      instruction_text = instruction_text[0...[inner_w - 3, 1].max] + "..." if display_width(instruction_text) > inner_w
+      pad_i = [inner_w - display_width(instruction_text), 0].max
+      instr_line = (" " * (pad_i / 2)) + instruction_text + (" " * (pad_i - (pad_i / 2)))
+
+      lines = []
+      if is_rgb
+        vr_col = Color.rgb(vertical_right, rgb_tick + (inner_w + 1) * 0.12)
+        lines << Color.rgb("#{border_chars[:tl]}#{top_fill}#{border_chars[:tr]}", rgb_tick)
+        lines << "#{Color.rgb(vertical_left, rgb_tick)} #{Color.rgb(prompt_line, rgb_tick + 2 * 0.12)} #{vr_col}"
+        lines << "#{Color.rgb(vertical_left, rgb_tick)} #{' ' * inner_w} #{vr_col}"
+
+        filled_part = Color.rgb("█" * filled_len, rgb_tick + 0.5)
+        empty_part  = Color.gray("░" * empty_len)
+        bar_raw = "[#{filled_part}#{empty_part}] #{Color.bright_white(val_str)}"
+        bar_vis_w = 2 + filled_len + empty_len + 1 + display_width(val_str)
+        pad_b = [inner_w - bar_vis_w, 0].max
+        lines << "#{Color.rgb(vertical_left, rgb_tick)} #{bar_raw}#{' ' * pad_b} #{vr_col}"
+        lines << "#{Color.rgb(vertical_left, rgb_tick)} #{' ' * inner_w} #{vr_col}"
+        lines << "#{Color.rgb(vertical_left, rgb_tick)} #{Color.gray(instr_line)} #{vr_col}"
+        lines << Color.rgb("#{border_chars[:bl]}#{bot_fill}#{border_chars[:br]}", rgb_tick)
+      else
+        color_code = ansi_color(slider_color, 2)
+        reset_code = ansi_reset
+
+        bar_raw = "[#{"█" * filled_len}#{"░" * empty_len}] #{val_str}"
+        pad_b = [inner_w - display_width(bar_raw), 0].max
+        bar_line = bar_raw + (" " * pad_b)
+
+        lines << "#{color_code}#{border_chars[:tl]}#{top_fill}#{border_chars[:tr]}#{reset_code}"
+        lines << "#{color_code}#{vertical_left}#{reset_code} #{Color.bright_yellow(prompt_line)} #{color_code}#{vertical_right}#{reset_code}"
+        lines << "#{color_code}#{vertical_left}#{reset_code} #{' ' * inner_w} #{color_code}#{vertical_right}#{reset_code}"
+        lines << "#{color_code}#{vertical_left}#{reset_code} #{bar_line} #{color_code}#{vertical_right}#{reset_code}"
+        lines << "#{color_code}#{vertical_left}#{reset_code} #{' ' * inner_w} #{color_code}#{vertical_right}#{reset_code}"
+        lines << "#{color_code}#{vertical_left}#{reset_code} #{Color.gray(instr_line)} #{color_code}#{vertical_right}#{reset_code}"
+        lines << "#{color_code}#{border_chars[:bl]}#{bot_fill}#{border_chars[:br]}#{reset_code}"
+      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?
+
+    begin
+      Kernel.print(HIDE_CURSOR)
+      render_slider.call
+
+      reader = lambda do |stream|
+        while true
+          if is_rgb
+            ready = false
+            if stream.respond_to?(:to_io) || stream.is_a?(IO)
+              begin
+                sr = IO.select([stream], nil, nil, 0.035)
+                ready = true if sr && sr[0] && !sr[0].empty?
+              rescue StandardError
+                ready = true
+              end
+            else
+              ready = true
+            end
+            unless ready
+              rgb_tick += 0.08
+              render_slider.call
+              next
+            end
+          end
+
+          key = GRmenu.read_key_raw(stream)
+          break if key.nil? || key == "\x03" || key == "\x04" || key == "q" || key == "Q" || key == "\e"
+
+          if key == "\e[D" || key == "\eOD" || key == "\xe0K" || key == "\x00K" || key == "h" || key == "H"
+            # Izquierda / 'h': restar 1 paso
+            current_value = (current_value - step_val).clamp(min.to_f, max.to_f)
+            render_slider.call
+          elsif key == "\e[C" || key == "\eOC" || key == "\xe0M" || key == "\x00M" || key == "l" || key == "L"
+            # Derecha / 'l': sumar 1 paso
+            current_value = (current_value + step_val).clamp(min.to_f, max.to_f)
+            render_slider.call
+          elsif key == "\e[B" || key == "\eOB" || key == "\xe0P" || key == "\x00P"
+            # Abajo: paso rápido hacia atrás (x5)
+            current_value = (current_value - step_val * 5).clamp(min.to_f, max.to_f)
+            render_slider.call
+          elsif key == "\e[A" || key == "\eOA" || key == "\xe0H" || key == "\x00H"
+            # Arriba: paso rápido hacia adelante (x5)
+            current_value = (current_value + step_val * 5).clamp(min.to_f, max.to_f)
+            render_slider.call
+          elsif key == "\r" || key == "\n"
+            # Enter: confirmar
+            break
+          end
+        end
+      end
+
+      if is_tty
+        $stdin.raw { |s| reader.call(s) }
+      else
+        reader.call($stdin)
+      end
+    ensure
+      Kernel.print(SHOW_CURSOR)
+    end
+
+    (current_value % 1 == 0) ? current_value.to_i : current_value.round(2)
+  end
+
+  class << self
+    alias_method :range, :slider
+  end
+end

data/grmenu/widgets/table.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+class GRmenu
+  # Tabla interactiva para la terminal con paginación, búsqueda en vivo y ordenamiento.
+  #
+  # Permite al usuario desplazarse entre filas de datos con las teclas direccionales,
+  # filtrar en tiempo real si `search: true`, ordenar columnas con la tecla 's' si `sort: true`,
+  # y seleccionar una fila pulsando Enter.
+  #
+  # @param headers_arg [Array, nil] Encabezados de columnas (posicional).
+  # @param rows_arg [Array, nil] Filas de datos (posicional).
+  # @param headers [Array, nil] Encabezados de columnas (nominal).
+  # @param rows [Array, nil] Filas de datos (nominal).
+  # @param title [String, nil] Título superior enmarcado en la tabla.
+  # @param style [Integer, nil] Estilo de borde (1 al 12).
+  # @param color [String, Symbol, nil] Color general del marco.
+  # @param header_color [String, Symbol, nil] Color de los textos de encabezado.
+  # @param border_color [String, Symbol, nil] Color específico de las líneas divisorias.
+  # @param selected_row [String, Symbol, nil] Color de resalto para la fila seleccionada.
+  # @param page_size [Integer, nil] Número máximo de filas mostradas a la vez.
+  # @param search [Boolean] Habilita barra de búsqueda interactiva en tiempo real.
+  # @param sort [Boolean] Permite ordenar las columnas ciclando con la tecla 's'.
+  # @param animate [Symbol, nil] Efecto de animación opcional.
+  # @param width [Integer, nil] Ancho forzado de la tabla.
+  # @return [Array, nil] La fila seleccionada por el usuario, o nil si canceló.
+  def self.table(headers_arg = nil, rows_arg = nil, headers: nil, rows: nil, title: nil, style: nil, color: nil, header_color: nil, border_color: nil, selected_row: nil, page_size: nil, search: false, sort: false, animate: nil, width: nil, **kwargs)
+    table_theme = (@@global_theme.is_a?(Hash) && @@global_theme.dig(:sections, "table")) || {}
+    input_stream  = $stdin
+    output_stream = $stdout
+
+    border_style = (style || table_theme["style"] || 3).to_i
+    border_chars = BORDERS[border_style] || BORDERS[3]
+
+    table_color_name = (border_color || color || table_theme["border_color"] || table_theme["border"] || table_theme["color"] || "cyan").to_s
+    header_color_val = header_color || table_theme["header_color"] || "yellow"
+    focus_color_val  = selected_row || table_theme["selected_row"] || table_theme["focus"] || "green"
+    page_size ||= (table_theme["page_size"] || 8).to_i
+
+    resolved_headers  = (headers || headers_arg || []).map(&:to_s)
+    resolved_raw_rows = (rows || rows_arg || []).map { |r| r.is_a?(Array) ? r.map(&:to_s) : r.values.map(&:to_s) }
+    headers = resolved_headers
+    raw_rows = resolved_raw_rows
+    filtered_rows = raw_rows.dup
+
+    selected_idx = 0
+    query = String.new("")
+    sort_column_idx = nil
+    sort_ascending = true
+    animation_tick = 0.0
+
+    # Calcula el ancho ideal para cada columna según el contenido más largo
+    calc_widths = lambda do
+      col_counts = [headers.length, raw_rows.map(&:length).max || 0].max
+      widths = Array.new(col_counts, 0)
+      headers.each_with_index { |h, i| widths[i] = [widths[i], display_width(h)].max }
+      filtered_rows.each do |row|
+        row.each_with_index { |cell, i| widths[i] = [widths[i], display_width(cell)].max }
+      end
+      widths.map { |w| w + 2 }
+    end
+
+    draw_table = lambda do |current_tick|
+      is_rgb = ["rgb", "rainbow", "chroma"].include?(table_color_name.downcase) || (animate && ["rgb", "rainbow", "chroma"].include?(animate.to_s.downcase))
+      resolved_border_color = is_rgb ? rgb_color(current_tick, 0.0) : ansi_color(table_color_name, 1)
+      resolved_header_color = is_rgb ? rgb_color(current_tick, 0.8) : ansi_color(header_color_val, 2)
+      resolved_focus_color  = is_rgb ? rgb_color(current_tick, 1.4) : ansi_color(focus_color_val, 2)
+      reset_code = ansi_reset
+
+      col_widths = calc_widths.call
+      help_line = " ↑/↓: Moverse | Enter: Elegir | s: Ordenar | Esc: Salir"
+      total_width = [col_widths.sum + (col_widths.length - 1) + 4, title ? display_width(title) + 8 : 0, display_width(help_line) + 4, 46].max
+      total_width = [total_width, terminal_width - 2].min
+      inner_w = total_width - 2
+
+      # Acortamos el texto de ayuda si el ancho disponible en la terminal es muy pequeño
+      if inner_w < display_width(help_line)
+        help_line = " ↑/↓: Mover | Enter: Ok | Esc: Salir"
+      end
+
+      top_left     = border_chars[:tl] || "#"
+      top_right    = border_chars[:tr] || "#"
+      bot_left     = border_chars[:bl] || "#"
+      bot_right    = border_chars[:br] || "#"
+      horizontal_c = border_chars[:h]  || "─"
+      vertical_c   = border_chars[:v]  || "│"
+
+      top_str = if title && !title.empty?
+                  clean_title = " #{title} "
+                  title_len = display_width(clean_title)
+                  if title_len > inner_w
+                    clean_title = " #{title[0...[(inner_w - 6), 1].max]}... "
+                    title_len = display_width(clean_title)
+                  end
+                  left_len = [(inner_w - title_len) / 2, 0].max
+                  right_len = [inner_w - title_len - left_len, 0].max
+                  horizontal_c * left_len + clean_title + horizontal_c * right_len
+                else
+                  horizontal_c * inner_w
+                end
+
+      out = String.new(CURSOR_HOME)
+      out << HIDE_CURSOR
+      out << "#{resolved_border_color}#{top_left}#{top_str}#{top_right}#{reset_code}#{CLEAR_TO_EOL}\r\n"
+
+      # Si está habilitada la búsqueda, mostramos la barra con el query actual
+      if search
+        search_line = " Buscar: #{query}█"
+        out << "#{resolved_border_color}#{vertical_c}#{reset_code}#{pad_to_width(search_line, inner_w)}#{resolved_border_color}#{vertical_c}#{reset_code}#{CLEAR_TO_EOL}\r\n"
+        out << "#{resolved_border_color}#{vertical_c}#{horizontal_c * inner_w}#{vertical_c}#{reset_code}#{CLEAR_TO_EOL}\r\n"
+      end
+
+      # Fila de encabezados de columnas
+      header_cells = headers.each_with_index.map do |h, i|
+        w = col_widths[i] || 10
+        sort_indicator = sort_column_idx == i ? (sort_ascending ? " ▲" : " ▼") : ""
+        h_str = "#{h}#{sort_indicator}"
+        max_c = [w - 2, 2].max
+        h_str = h_str[0...[max_c - 2, 1].max] + ".." if display_width(h_str) > max_c
+        pad_to_width(" #{h_str}", w)
+      end
+      hdr_row_str = " " + header_cells.join("│")
+      hdr_row_str = hdr_row_str[0...inner_w] if display_width(hdr_row_str) > inner_w
+      out << "#{resolved_border_color}#{vertical_c}#{reset_code}#{resolved_header_color}#{pad_to_width(hdr_row_str, inner_w)}#{reset_code}#{resolved_border_color}#{vertical_c}#{reset_code}#{CLEAR_TO_EOL}\r\n"
+      out << "#{resolved_border_color}#{vertical_c}#{horizontal_c * inner_w}#{vertical_c}#{reset_code}#{CLEAR_TO_EOL}\r\n"
+
+      max_visible = page_size || 8
+      total_rows = filtered_rows.length
+      if total_rows == 0
+        empty_msg = " (Sin registros que coincidan con '#{query}')"
+        out << "#{resolved_border_color}#{vertical_c}#{reset_code}#{pad_to_width(empty_msg, inner_w)}#{resolved_border_color}#{vertical_c}#{reset_code}#{CLEAR_TO_EOL}\r\n"
+      else
+        # Paginación inteligente manteniendo visible la fila seleccionada
+        start_idx = [(selected_idx - max_visible / 2), 0].max
+        start_idx = [start_idx, [total_rows - max_visible, 0].max].min
+        end_idx = [start_idx + max_visible - 1, total_rows - 1].min
+
+        if start_idx > 0
+          up_str = " ▲ (+#{start_idx} arriba)"
+          out << "#{resolved_border_color}#{vertical_c}#{reset_code}#{ansi_color('gray', 1)}#{pad_to_width(up_str, inner_w)}#{reset_code}#{resolved_border_color}#{vertical_c}#{reset_code}#{CLEAR_TO_EOL}\r\n"
+        end
+
+        (start_idx..end_idx).each do |r_i|
+          row = filtered_rows[r_i]
+          is_active = (r_i == selected_idx)
+          prefix = is_active ? "> " : "  "
+
+          row_cells = row.each_with_index.map do |cell, c_i|
+            w = col_widths[c_i] || 10
+            c_str = cell.to_s
+            max_c = [w - 2, 2].max
+            c_str = c_str[0...[max_c - 2, 1].max] + ".." if display_width(c_str) > max_c
+            pad_to_width(" #{c_str}", w)
+          end
+          row_str = prefix + row_cells.join("│")[1..-1].to_s
+          row_str = row_str[0...inner_w] if display_width(row_str) > inner_w
+
+          if is_active
+            out << "#{resolved_border_color}#{vertical_c}#{reset_code}#{resolved_focus_color}#{pad_to_width(row_str, inner_w)}#{reset_code}#{resolved_border_color}#{vertical_c}#{reset_code}#{CLEAR_TO_EOL}\r\n"
+          else
+            out << "#{resolved_border_color}#{vertical_c}#{reset_code}#{pad_to_width(row_str, inner_w)}#{resolved_border_color}#{vertical_c}#{reset_code}#{CLEAR_TO_EOL}\r\n"
+          end
+        end
+
+        remaining_down = total_rows - 1 - end_idx
+        if remaining_down > 0
+          down_str = " ▼ (+#{remaining_down} abajo)"
+          out << "#{resolved_border_color}#{vertical_c}#{reset_code}#{ansi_color('gray', 1)}#{pad_to_width(down_str, inner_w)}#{reset_code}#{resolved_border_color}#{vertical_c}#{reset_code}#{CLEAR_TO_EOL}\r\n"
+        end
+      end
+
+      out << "#{resolved_border_color}#{vertical_c}#{horizontal_c * inner_w}#{vertical_c}#{reset_code}#{CLEAR_TO_EOL}\r\n"
+      out << "#{resolved_border_color}#{vertical_c}#{reset_code}#{ansi_color('gray', 1)}#{pad_to_width(help_line, inner_w)}#{reset_code}#{resolved_border_color}#{vertical_c}#{reset_code}#{CLEAR_TO_EOL}\r\n"
+      out << "#{resolved_border_color}#{bot_left}#{horizontal_c * inner_w}#{bot_right}#{reset_code}#{CLEAR_TO_EOL}\r\n"
+      out << CLEAR_TO_EOS
+      output_stream.print(out)
+      output_stream.flush
+    end
+
+    loop_res = nil
+    reader = lambda do |stream|
+      loop do
+        draw_table.call(animation_tick)
+        is_anim = is_rgb
+        if is_anim
+          ready = false
+          if stream.respond_to?(:to_io) || stream.is_a?(IO)
+            begin
+              res = IO.select([stream], nil, nil, 0.035)
+              ready = true if res && res[0] && !res[0].empty?
+            rescue StandardError
+              ready = true
+            end
+          else
+            ready = true
+          end
+          unless ready
+            animation_tick += 0.08
+            next
+          end
+        end
+
+        key = read_key_raw(stream)
+        break if key.nil? || key == "\x03" || key == "\x04"
+
+        if key == "\e[A" || key == "\eOA" || key == "\xe0H" || key == "\x00H"
+          # Flecha Arriba
+          if filtered_rows.length > 0
+            selected_idx = (selected_idx - 1) % filtered_rows.length
+          end
+        elsif key == "\e[B" || key == "\eOB" || key == "\xe0P" || key == "\x00P"
+          # Flecha Abajo
+          if filtered_rows.length > 0
+            selected_idx = (selected_idx + 1) % filtered_rows.length
+          end
+        elsif key == "\e[5~" || key == "\e[D"
+          # RePág o Flecha Izquierda: saltar una página hacia arriba
+          if filtered_rows.length > 0
+            selected_idx = [(selected_idx - (page_size || 8)), 0].max
+          end
+        elsif key == "\e[6~" || key == "\e[C"
+          # AvPág o Flecha Derecha: saltar una página hacia abajo
+          if filtered_rows.length > 0
+            selected_idx = [(selected_idx + (page_size || 8)), filtered_rows.length - 1].min
+          end
+        elsif key == "\r" || key == "\n"
+          # Confirmar fila seleccionada
+          if filtered_rows.length > 0
+            loop_res = filtered_rows[selected_idx]
+          end
+          break
+        elsif key == "\e"
+          # Escape: si había búsqueda activa la limpia, de lo contrario sale
+          if search && !query.empty?
+            query.clear
+            filtered_rows = raw_rows.dup
+            selected_idx = 0
+          else
+            loop_res = nil
+            break
+          end
+        elsif key == "\x7f" || key == "\b" || key == "\x08"
+          # Borrar caracter en el filtro de búsqueda
+          if search && !query.empty?
+            query.chop!
+            if query.empty?
+              filtered_rows = raw_rows.dup
+            else
+              filtered_rows = raw_rows.select { |r| r.any? { |c| c.downcase.include?(query.downcase) } }
+            end
+            selected_idx = 0
+          end
+        elsif key == "\x15"
+          # Ctrl+U: limpiar búsqueda por completo
+          if search
+            query.clear
+            filtered_rows = raw_rows.dup
+            selected_idx = 0
+          end
+        elsif (!search || query.empty?) && (key == "s" || key == "S")
+          # Ciclar por la siguiente columna para ordenar
+          if sort
+            sort_column_idx = ((sort_column_idx || -1) + 1) % [headers.length, 1].max
+            filtered_rows.sort_by! { |r| r[sort_column_idx] || "" }
+            selected_idx = 0
+          end
+        elsif (!search || query.empty?) && (key == "q" || key == "Q")
+          loop_res = nil
+          break
+        elsif search && key =~ /^[[:print:]]$/
+          # Agregar letra al filtro de búsqueda y actualizar filas visibles al vuelo
+          query << key
+          filtered_rows = raw_rows.select { |r| r.any? { |c| c.downcase.include?(query.downcase) } }
+          selected_idx = 0
+        end
+      end
+    end
+
+    begin
+      output_stream.print("#{HIDE_CURSOR}#{CLEAR_SCREEN_SEQUENCE}")
+      if input_stream.respond_to?(:raw) && input_stream.respond_to?(:tty?) && input_stream.tty?
+        input_stream.raw { |s| reader.call(s) }
+      else
+        reader.call(input_stream)
+      end
+    ensure
+      output_stream.print("#{SHOW_CURSOR}#{CLEAR_SCREEN_SEQUENCE}")
+    end
+
+    loop_res
+  end
+end

data/grmenu/window.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+# ==============================================================================
+# GRmenu::Window - Control del lienzo y color de fondo nativo de la terminal.
+# Permite alterar el color de fondo de toda la ventana usando OSC 11 y ANSI BCE,
+# garantizando la restauración automática al salir o ante errores inesperados.
+# ==============================================================================
+
+class GRmenu
+  module Window
+    @active = false
+    @cleanup_hook_registered = false
+    @current_bg = nil
+    @current_fg = nil
+
+    class << self
+      # Indica si hay un color de ventana personalizado activo actualmente
+      def active?
+        @active == true
+      end
+
+      # Resuelve cualquier especificación de color (nombre, español, hex, array, rgb()) a [R, G, B]
+      def resolve_rgb(color, *rest, **kwargs)
+        target = kwargs[:bg] || color
+        # Formato numérico posicional: color(255, 0, 50)
+        if target.is_a?(Numeric) && rest.length >= 2
+          return [target.to_i.clamp(0, 255), rest[0].to_i.clamp(0, 255), rest[1].to_i.clamp(0, 255)]
+        end
+
+        # Formato array: color([255, 0, 50])
+        if target.is_a?(Array) && target.length >= 3
+          return [target[0].to_i.clamp(0, 255), target[1].to_i.clamp(0, 255), target[2].to_i.clamp(0, 255)]
+        end
+
+        str = target.to_s.strip.downcase
+
+        # Formato funcional rgb(r, g, b)
+        if str =~ /\Argb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)\z/i
+          return [$1.to_i.clamp(0, 255), $2.to_i.clamp(0, 255), $3.to_i.clamp(0, 255)]
+        end
+
+        # Hexadecimal de 6 dígitos (#RRGGBB o RRGGBB)
+        if str =~ /\A#?([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})\z/i
+          return [$1.to_i(16), $2.to_i(16), $3.to_i(16)]
+        end
+
+        # Hexadecimal shorthand de 3 dígitos (#RGB o RGB)
+        if str =~ /\A#?([0-9a-f])([0-9a-f])([0-9a-f])\z/i
+          return [($1 * 2).to_i(16), ($2 * 2).to_i(16), ($3 * 2).to_i(16)]
+        end
+
+        # Normalización y búsqueda por nombre en los catálogos del sistema
+        clean = str.split(":").first.strip
+        return GRmenu::BASE_RGB[clean].dup if GRmenu::BASE_RGB.key?(clean)
+
+        code_val = GRmenu::COLORS[clean] || GRmenu::COLORS.dig(clean, "2") || GRmenu::COLORS.dig(clean, "1")
+        if code_val.to_s =~ /38;2;(\d+);(\d+);(\d+)/
+          return [$1.to_i, $2.to_i, $3.to_i]
+        end
+
+        # Fallback predeterminado a negro
+        [0, 0, 0]
+      end
+
+      # Cambia el color de fondo de toda la ventana de la terminal.
+      # Admite nombres ("red", "azul", "negro"), hex ("#1a1b26"), rgb([r,g,b]), o kwargs.
+      # Se restaura automáticamente sin que el programador tenga que escribir código de limpieza.
+      def color(bg_color = nil, *rest, fg: nil, clear: true, **kwargs)
+        ensure_cleanup_hook
+
+        target_bg = kwargs[:bg] || bg_color
+        return reset if target_bg.nil? || target_bg.to_s.downcase == "reset"
+
+        r, g, b = resolve_rgb(target_bg, *rest, **kwargs)
+        hex = sprintf("#%02x%02x%02x", r, g, b)
+        @current_bg = hex
+
+        # 1. Comando OSC 11 para la ventana nativa (XTerm / GNOME / Kitty / Alacritty / Windows Terminal)
+        # 2. Secuencia ANSI BCE (Background Color Erase) para pintar todas las celdas de la pantalla
+        buffer = String.new("")
+        buffer << "\e]11;#{hex}\a\e]11;#{hex}\e\\"
+        buffer << "\e[48;2;#{r};#{g};#{b}m"
+
+        # Manejo opcional de color de texto (foreground) de la ventana
+        if fg
+          fg_r, fg_g, fg_b = resolve_rgb(fg)
+          fg_hex = sprintf("#%02x%02x%02x", fg_r, fg_g, fg_b)
+          @current_fg = fg_hex
+          buffer << "\e]10;#{fg_hex}\a\e]10;#{fg_hex}\e\\"
+          buffer << "\e[38;2;#{fg_r};#{fg_g};#{fg_b}m"
+        end
+
+        # Limpiar y rellenar pantalla completa con el color activo
+        buffer << "\e[2J\e[H" if clear
+
+        $stdout.print(buffer)
+        $stdout.flush
+        @active = true
+        self
+      end
+
+      alias_method :bg, :color
+      alias_method :background, :color
+      alias_method :set, :color
+
+      # Cambia el color de texto por defecto de la ventana
+      def fg(fg_color)
+        ensure_cleanup_hook
+        fg_r, fg_g, fg_b = resolve_rgb(fg_color)
+        fg_hex = sprintf("#%02x%02x%02x", fg_r, fg_g, fg_b)
+        @current_fg = fg_hex
+        $stdout.print("\e]10;#{fg_hex}\a\e]10;#{fg_hex}\e\\\e[38;2;#{fg_r};#{fg_g};#{fg_b}m")
+        $stdout.flush
+        @active = true
+        self
+      end
+
+      # Restaura inmediatamente el color de fondo y texto original de la terminal
+      def reset
+        return unless @active
+        @active = false
+        @current_bg = nil
+        @current_fg = nil
+
+        # OSC 111 (reset fondo), OSC 110 (reset texto), \e[0m (ANSI reset), y limpia pantalla
+        $stdout.print("\e]111\a\e]111\e\\\e]110\a\e]110\e\\\e[0m\e[2J\e[H")
+        $stdout.flush
+        self
+      end
+
+      # Asigna el título a la barra de la ventana de la terminal
+      def title(window_title)
+        $stdout.print("\e]0;#{window_title}\a")
+        $stdout.flush
+        self
+      end
+
+      # Limpia la pantalla usando el color de fondo actual
+      def clear
+        $stdout.print("\e[2J\e[H")
+        $stdout.flush
+        self
+      end
+
+      private
+
+      # Registra los manejadores de salida (at_exit) y señales del sistema una única vez
+      def ensure_cleanup_hook
+        return if @cleanup_hook_registered
+        @cleanup_hook_registered = true
+
+        # Se ejecuta ante salida normal o errores/excepciones no capturadas de Ruby
+        at_exit do
+          reset if active?
+        end
+
+        # Intercepta interrupción por teclado (Ctrl+C), kill normal y desconexión de terminal
+        [:INT, :TERM, :HUP].each do |sig|
+          old_handler = Signal.trap(sig) do
+            reset if active?
+            if old_handler.respond_to?(:call)
+              old_handler.call
+            elsif old_handler == "DEFAULT"
+              exit(1)
+            else
+              exit(0)
+            end
+          end rescue nil
+        end
+      end
+    end
+  end
+
+  # Punto de entrada público en GRmenu:
+  # Permite invocar como GRmenu.window.bg("red"), GRmenu.window.color("red") o directamente GRmenu.window("red")
+  def self.window(*args, **kwargs)
+    if args.empty? && kwargs.empty?
+      GRmenu::Window
+    else
+      GRmenu::Window.color(*args, **kwargs)
+    end
+  end
+
+  class << self
+    alias_method :window_bg, :window
+  end
+end