shoko 0.1.3 → 0.1.5

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

@@ -0,0 +1,324 @@
+# frozen_string_literal: true
+
+require_relative '../base_component'
+require_relative '../../constants/ui_constants'
+require_relative '../../../../shared/terminal/text_metrics'
+require_relative '../../../../shared/menu_definitions'
+require_relative '../menu_design/frame_renderer'
+require_relative '../menu_design/icon_set'
+require_relative '../menu_design/layout'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module Screens
+          # Settings screen component for configuration management
+          class SettingsScreenComponent < BaseComponent
+            include Adapters::Ui::Constants::Ui
+
+            SETTINGS_ITEMS = Shoko::Shared::MenuDefinitions.settings_items
+
+            ItemCtx = Struct.new(:row, :item, :value_text, :value_color, :index, :selected, :indent, keyword_init: true)
+            CHECKBOX_UNCHECKED = '󰄱'
+            CHECKBOX_CHECKED = '󰱒'
+            WIPE_CACHE_TOGGLE_ACTIONS = {
+              toggle_wipe_cache_cached: :wipe_cache_cached,
+              toggle_wipe_cache_downloads: :wipe_cache_downloads,
+              toggle_wipe_cache_annotations: :wipe_cache_annotations,
+              toggle_wipe_cache_bookmarks: :wipe_cache_bookmarks,
+              toggle_wipe_cache_progress: :wipe_cache_progress,
+              toggle_wipe_cache_config: :wipe_cache_config,
+              toggle_wipe_cache_nuke: :wipe_cache_nuke,
+            }.freeze
+
+            def initialize(catalog_service = nil, dependencies: nil, menu_visual_profile: nil)
+              super()
+              @catalog = catalog_service
+              @dependencies = dependencies
+              @menu_visual_profile = menu_visual_profile
+              @menu_state_reader = nil
+              @config_reader = nil
+            end
+
+            def do_render(surface, bounds)
+              frame = MenuDesign::FrameRenderer.new(surface, bounds)
+              selected = menu_state_reader&.settings_selected || 1
+              frame.render_title(title: 'Settings')
+              frame.render_divider
+              text_values = setting_value_map
+              render_settings(surface, bounds, selected, text_values)
+              frame.render_footer(text: footer_text(selected))
+            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}#{colors[:suffix]}"
+              line = "#{line}#{Shoko::Shared::Terminal::Ansi::RESET}  #{value_color}#{value_text}" if value_text && !value_text.to_s.empty?
+              "#{line}#{Shoko::Shared::Terminal::Ansi::RESET}"
+            end
+
+            def row_colors(selected)
+              if selected
+                {
+                  prefix: "#{Shoko::Shared::Terminal::Ansi::BOLD}#{MENU_SELECTION_BG}",
+                  fg: MENU_SELECTION_TEXT,
+                  suffix: ' ',
+                }
+              else
+                { prefix: '', fg: COLOR_TEXT_PRIMARY, suffix: '' }
+              end
+            end
+
+            def label_text(item)
+              action = item.action
+              if WIPE_CACHE_TOGGLE_ACTIONS.key?(action)
+                checkbox = checkbox_glyph(wipe_cache_checked?(WIPE_CACHE_TOGGLE_ACTIONS[action]))
+                "  #{checkbox}  #{item.label}"
+              else
+                icon = MenuDesign::IconSet.icon_for(item.icon_key)
+                icon.empty? ? item.label : "#{icon}  #{item.label}"
+              end
+            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
+              indent = MenuDesign::Layout.centered_indent(bounds, content_width)
+              content_rows = estimated_content_rows
+              {
+                indent: indent,
+                start_row: MenuDesign::Layout.centered_row(bounds, top: 4, bottom: height - 3, content_rows: content_rows),
+                max_row: height - 3,
+              }
+            end
+
+            def display_width(text)
+              Shoko::Shared::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,
+                open_dictionary_settings: ['Configure & download dictionaries', COLOR_TEXT_DIM],
+                toggle_kitty_images: toggle_kitty_images_value,
+                wipe_cache: ['Use options below', 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)}#{Shoko::Shared::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} #{Shoko::Shared::Terminal::Ansi::RESET}"
+            end
+
+            def button_group_width(buttons)
+              buttons.sum do |_value, label|
+                Shoko::Shared::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
+              config_reader&.view_mode || :single
+            end
+
+            def current_line_spacing
+              config_reader&.line_spacing || :normal
+            end
+
+            def current_page_numbering_mode
+              config_reader&.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
+              config_reader&.show_page_numbers ? 'Enabled' : 'Disabled'
+            end
+
+            def format_highlight_quotes
+              value = config_reader&.highlight_quotes
+              if value.nil? || !!value
+                'On'
+              else
+                'Off'
+              end
+            end
+
+            def toggle_kitty_images_value
+              enabled = config_reader&.kitty_images == true
+              text = enabled ? 'Enabled' : 'Disabled'
+              color = enabled ? COLOR_TEXT_SUCCESS : COLOR_TEXT_DIM
+              [text, color]
+            end
+
+            def menu_state_reader
+              return @menu_state_reader if @menu_state_reader
+
+              @menu_state_reader = @dependencies&.menu_state_reader
+            end
+
+            def checkbox_glyph(selected)
+              if MenuDesign::IconSet.ascii_icons?
+                selected ? '[x]' : '[ ]'
+              else
+                selected ? CHECKBOX_CHECKED : CHECKBOX_UNCHECKED
+              end
+            end
+
+            def wipe_cache_checked?(key)
+              reader = menu_state_reader
+              return false unless reader
+
+              case key
+              when :wipe_cache_cached
+                reader.wipe_cache_cached?
+              when :wipe_cache_downloads
+                reader.wipe_cache_downloads?
+              when :wipe_cache_annotations
+                reader.wipe_cache_annotations?
+              when :wipe_cache_bookmarks
+                reader.wipe_cache_bookmarks?
+              when :wipe_cache_progress
+                reader.wipe_cache_progress?
+              when :wipe_cache_config
+                reader.wipe_cache_config?
+              when :wipe_cache_nuke
+                reader.wipe_cache_nuke?
+              else
+                false
+              end
+            rescue Shoko::Error
+              raise
+            end
+
+            def config_reader
+              return @config_reader if @config_reader
+
+              @config_reader = @dependencies&.config_reader
+            end
+
+            def estimated_content_rows
+              button_actions = %i[toggle_view_mode cycle_line_spacing toggle_page_numbering_mode]
+              base = SETTINGS_ITEMS.sum do |item|
+                button_actions.include?(item.action) ? 3 : 2
+              end
+
+              has_post_toggle = SETTINGS_ITEMS.any? { |item| toggled_action?(item.action) }
+              base += 1 if has_post_toggle
+              base
+            end
+
+            def footer_text(selected_index)
+              item = SETTINGS_ITEMS[selected_index.to_i] || SETTINGS_ITEMS.first
+              item ? item.label : 'Settings'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/ui/components/sidebar/annotations_tab_renderer.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require_relative '../base_component'
+require_relative '../ui/list_helpers'
+require_relative '../ui/text_utils'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module Sidebar
+          # Annotations tab renderer for sidebar
+          class AnnotationsTabRenderer < BaseComponent
+            include Adapters::Ui::Constants::Ui
+
+            ItemCtx = Struct.new(:annotation, :index, :selected_index, :y, keyword_init: true)
+
+            def initialize(dependencies: nil)
+              super()
+              @dependencies = dependencies
+              @reader_state_reader = nil
+            end
+
+            BoundsMetrics = Struct.new(:x, :y, :width, :height, keyword_init: true)
+
+            def do_render(surface, bounds)
+              metrics = metrics_for(bounds)
+              annotations = reader_state_reader&.annotations || []
+              selected_index = reader_state_reader&.sidebar_annotations_selected || 0
+
+              return render_empty_message(surface, bounds, metrics) if annotations.empty?
+
+              render_annotations_list(surface, bounds, metrics, annotations, selected_index)
+            end
+
+            def reader_state_reader
+              return @reader_state_reader if @reader_state_reader
+
+              @reader_state_reader = @dependencies&.reader_state_reader
+            end
+
+            private
+
+            def metrics_for(bounds)
+              BoundsMetrics.new(x: 1, y: 1, width: bounds.width, height: bounds.height)
+            end
+
+            def render_empty_message(surface, bounds, metrics)
+              reset = Shoko::Shared::Terminal::Ansi::RESET
+              bw = metrics.width
+              bh = metrics.height
+              messages = [
+                'No annotations yet',
+                '',
+                'Select text while reading',
+                'to create annotations',
+              ]
+
+              start_y = ((bh - messages.length) / 2) + 1
+              messages.each_with_index do |message, i|
+                msg_width = Shoko::Shared::Terminal::TextMetrics.visible_length(message)
+                x = [(bw - msg_width) / 2, 2].max
+                y = start_y + i
+                surface.write(bounds, y, x, "#{COLOR_TEXT_DIM}#{message}#{reset}")
+              end
+            end
+
+            def render_annotations_list(surface, bounds, metrics, annotations, selected_index)
+              # Each annotation takes 3 lines: text excerpt, note (if any), location
+              item_height = 3
+              bh = metrics.height
+              by = metrics.y
+              visible_items = [bh / item_height, 1].max
+              window_start, window_items = Ui::ListHelpers.slice_visible(annotations, visible_items, selected_index)
+              current_y = by
+
+              window_items.each_with_index do |annotation, offset|
+                idx = window_start + offset
+                break if current_y + item_height > by + bh
+
+                ctx = ItemCtx.new(annotation: annotation, index: idx, selected_index: selected_index, y: current_y)
+                render_annotation_item(surface, bounds, metrics, ctx)
+                current_y += item_height
+              end
+            end
+
+            def render_annotation_item(surface, bounds, metrics, ctx)
+              is_selected = (ctx.index == ctx.selected_index)
+              bx = metrics.x
+              bw = metrics.width
+              max_width = bw - 4
+
+              # Color indicator based on highlight color
+              ann = ctx.annotation
+              color_indicator = get_color_indicator(ann['color'])
+
+              # Text excerpt (first line)
+              text = ann['text'] || ''
+              excerpt = text.tr("\n", ' ').strip
+              excerpt = Ui::TextUtils.truncate_text(excerpt, [max_width - 6, 1].max)
+
+              reset = Shoko::Shared::Terminal::Ansi::RESET
+              if is_selected
+                prefix = "#{COLOR_TEXT_ACCENT}#{SELECTION_POINTER}#{reset}"
+                note_style = COLOR_TEXT_PRIMARY
+                location_style = COLOR_TEXT_SECONDARY
+              else
+                prefix = '  '
+                note_style = COLOR_TEXT_DIM
+                location_style = COLOR_TEXT_DIM
+              end
+              text_line = "#{prefix}#{color_indicator}#{excerpt}#{reset}"
+              row = ctx.y
+              col1 = bx + 1
+              surface.write(bounds, row, col1, text_line)
+
+              # Note (second line, if exists)
+              note = ann['note']
+              if note && !note.strip.empty?
+                note_text = note.tr("\n", ' ').strip
+                note_text = Ui::TextUtils.truncate_text(note_text, [max_width - 5, 1].max)
+
+                note_line = "  #{Shoko::Shared::Terminal::Ansi::ITALIC}#{note_style}✎ #{note_text}#{reset}"
+                surface.write(bounds, row + 1, col1, note_line)
+              end
+
+              # Location (third line)
+              location = format_location(ann)
+              location = Ui::TextUtils.truncate_text(location, [max_width, 1].max)
+              location_line = "  #{location_style}#{location}#{reset}"
+              surface.write(bounds, row + 2, col1, location_line)
+            end
+
+            def get_color_indicator(color)
+              reset = Shoko::Shared::Terminal::Ansi::RESET
+              case color&.downcase
+              when 'yellow', 'highlight'
+                "#{COLOR_TEXT_WARNING}●#{reset} "
+              when 'red'
+                "#{COLOR_TEXT_ERROR}●#{reset} "
+              when 'green'
+                "#{COLOR_TEXT_SUCCESS}●#{reset} "
+              when 'blue'
+                "#{COLOR_TEXT_ACCENT}●#{reset} "
+              else
+                "#{COLOR_TEXT_PRIMARY}●#{reset} "
+              end
+            end
+
+            def format_location(annotation)
+              ch_idx = annotation['chapter_index'] || 0
+              chapter_title = annotation['chapter_title'] || "Ch. #{ch_idx + 1}"
+
+              # Try to calculate percentage if we have position info
+              percentage = ''
+              start_pos = annotation['start_position']
+              ch_len = annotation['chapter_length']
+              if start_pos && ch_len
+                pct = (start_pos.to_f / ch_len * 100).round
+                percentage = " · #{pct}%"
+              end
+
+              "#{chapter_title}#{percentage}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/ui/components/sidebar/bookmarks_tab_renderer.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require_relative '../base_component'
+require_relative '../ui/list_helpers'
+require_relative '../ui/text_utils'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module Sidebar
+          # Bookmarks tab renderer for sidebar
+          class BookmarksTabRenderer < BaseComponent
+            include Adapters::Ui::Constants::Ui
+
+            ItemCtx = Struct.new(:bookmark, :doc, :index, :selected_index, :y, keyword_init: true)
+
+            def initialize(dependencies)
+              super()
+              @dependencies = dependencies
+              @reader_state_reader = nil
+            end
+
+            BoundsMetrics = Struct.new(:x, :y, :width, :height, keyword_init: true)
+
+            def do_render(surface, bounds)
+              metrics = metrics_for(bounds)
+              bookmarks = reader_state_reader&.bookmarks || []
+              doc = resolve_document
+              selected_index = sidebar_state_reader&.sidebar_bookmarks_selected || 0
+
+              return render_empty_message(surface, bounds, metrics) if bookmarks.empty?
+
+              render_bookmarks_list(surface, bounds, metrics, bookmarks, doc, selected_index)
+            end
+
+            def reader_state_reader
+              return @reader_state_reader if @reader_state_reader
+
+              @reader_state_reader = @dependencies&.reader_state_reader
+            end
+
+            def sidebar_state_reader
+              return @sidebar_state_reader if defined?(@sidebar_state_reader)
+
+              @sidebar_state_reader = @dependencies&.sidebar_state_reader
+            end
+
+            private
+
+            def metrics_for(bounds)
+              BoundsMetrics.new(x: 1, y: 1, width: bounds.width, height: bounds.height)
+            end
+
+            def render_empty_message(surface, bounds, metrics)
+              reset = Shoko::Shared::Terminal::Ansi::RESET
+              bw = metrics.width
+              bh = metrics.height
+              messages = [
+                'No bookmarks yet',
+                '',
+                'Press "b" while reading',
+                'to add a bookmark',
+              ]
+
+              start_y = ((bh - messages.length) / 2) + 1
+              messages.each_with_index do |message, i|
+                msg_width = Shoko::Shared::Terminal::TextMetrics.visible_length(message)
+                x = [(bw - msg_width) / 2, 2].max
+                y = start_y + i
+                surface.write(bounds, y, x, "#{COLOR_TEXT_DIM}#{message}#{reset}")
+              end
+            end
+
+            def render_bookmarks_list(surface, bounds, metrics, bookmarks, doc, selected_index)
+              # Each bookmark takes 2 lines: title/chapter + snippet
+              item_height = 2
+              bh = metrics.height
+              by = metrics.y
+              visible_items = [bh / item_height, 1].max
+              visible_start, window_items = Ui::ListHelpers.slice_visible(bookmarks, visible_items, selected_index)
+              current_y = by
+              end_y = by + bh
+
+              window_items.each_with_index do |bookmark, offset|
+                idx = visible_start + offset
+                break if current_y + item_height > end_y
+
+                ctx = ItemCtx.new(bookmark: bookmark, doc: doc, index: idx, selected_index: selected_index, y: current_y)
+                render_bookmark_item(surface, bounds, metrics, ctx)
+                current_y += item_height
+              end
+            end
+
+            def render_bookmark_item(surface, bounds, metrics, ctx)
+              reset = Shoko::Shared::Terminal::Ansi::RESET
+              bx = metrics.x
+              bw = metrics.width
+              row = ctx.y
+              col = bx + 1
+              bm = ctx.bookmark
+              is_selected = (ctx.index == ctx.selected_index)
+              max_width = bw - 4
+
+              # Get chapter info
+              ch_index = bm.chapter_index
+              chapter = ctx.doc&.get_chapter(ch_index)
+              chapter_title = chapter&.title || "Chapter #{ch_index + 1}"
+
+              # First line: Chapter title with bookmark indicator
+              if is_selected
+                prefix = "#{COLOR_TEXT_ACCENT}#{SELECTION_POINTER}#{reset}"
+                title_style = SELECTION_HIGHLIGHT
+                snippet_style = COLOR_TEXT_SECONDARY
+              else
+                prefix = '  '
+                title_style = COLOR_TEXT_PRIMARY
+                snippet_style = COLOR_TEXT_DIM
+              end
+              chapter_text = chapter_title.to_s
+              chapter_text = Ui::TextUtils.truncate_text(chapter_text, [max_width - 6, 1].max)
+
+              # Modern bookmark icon
+              bookmark_icon = "#{COLOR_TEXT_WARNING}◆#{reset}"
+              title_line = "#{prefix}#{bookmark_icon} #{title_style}#{chapter_text}#{reset}"
+              surface.write(bounds, row, col, title_line)
+
+              # Second line: Text snippet and position
+              snippet = bm.text_snippet || ''
+              snippet = Ui::TextUtils.truncate_text(snippet, [max_width - 11, 1].max)
+
+              # Add position indicator if available
+              position_text = bookmark_position_text(bm)
+
+              snippet_line = "    #{snippet_style}\"#{snippet}\"#{position_text}#{reset}"
+              surface.write(bounds, row + 1, col, snippet_line)
+            end
+
+            def bookmark_position_text(bookmark)
+              percentage = if bookmark.is_a?(Hash)
+                             bookmark[:position_percentage] || bookmark['position_percentage']
+                           elsif bookmark.is_a?(Struct) && bookmark.members.include?(:position_percentage)
+                             bookmark[:position_percentage]
+                           end
+              percentage ? " (#{percentage}%)" : ''
+            end
+
+            def resolve_document
+              session_context = @dependencies&.reader_launch_state
+              document = session_context&.preloaded_document
+              return document if document
+
+              @dependencies&.document
+            end
+          end
+        end
+      end
+    end
+  end
+end