shoko 0.1.0

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

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require_relative '../base_component'
+require_relative '../ui/list_helpers'
+require_relative '../ui/text_utils'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    module Sidebar
+      # Annotations tab renderer for sidebar
+      class AnnotationsTabRenderer < BaseComponent
+        include Adapters::Output::Ui::Constants::UI
+
+        ItemCtx = Struct.new(:annotation, :index, :selected_index, :y, keyword_init: true)
+
+        def initialize(state)
+          super()
+          @state = state
+        end
+
+        BoundsMetrics = Struct.new(:x, :y, :width, :height, keyword_init: true)
+
+        def do_render(surface, bounds)
+          metrics = metrics_for(bounds)
+          annotations = @state.get(%i[reader annotations]) || []
+          selected_index = @state.get(%i[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
+
+        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 = 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::Adapters::Output::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 = 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 = "  #{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 = 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

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require_relative '../base_component'
+require_relative '../ui/list_helpers'
+require_relative '../ui/text_utils'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    module Sidebar
+      # Bookmarks tab renderer for sidebar
+      class BookmarksTabRenderer < BaseComponent
+        include Adapters::Output::Ui::Constants::UI
+
+        ItemCtx = Struct.new(:bookmark, :doc, :index, :selected_index, :y, keyword_init: true)
+
+        def initialize(state, dependencies)
+          super()
+          @state = state
+          @dependencies = dependencies
+        end
+
+        BoundsMetrics = Struct.new(:x, :y, :width, :height, keyword_init: true)
+
+        def do_render(surface, bounds)
+          metrics = metrics_for(bounds)
+          bookmarks = @state.get(%i[reader bookmarks]) || []
+          doc = resolve_document
+          selected_index = @state.get(%i[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
+
+        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 = 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::Adapters::Output::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 = 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 = ''
+          if bm.respond_to?(:position_percentage)
+            pct = bm.position_percentage
+            position_text = " (#{pct}%)" if pct
+          end
+
+          snippet_line = "    #{snippet_style}\"#{snippet}\"#{position_text}#{reset}"
+          surface.write(bounds, row + 1, col, snippet_line)
+        end
+
+        def resolve_document
+          return @dependencies.resolve(:document) if @dependencies.respond_to?(:resolve)
+
+          nil
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/ui/components/sidebar/tab_header_component.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require_relative '../base_component'
+require_relative '../../../terminal/text_metrics.rb'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    module Sidebar
+      # Modern bottom tab navigation for sidebar
+      class TabHeaderComponent < BaseComponent
+        include Adapters::Output::Ui::Constants::UI
+
+        RenderTarget = Struct.new(:surface, :bounds, keyword_init: true) do
+          def write(row, col, text)
+            surface.write(bounds, row, col, text)
+          end
+        end
+        private_constant :RenderTarget
+
+        TABS = %i[toc annotations bookmarks].freeze
+        TAB_INFO = {
+          toc: { label: 'Contents', icon: '◉', key: 'T' },
+          annotations: { label: 'Notes', icon: '◈', key: 'A' },
+          bookmarks: { label: 'Bookmarks', icon: '◆', key: 'B' },
+        }.freeze
+
+        def initialize(state)
+          super() # Call BaseComponent constructor with no services
+          @state = state
+        end
+
+        def do_render(surface, bounds)
+          target = RenderTarget.new(surface: surface, bounds: bounds)
+          draw_separator(target)
+          render_tab_navigation(target)
+        end
+
+        def tab_for_point(bounds, col, row)
+          return nil unless bounds
+
+          local_row = row.to_i - bounds.y + 1
+          local_col = col.to_i - bounds.x + 1
+          return nil unless local_row.between?(2, 3)
+          return nil unless local_col.between?(1, bounds.width)
+
+          tab_width = (bounds.width - 2) / TABS.length
+          return nil if tab_width <= 0
+
+          offset = local_col - 2
+          return nil if offset.negative?
+
+          max_tabs_width = tab_width * TABS.length
+          return nil if offset >= max_tabs_width
+
+          TABS[offset / tab_width]
+        end
+
+        # Internal context for rendering a single tab button.
+        TabButtonCtx = Struct.new(
+          :tab,
+          :x,
+          :width,
+          :active,
+          :icon,
+          :label,
+          :key,
+          :row_top,
+          :row_bottom,
+          keyword_init: true
+        )
+        private_constant :TabButtonCtx
+
+        private
+
+        def draw_separator(target)
+          width = target.bounds.width
+          line_width = [width - 1, 0].max
+          return if line_width.zero?
+
+          reset = Terminal::ANSI::RESET
+          target.write(1, 1, "#{COLOR_TEXT_DIM}#{'─' * line_width}#{reset}")
+          junction_col = width
+          target.write(1, junction_col, "#{COLOR_TEXT_DIM}┤#{reset}") if junction_col.positive?
+        end
+
+        def render_tab_navigation(target)
+          tab_width = (target.bounds.width - 2) / TABS.length
+          row_top = 2
+          row_bottom = 3
+
+          active_tab = Shoko::Application::Selectors::ReaderSelectors.sidebar_active_tab(@state)
+          TABS.each_with_index do |tab, index|
+            x_pos = 2 + (index * tab_width)
+            active = (active_tab == tab)
+            ctx = build_tab_button_ctx(tab, x_pos, tab_width, active, row_top: row_top, row_bottom: row_bottom)
+            render_tab_button(target, ctx)
+          end
+        end
+
+        def build_tab_button_ctx(tab, x_pos, width, active, row_top:, row_bottom:)
+          info = TAB_INFO.fetch(tab)
+          TabButtonCtx.new(
+            tab: tab,
+            x: x_pos,
+            width: width,
+            active: active,
+            icon: info[:icon],
+            label: info[:label],
+            key: info[:key],
+            row_top: row_top,
+            row_bottom: row_bottom
+          )
+        end
+
+        def render_tab_button(target, ctx)
+          ctx.active ? render_active(target, ctx) : render_inactive(target, ctx)
+        end
+
+        def render_active(target, ctx)
+          reset = Terminal::ANSI::RESET
+          icon_text = "#{COLOR_TEXT_ACCENT}#{ctx.icon}#{reset}"
+          label_text = "#{COLOR_TEXT_PRIMARY}#{ctx.label}#{reset}"
+
+          content = "#{ctx.icon} #{ctx.label}"
+          content_len = Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(content)
+          padding = [(ctx.width - content_len) / 2, 0].max
+          padded_col = ctx.x + padding
+
+          target.write(ctx.row_top, padded_col, icon_text)
+          target.write(ctx.row_top, padded_col + 2, label_text)
+          render_active_indicator(target, ctx, content_len, reset)
+        end
+
+        def render_active_indicator(target, ctx, content_len, reset)
+          indicator_width = [content_len, ctx.width - 2].min
+          return if indicator_width <= 0
+
+          start = ctx.x + [(ctx.width - indicator_width) / 2, 0].max
+          line = "#{COLOR_TEXT_ACCENT}#{'▬' * indicator_width}#{reset}"
+          target.write(ctx.row_bottom, start, line)
+        end
+
+        def render_inactive(target, ctx)
+          reset = Terminal::ANSI::RESET
+          icon_text = "#{COLOR_TEXT_DIM}#{ctx.icon}#{reset}"
+          key_hint = "#{COLOR_TEXT_DIM}[#{ctx.key}]#{reset}"
+
+          icon_padding = [(ctx.width - 1) / 2, 0].max
+          target.write(ctx.row_top, ctx.x + icon_padding, icon_text)
+
+          key_padding = [(ctx.width - 3) / 2, 0].max
+          target.write(ctx.row_bottom, ctx.x + key_padding, key_hint)
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/ui/components/sidebar/toc_tab_renderer.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative '../base_component'
+require_relative 'toc_tab_support'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    module Sidebar
+      # TOC tab renderer for sidebar
+      class TocTabRenderer < BaseComponent
+        include Adapters::Output::Ui::Constants::UI
+
+        NullSurface = Struct.new(:_noop) do
+          def write(*_args); end
+        end
+        private_constant :NullSurface
+
+        def initialize(state, dependencies = nil)
+          super()
+          @state = state
+          @dependencies = dependencies
+          @wrap_cache = {}
+          @cache_document_id = nil
+          @entries_cache_key = nil
+          @entries_cache = nil
+        end
+
+        def do_render(surface, bounds)
+          doc = document
+          refresh_wrap_cache(doc)
+          entries_cache = entries_cache_for(@state, doc, bounds)
+          context = RenderContext.new(surface, bounds, @state, doc, wrap_cache: @wrap_cache,
+                                      entries_cache: entries_cache)
+          @last_bounds_signature = bounds_signature(bounds)
+          @last_scroll_metrics = context.scroll_metrics
+          ComponentOrchestrator.new(context).render
+        end
+
+        def entry_at(bounds, col, row)
+          return nil unless bounds
+
+          local_row = row.to_i - bounds.y + 1
+          local_col = col.to_i - bounds.x + 1
+          return nil unless local_row.between?(1, bounds.height)
+          return nil unless local_col.between?(1, bounds.width)
+
+          doc = document
+          refresh_wrap_cache(doc)
+          entries_cache = entries_cache_for(@state, doc, bounds)
+          context = RenderContext.new(NullSurface.new, bounds, @state, doc, wrap_cache: @wrap_cache,
+                                      entries_cache: entries_cache)
+          context.entries_layout.item_at(local_row)
+        end
+
+        def scroll_metrics(bounds)
+          return nil unless bounds
+
+          signature = bounds_signature(bounds)
+          if @last_scroll_metrics && @last_bounds_signature == signature
+            return @last_scroll_metrics
+          end
+
+          doc = document
+          refresh_wrap_cache(doc)
+          entries_cache = entries_cache_for(@state, doc, bounds)
+          context = RenderContext.new(NullSurface.new, bounds, @state, doc, wrap_cache: @wrap_cache,
+                                      entries_cache: entries_cache)
+          @last_bounds_signature = signature
+          @last_scroll_metrics = context.scroll_metrics
+        end
+
+        private
+
+        def document
+          @document ||= DocumentResolver.new(@dependencies).resolve
+        end
+
+        def bounds_signature(bounds)
+          [bounds.x, bounds.y, bounds.width, bounds.height]
+        end
+
+        def refresh_wrap_cache(doc)
+          doc_id = doc&.object_id
+          return if doc_id == @cache_document_id
+
+          @cache_document_id = doc_id
+          @wrap_cache.clear
+        end
+
+        def entries_cache_for(state, doc, bounds)
+          key = entries_cache_key(state, doc)
+          return @entries_cache if key == @entries_cache_key && @entries_cache
+
+          context = RenderContext.new(NullSurface.new, bounds, state, doc, wrap_cache: @wrap_cache)
+          entries = EntriesCalculator.new(context).calculate
+          @entries_cache = EntriesCache.new(full: entries.full, visible: entries.visible,
+                                            visible_indices: entries.visible_indices)
+          @entries_cache_key = key
+          @entries_cache
+        end
+
+        def entries_cache_key(state, doc)
+          filter_active = state.get(%i[reader sidebar_toc_filter_active])
+          filter_text = state.get(%i[reader sidebar_toc_filter]) || ''
+          collapsed = Array(state.get(%i[reader sidebar_toc_collapsed])).map(&:to_i).sort
+          [doc&.object_id, filter_active ? 1 : 0, filter_text.to_s, collapsed]
+        end
+      end
+    end
+  end
+end