shoko 0.1.0

data/lib/shoko/adapters/output/ui/components/screens/library_screen_component.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require_relative 'base_screen_component'
+require_relative '../../constants/ui_constants'
+require_relative '../ui/list_helpers'
+require_relative '../ui/text_utils'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    module Screens
+      # LibraryScreenComponent renders the cached library view with
+      # sortable columns and paging of visible items.
+      class LibraryScreenComponent < BaseScreenComponent
+        include UI::TextUtils
+
+        Item = Struct.new(:title, :authors, :year, :last_accessed, :size_bytes, :open_path, :epub_path,
+                          keyword_init: true)
+        ItemRenderCtx = Struct.new(:row, :width, :book, :index, :selected, keyword_init: true)
+
+        def initialize(state, dependencies)
+          super(dependencies)
+          @state = state
+          @catalog = dependencies.resolve(:catalog_service)
+          @items = nil
+          # Observe selection changes to support scrolling
+          @state.add_observer(self, %i[menu browse_selected])
+        end
+
+        def state_changed(_path, _old, _new)
+          invalidate
+        end
+
+        def do_render(surface, bounds)
+          items = load_items
+          selected = Shoko::Application::Selectors::MenuSelectors.browse_selected(@state) || 0
+
+          render_header(surface, bounds)
+
+          if items.empty?
+            render_empty(surface, bounds)
+          else
+            render_library(surface, bounds, items, selected)
+          end
+
+          render_footer(surface, bounds)
+        end
+
+        private
+
+        def load_items
+          return @items if @items
+
+          entries = Array(@catalog.cached_library_entries)
+          @items = entries.map do |entry|
+            Item.new(
+              title: entry[:title] || entry['title'],
+              authors: entry[:authors] || entry['authors'],
+              year: entry[:year] || entry['year'],
+              last_accessed: entry[:last_accessed] || entry['last_accessed'],
+              size_bytes: entry[:size_bytes] || entry['size_bytes'] || @catalog.size_for(entry[:open_path] || entry['open_path']),
+              open_path: entry[:open_path] || entry['open_path'],
+              epub_path: entry[:epub_path] || entry['epub_path']
+            )
+          end
+        end
+
+        def render_header(surface, bounds)
+          write_header(surface, bounds, "#{Adapters::Output::Ui::Constants::UI::COLOR_TEXT_ACCENT} Library (Cached)#{Terminal::ANSI::RESET}")
+        end
+
+        def render_empty(surface, bounds)
+          write_empty_message(surface, bounds, "#{Adapters::Output::Ui::Constants::UI::COLOR_TEXT_DIM}No cached books yet#{Terminal::ANSI::RESET}")
+        end
+
+        def render_library(surface, bounds, items, selected)
+          list_start = 4
+          width = bounds.width
+          height = bounds.height
+          list_height = height - list_start - 2
+          return if list_height <= 0
+
+          draw_list_header(surface, bounds, width, list_start)
+          list_start += 2
+          list_height -= 2
+
+          items_per_page = list_height
+          start_index, visible_items = UI::ListHelpers.slice_visible(items, items_per_page, selected)
+
+          current_row = list_start
+          visible_items.each_with_index do |book, i|
+            break if current_row >= height - 1
+
+            ctx = ItemRenderCtx.new(row: current_row, width: width, book: book,
+                                    index: start_index + i, selected: selected)
+            render_library_item(surface, bounds, ctx)
+            current_row += 1
+          end
+        end
+
+        def draw_list_header(surface, bounds, width, row)
+          dims = compute_column_widths(width)
+
+          headers = [
+            pad_right('Title', dims[:title_w]),
+            pad_right('Author(s)', dims[:author_w]),
+            pad_right('Year', dims[:year_w]),
+            pad_right('Last accessed', dims[:last_w]),
+            pad_left('Size', dims[:size_w]),
+          ].join(' ' * dims[:gap])
+          header_style = Terminal::ANSI::BOLD + Terminal::ANSI::LIGHT_GREY
+          header_line = header_style + (' ' * dims[:pointer_w]) + headers + Terminal::ANSI::RESET
+          surface.write(bounds, row, 1, header_line)
+          divider = '─' * [width - 2, 1].max
+          divider_line = Adapters::Output::Ui::Constants::UI::COLOR_TEXT_DIM + divider + Terminal::ANSI::RESET
+          surface.write(bounds, row + 1, 1, divider_line)
+        end
+
+        def render_library_item(surface, bounds, ctx)
+          is_selected = (ctx.index == ctx.selected)
+          dims = compute_column_widths(ctx.width)
+
+          pointer = is_selected ? '▸ ' : '  '
+          book = ctx.book
+          t_w = dims[:title_w]
+          a_w = dims[:author_w]
+          y_w = dims[:year_w]
+          l_w = dims[:last_w]
+          s_w = dims[:size_w]
+          title_col = pad_right(truncate_text((book.title || 'Unknown').to_s, t_w), t_w)
+          author_col = pad_right(truncate_text((book.authors || '').to_s, a_w), a_w)
+          year_col = pad_right((book.year || '').to_s[0, 4], y_w)
+          last_col = pad_right(truncate_text(relative_accessed_label(book.last_accessed), l_w), l_w)
+          size_col = pad_left(format_size(book.size_bytes), s_w)
+
+          line = [title_col, author_col, year_col, last_col, size_col].join(' ' * dims[:gap])
+          style = is_selected ? Adapters::Output::Ui::Constants::UI::SELECTION_HIGHLIGHT : Adapters::Output::Ui::Constants::UI::COLOR_TEXT_PRIMARY
+          surface.write(bounds, ctx.row, 1, style + pointer + line + Terminal::ANSI::RESET)
+        end
+
+        def compute_column_widths(total_width)
+          pointer_w = 2
+          gap = 2
+          remaining = total_width - pointer_w - (gap * 4)
+          year_w = 6
+          last_w = 16
+          size_w = 8
+          author_w = [(remaining * 0.25).to_i, 12].max.clamp(12, remaining - 20 - year_w - last_w - size_w)
+          title_w = [remaining - author_w - year_w - last_w - size_w, 20].max
+          { pointer_w: pointer_w, gap: gap, title_w: title_w, author_w: author_w,
+            year_w: year_w, last_w: last_w, size_w: size_w }
+        end
+
+        def format_size(bytes)
+          mb = (bytes.to_f / (1024 * 1024)).round(1)
+          format('%.1f MB', mb)
+        end
+
+        def relative_accessed_label(iso)
+          return '' unless iso
+
+          t = begin
+            Time.parse(iso)
+          rescue StandardError
+            nil
+          end
+          return '' unless t
+
+          seconds = (Time.now - t).to_i
+          minutes = seconds / 60
+          hours = seconds / 3600
+          days = seconds / 86_400
+          weeks = days / 7
+
+          if hours < 1
+            minutes <= 1 ? 'a minute ago' : "#{minutes} minutes ago"
+          elsif days < 1
+            hours == 1 ? 'an hour ago' : "#{hours} hours ago"
+          elsif days == 1
+            'yesterday'
+          elsif days < 7
+            "#{days} days ago"
+          else
+            weeks == 1 ? 'a week ago' : "#{weeks} weeks ago"
+          end
+        end
+
+        def render_footer(surface, bounds)
+          write_footer(surface, bounds,
+                       "#{Adapters::Output::Ui::Constants::UI::COLOR_TEXT_DIM}↑↓ Navigate • Enter Open • ESC Back#{Terminal::ANSI::RESET}")
+        end
+
+        public
+
+        # Public accessor for items to avoid reflective access from MainMenu
+        def items
+          load_items
+        end
+
+        def invalidate_cache!
+          @items = nil
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/ui/components/screens/loading_overlay_component.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative '../base_component'
+require_relative '../../../terminal/text_metrics.rb'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    module Screens
+      # Simple progress/loading overlay rendered as a component.
+      # Draws a single-row progress bar; expects progress in state at [:ui, :loading_progress].
+      class LoadingOverlayComponent < BaseComponent
+        include Adapters::Output::Ui::Constants::UI
+
+        def do_render(surface, bounds)
+          width  = bounds.width
+          height = bounds.height
+
+          state = @dependencies.resolve(:global_state)
+          message = state.get(%i[ui loading_message]).to_s.strip
+
+          message_row = 1
+          bar_row = message.empty? ? 2 : message_row + 2
+          bar_row = [bar_row, height - 1].min
+          bar_col = 2
+          bar_width = (width - (bar_col + 1)).clamp(10, width - bar_col)
+
+          progress = (state.get(%i[ui loading_progress]) || 0.0).to_f
+          progress = progress.clamp(0.0, 1.0)
+          filled = (bar_width * progress).round
+
+          unless message.empty?
+            label = Shoko::Adapters::Output::Terminal::TextMetrics.truncate_to(message, width - 2)
+            label_col = [(width - Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(label)) / 2, 1].max
+            surface.write(bounds, message_row, label_col, "#{COLOR_TEXT_DIM}#{label}#{Terminal::ANSI::RESET}")
+          end
+
+          track = if bar_width.positive?
+                    (Terminal::ANSI::BRIGHT_GREEN + ('━' * filled)) +
+                      (Terminal::ANSI::GRAY + ('━' * (bar_width - filled))) +
+                      Terminal::ANSI::RESET
+                  else
+                    ''
+                  end
+          surface.write(bounds, bar_row, bar_col, track)
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/ui/components/screens/menu_screen_component.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative 'base_screen_component'
+require_relative '../../constants/ui_constants'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    module Screens
+      # Component-based renderer for the main menu screen
+      class MenuScreenComponent < BaseScreenComponent
+        MenuItemCtx = Struct.new(:row, :item, :index, :selected, :indent, keyword_init: true)
+
+        def initialize(state)
+          super()
+          @state = state
+          @state.add_observer(self, %i[menu selected])
+        end
+
+        MENU_ITEMS = [
+          { icon: '', label: 'Browse Library' },
+          { icon: '', label: 'Library' },
+          { icon: '', label: 'Annotations' },
+          { icon: '', label: 'Download Books' },
+          { icon: '', label: 'Settings' },
+          { icon: '', label: 'Quit' },
+        ].freeze
+
+        def do_render(surface, bounds)
+          selected = Shoko::Application::Selectors::MenuSelectors.selected(@state) || 0
+
+          render_menu_items(surface, bounds, selected)
+        end
+
+        private
+
+        def render_menu_items(surface, bounds, selected)
+          metrics = layout_metrics(bounds)
+
+          MENU_ITEMS.each_with_index do |item, index|
+            row = metrics[:start_row] + (index * metrics[:row_height])
+            break if row >= metrics[:max_row]
+
+            ctx = MenuItemCtx.new(row: row, item: item, index: index,
+                                  selected: selected, indent: metrics[:indent])
+            render_menu_item(surface, bounds, ctx)
+          end
+        end
+
+        def render_menu_item(surface, bounds, ctx)
+          item = ctx.item
+          row = ctx.row
+          indent = ctx.indent
+
+          colors = row_colors(ctx.index == ctx.selected)
+
+          surface.write(bounds, row, indent,
+                        formatted_row(item[:icon], item[:label], colors))
+        end
+
+        def layout_metrics(bounds)
+          height = bounds.height
+          width  = bounds.width
+          content_width = menu_content_width
+          indent = ((width - content_width) / 2).floor
+          indent = indent.clamp(2, [width - content_width, 0].max)
+          row_height = 2
+          {
+            indent: indent,
+            row_height: row_height,
+            start_row: [(height - (MENU_ITEMS.size * row_height)) / 2, 4].max,
+            max_row: height - 4,
+          }
+        end
+
+        def formatted_row(icon, label, colors)
+          icon_col = icon.to_s
+          text = label
+          "#{colors[:prefix]}#{colors[:fg]}#{icon_col}  #{text}#{Terminal::ANSI::RESET}"
+        end
+
+        def row_colors(selected)
+          if selected
+            {
+              prefix: Terminal::ANSI::BOLD,
+              fg: Adapters::Output::Ui::Constants::UI::COLOR_TEXT_ACCENT,
+            }
+          else
+            {
+              prefix: '',
+              fg: Adapters::Output::Ui::Constants::UI::COLOR_TEXT_PRIMARY,
+            }
+          end
+        end
+
+        def menu_content_width
+          max_label = MENU_ITEMS.map { |item| display_width(item[:label]) }.max
+          icon_width = MENU_ITEMS.map { |item| display_width(item[:icon]) }.max
+          icon_width + 2 + max_label
+        end
+
+        def display_width(text)
+          Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(text.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/ui/components/screens/settings_screen_component.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require_relative '../base_component'
+require_relative '../../constants/ui_constants'
+require_relative '../../../terminal/text_metrics.rb'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    module Screens
+      # Settings screen component for configuration management
+      class SettingsScreenComponent < BaseComponent
+        include Adapters::Output::Ui::Constants::UI
+
+        SettingsItem = Struct.new(:action, :icon, :label, keyword_init: true)
+
+        SETTINGS_ITEMS = [
+          SettingsItem.new(action: :back_to_menu, icon: '', label: 'Go Back'),
+          SettingsItem.new(action: :toggle_view_mode, icon: '', label: 'View Mode'),
+          SettingsItem.new(action: :cycle_line_spacing, icon: '', label: 'Line Spacing'),
+          SettingsItem.new(action: :toggle_page_numbering_mode, icon: '', label: 'Page Numbering Mode'),
+          SettingsItem.new(action: :toggle_page_numbers, icon: '', label: 'Page Numbers'),
+          SettingsItem.new(action: :toggle_highlight_quotes, icon: '', label: 'Text Highlighting'),
+          SettingsItem.new(action: :toggle_kitty_images, icon: '', label: 'Kitty Images'),
+          SettingsItem.new(action: :wipe_cache, icon: '', label: 'Wipe Cache'),
+        ].freeze
+
+        ItemCtx = Struct.new(:row, :item, :value_text, :value_color, :index, :selected, :indent, keyword_init: true)
+
+        def initialize(state, catalog_service = nil)
+          super()
+          @state = state
+          @catalog = catalog_service
+        end
+
+        def do_render(surface, bounds)
+          surface.write(bounds, 1, 2, "#{COLOR_TEXT_ACCENT}Settings#{Terminal::ANSI::RESET}")
+
+          selected = @state.get(%i[menu settings_selected]) || 1
+          text_values = setting_value_map
+          render_settings(surface, bounds, selected, text_values)
+        end
+
+        def preferred_height(_available_height)
+          :fill
+        end
+
+        private
+
+        def render_settings(surface, bounds, selected, text_values)
+          metrics = layout_metrics(bounds, text_values)
+          indent = metrics[:indent]
+          max_index = SETTINGS_ITEMS.length - 1
+          cursor = selected.clamp(0, max_index)
+          row = metrics[:start_row]
+          insert_toggle_gap = false
+
+          SETTINGS_ITEMS.each_with_index do |item, index|
+            break if row >= metrics[:max_row]
+
+            action = item.action
+            is_selected = cursor == index
+            case action
+            when :toggle_view_mode
+              row = render_button_group(surface, bounds, item, row, indent, is_selected,
+                                        current_view_mode, view_mode_buttons)
+              insert_toggle_gap = false
+            when :cycle_line_spacing
+              row = render_button_group(surface, bounds, item, row, indent, is_selected,
+                                        current_line_spacing, line_spacing_buttons)
+              insert_toggle_gap = false
+            when :toggle_page_numbering_mode
+              row = render_button_group(surface, bounds, item, row, indent, is_selected,
+                                        current_page_numbering_mode, page_numbering_buttons)
+              insert_toggle_gap = true
+            else
+              if toggled_action?(action) && insert_toggle_gap
+                row += 1
+                insert_toggle_gap = false
+              end
+              value_text, value_color = text_values[action]
+              ctx = ItemCtx.new(row: row, item: item, value_text: value_text, value_color: value_color,
+                                index: index, selected: is_selected, indent: indent)
+              row = render_text_item(surface, bounds, ctx)
+            end
+          end
+        end
+
+        def render_text_item(surface, bounds, ctx)
+          text = formatted_row(ctx.item, ctx.value_text, ctx.value_color, ctx.selected)
+          row = ctx.row
+          surface.write(bounds, row, ctx.indent, text)
+          row + 2
+        end
+
+        def formatted_row(item, value_text, value_color, selected)
+          label = label_text(item)
+          colors = row_colors(selected)
+          line = "#{colors[:prefix]}#{colors[:fg]}#{label}"
+          line = "#{line}#{Terminal::ANSI::RESET}  #{value_color}#{value_text}" if value_text && !value_text.to_s.empty?
+          "#{line}#{Terminal::ANSI::RESET}"
+        end
+
+        def row_colors(selected)
+          if selected
+            { prefix: Terminal::ANSI::BOLD, fg: COLOR_TEXT_ACCENT }
+          else
+            { prefix: '', fg: COLOR_TEXT_PRIMARY }
+          end
+        end
+
+        def label_text(item)
+          "#{item.icon}  #{item.label}"
+        end
+
+        def layout_metrics(bounds, text_values)
+          height = bounds.height
+          width = bounds.width
+          label_width = SETTINGS_ITEMS.map { |item| display_width(label_text(item)) }.max || 0
+          text_value_width = text_values.values.map { |value| display_width(Array(value).first) }.max || 0
+          button_width = [
+            button_group_width(view_mode_buttons),
+            button_group_width(line_spacing_buttons),
+            button_group_width(page_numbering_buttons),
+          ].max || 0
+          content_width = label_width + 2 + [text_value_width, button_width].max
+          available = width - content_width
+          indent = (available / 2).floor
+          indent = indent.clamp(2, [available, 0].max)
+          {
+            indent: indent,
+            start_row: [(height - 16) / 2, 4].max,
+            max_row: height - 3,
+          }
+        end
+
+        def display_width(text)
+          Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(text.to_s)
+        end
+
+        def setting_value_map
+          {
+            back_to_menu: ['Return to main menu', COLOR_TEXT_DIM],
+            toggle_page_numbers: toggle_page_number_value,
+            toggle_highlight_quotes: toggle_highlight_value,
+            toggle_kitty_images: toggle_kitty_images_value,
+            wipe_cache: ['Removes EPUB + scan caches', COLOR_TEXT_WARNING],
+          }
+        end
+
+        def render_button_group(surface, bounds, item, row, indent, selected, current_value, buttons)
+          colors = row_colors(selected)
+          label = "#{colors[:prefix]}#{colors[:fg]}#{label_text(item)}#{Terminal::ANSI::RESET}"
+          surface.write(bounds, row, indent, label)
+          buttons_line = button_row(buttons, current_value)
+          next_row = row + 1
+          surface.write(bounds, next_row, indent, buttons_line) if next_row < bounds.height
+          row + 3
+        end
+
+        def button_row(buttons, current_value)
+          buttons.map { |value, label| button_string(label, value == current_value) }.join(' ')
+        end
+
+        def button_string(label, active)
+          bg = active ? BUTTON_BG_ACTIVE : BUTTON_BG_INACTIVE
+          fg = active ? BUTTON_FG_ACTIVE : BUTTON_FG_INACTIVE
+          "#{bg}#{fg} #{label} #{Terminal::ANSI::RESET}"
+        end
+
+        def button_group_width(buttons)
+          buttons.sum do |_value, label|
+            Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(label) + 2
+          end + (buttons.length - 1)
+        end
+
+        def toggled_action?(action)
+          %i[toggle_page_numbers toggle_highlight_quotes toggle_kitty_images].include?(action)
+        end
+
+        def view_mode_buttons
+          [[:split, 'Split'], [:single, 'Single']]
+        end
+
+        def line_spacing_buttons
+          [[:normal, 'Normal'], [:relaxed, 'Relaxed'], [:compact, 'Compact']]
+        end
+
+        def page_numbering_buttons
+          [[:absolute, 'Absolute'], [:dynamic, 'Dynamic']]
+        end
+
+        def current_view_mode
+          @state.get(%i[config view_mode]) || :split
+        end
+
+        def current_line_spacing
+          @state.get(%i[config line_spacing]) || :compact
+        end
+
+        def current_page_numbering_mode
+          @state.get(%i[config page_numbering_mode]) || :dynamic
+        end
+
+        def toggle_page_number_value
+          text = format_page_numbers
+          color = text == 'Enabled' ? COLOR_TEXT_SUCCESS : COLOR_TEXT_WARNING
+          [text, color]
+        end
+
+        def toggle_highlight_value
+          text = format_highlight_quotes
+          color = text == 'On' ? COLOR_TEXT_SUCCESS : COLOR_TEXT_WARNING
+          [text, color]
+        end
+
+        def format_page_numbers
+          @state.get(%i[config show_page_numbers]) ? 'Enabled' : 'Disabled'
+        end
+
+        def format_highlight_quotes
+          value = @state.get(%i[config highlight_quotes])
+          if value.nil? || !!value
+            'On'
+          else
+            'Off'
+          end
+        end
+
+        def toggle_kitty_images_value
+          enabled = !@state.get(%i[config kitty_images]).nil?
+          text = enabled ? 'Enabled' : 'Disabled'
+          color = enabled ? COLOR_TEXT_SUCCESS : COLOR_TEXT_DIM
+          [text, color]
+        end
+      end
+    end
+  end
+end