shoko 0.1.0

data/lib/shoko/adapters/output/ui/components/sidebar_panel_component.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require_relative 'base_component'
+require_relative 'surface'
+require_relative 'rect'
+require_relative 'sidebar/tab_header_component'
+require_relative 'sidebar/toc_tab_renderer'
+require_relative 'sidebar/annotations_tab_renderer'
+require_relative 'sidebar/bookmarks_tab_renderer'
+require_relative 'ui/text_utils'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    # Collapsible sidebar panel with tabbed interface for TOC, Annotations, and Bookmarks
+    class SidebarPanelComponent < BaseComponent
+      include Adapters::Output::Ui::Constants::UI
+
+      TABS = %i[toc annotations bookmarks].freeze
+      TAB_TITLES = { toc: 'Contents', annotations: 'Annotations', bookmarks: 'Bookmarks' }.freeze
+      TAB_KEYS = { toc: 'T', annotations: 'A', bookmarks: 'B' }.freeze
+      HELP_TEXTS = {
+        toc: '↑↓ Navigate • ⏎ Jump • / Filter',
+        annotations: '↑↓ Navigate • ⏎ Jump • e Edit • d Delete',
+        bookmarks: '↑↓ Navigate • ⏎ Jump • d Delete',
+      }.freeze
+      DEFAULT_WIDTH_PERCENT = 30
+      MIN_WIDTH = 24
+      HEADER_HEIGHT = 2
+      TAB_HEIGHT = 3
+      HELP_HEIGHT = 1
+
+      def initialize(state, dependencies)
+        super() # Call BaseComponent constructor
+        @state = state
+        @dependencies = dependencies
+        @tab_header = Sidebar::TabHeaderComponent.new(state)
+        @toc_renderer = Sidebar::TocTabRenderer.new(state, dependencies)
+        @annotations_renderer = Sidebar::AnnotationsTabRenderer.new(state)
+        @bookmarks_renderer = Sidebar::BookmarksTabRenderer.new(state, dependencies)
+
+        # Observe sidebar state changes
+        state.add_observer(self,
+                           %i[reader sidebar_visible],
+                           %i[reader sidebar_active_tab],
+                           %i[reader sidebar_toc_selected],
+                           %i[reader sidebar_toc_collapsed],
+                           %i[reader sidebar_annotations_selected],
+                           %i[reader sidebar_bookmarks_selected])
+      end
+
+      def preferred_width(total_width)
+        state = @state
+        return :hidden unless state.get(%i[reader sidebar_visible])
+
+        # Calculate width as percentage of total, with minimum
+        preferred = (total_width * DEFAULT_WIDTH_PERCENT / 100.0).round
+        [preferred, MIN_WIDTH].max
+      end
+
+      def do_render(surface, bounds)
+        state = @state
+        bw = bounds.width
+        bh = bounds.height
+        return unless state.get(%i[reader sidebar_visible]) && bw >= MIN_WIDTH
+
+        # Cache frequently-used bounds values
+        bx = bounds.x
+        by = bounds.y
+        # bw, bh already cached above
+
+        # Draw modern border
+        draw_border(surface, bounds)
+
+        content_bounds = content_bounds_for(bounds)
+        return unless content_bounds
+
+        # Render minimal header with title only
+        header_bounds = Rect.new(x: bx, y: by, width: bw,
+                                 height: HEADER_HEIGHT)
+        render_header(surface, header_bounds)
+
+        # Render active tab content
+        render_active_tab(surface, content_bounds)
+
+        # Render help text
+        help_bounds = Rect.new(
+          x: bx,
+          y: content_bounds.y + content_bounds.height,
+          width: bw,
+          height: HELP_HEIGHT
+        )
+        render_help(surface, help_bounds)
+
+        # Render tab navigation at bottom
+        tab_bounds = Rect.new(
+          x: bx,
+          y: by + bh - TAB_HEIGHT,
+          width: bw,
+          height: TAB_HEIGHT
+        )
+        @tab_header.render(surface, tab_bounds)
+      end
+
+      def sidebar_bounds_for(total_width, total_height)
+        return nil unless @state.get(%i[reader sidebar_visible])
+
+        width = preferred_width(total_width)
+        return nil unless width.is_a?(Integer) && width.positive?
+
+        width = [width, total_width].min
+        Rect.new(x: 1, y: 1, width: width, height: total_height)
+      end
+
+      def tab_for_point(col, row, sidebar_bounds)
+        return nil unless sidebar_bounds
+
+        tab_bounds = tab_bounds_for(sidebar_bounds)
+        @tab_header.tab_for_point(tab_bounds, col, row)
+      end
+
+      def toc_entry_at(col, row, sidebar_bounds)
+        return nil unless sidebar_bounds
+
+        active_tab = Shoko::Application::Selectors::ReaderSelectors.sidebar_active_tab(@state)
+        return nil unless active_tab == :toc
+
+        content_bounds = content_bounds_for(sidebar_bounds)
+        return nil unless content_bounds
+
+        @toc_renderer.entry_at(content_bounds, col, row)
+      end
+
+      def toc_scroll_metrics(sidebar_bounds)
+        return nil unless sidebar_bounds
+
+        active_tab = Shoko::Application::Selectors::ReaderSelectors.sidebar_active_tab(@state)
+        return nil unless active_tab == :toc
+
+        content_bounds = content_bounds_for(sidebar_bounds)
+        return nil unless content_bounds
+
+        @toc_renderer.scroll_metrics(content_bounds)
+      end
+
+      private
+
+      def draw_border(surface, bounds)
+        # Draw modern vertical border on the right edge
+        h = bounds.height
+        w = bounds.width
+        reset = Terminal::ANSI::RESET
+        dim = COLOR_TEXT_DIM
+        (1..h).each do |y|
+          surface.write(bounds, y, w, "#{dim}│#{reset}")
+        end
+      end
+
+      def render_header(surface, bounds)
+        state = @state
+
+        # Simple clean title
+        active_tab = Shoko::Application::Selectors::ReaderSelectors.sidebar_active_tab(state)
+        title = TAB_TITLES[active_tab] || 'Sidebar'
+        reset = Terminal::ANSI::RESET
+        surface.write(bounds, 1, 2, "#{SELECTION_HIGHLIGHT}#{title}#{reset}")
+
+        # Close indicator
+        w = bounds.width
+        key = TAB_KEYS[active_tab] || 'T'
+        close_text = "#{COLOR_TEXT_DIM}[#{key}]#{reset}"
+        surface.write(bounds, 1, w - 5, close_text)
+      end
+
+      def render_help(surface, bounds)
+        state = @state
+
+        active_tab = Shoko::Application::Selectors::ReaderSelectors.sidebar_active_tab(state)
+        reset = Terminal::ANSI::RESET
+        width = bounds.width
+        hint = HELP_TEXTS[active_tab]
+        return unless hint
+
+        max_hint_width = [width - 4, 1].max
+        clipped_hint = UI::TextUtils.truncate_text(hint, max_hint_width)
+        surface.write(bounds, 1, 2, "#{COLOR_TEXT_DIM}#{clipped_hint}#{reset}")
+      end
+
+      def render_active_tab(surface, bounds)
+        active_tab = Shoko::Application::Selectors::ReaderSelectors.sidebar_active_tab(@state)
+        renderer = { toc: @toc_renderer, annotations: @annotations_renderer,
+                     bookmarks: @bookmarks_renderer }[active_tab]
+        renderer&.render(surface, bounds)
+      end
+
+      def content_bounds_for(bounds)
+        content_height = bounds.height - HEADER_HEIGHT - TAB_HEIGHT - HELP_HEIGHT
+        return nil if content_height <= 0
+
+        Rect.new(
+          x: bounds.x,
+          y: bounds.y + HEADER_HEIGHT,
+          width: bounds.width,
+          height: content_height
+        )
+      end
+
+      def tab_bounds_for(sidebar_bounds)
+        Rect.new(
+          x: sidebar_bounds.x,
+          y: sidebar_bounds.y + sidebar_bounds.height - TAB_HEIGHT,
+          width: sidebar_bounds.width,
+          height: TAB_HEIGHT
+        )
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/ui/components/surface.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative '../../terminal/terminal.rb'
+require_relative '../../terminal/text_metrics.rb'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    # Terminal wrapper that applies bounds and basic clipping
+    class Surface
+      def initialize(output = Terminal)
+        @output = output
+        @style_stack = []
+      end
+
+      # Write text at local (row, col) relative to bounds
+      # Applies basic clipping to the provided bounds
+      def write(bounds, row, col, text)
+        b_height = bounds.height
+        b_width  = bounds.width
+        return if b_height <= 0 || b_width <= 0
+
+        b_y = bounds.y
+        b_x = bounds.x
+        b_right = bounds.right
+        b_bottom = bounds.bottom
+
+        abs_row = b_y + row - 1
+        abs_col = b_x + col - 1
+
+        return if abs_row < b_y || abs_row > b_bottom
+        return if abs_col < b_x || abs_col > b_right
+
+        max_width = b_right - abs_col + 1
+        clipped = Shoko::Adapters::Output::Terminal::TextMetrics.truncate_to(
+          text.to_s,
+          max_width,
+          start_column: [abs_col - 1, 0].max
+        )
+        clipped = apply_dim(clipped) if dimmed?
+        return if clipped.nil? || clipped.empty?
+
+        @output.write(abs_row, abs_col, clipped)
+      end
+
+      # Write using absolute terminal coordinates while still clipping to bounds.
+      #
+      # This is intended for overlay components that operate in absolute
+      # coordinates (e.g., mouse hit regions, selection geometry).
+      def write_abs(bounds, abs_row, abs_col, text)
+        local_row = abs_row.to_i - bounds.y + 1
+        local_col = abs_col.to_i - bounds.x + 1
+        write(bounds, local_row, local_col, text)
+      end
+
+      # Convenience to fill an area with a character
+      def fill(bounds, char)
+        w = bounds.width
+        h = bounds.height
+        line = char.to_s * w
+        (0...h).each do |r|
+          write(bounds, r + 1, 1, line)
+        end
+      end
+
+      def with_dimmed
+        @style_stack << :dim
+        yield
+      ensure
+        @style_stack.pop
+      end
+
+      private
+
+      def dimmed?
+        @style_stack.include?(:dim)
+      end
+
+      def apply_dim(text)
+        dim = Terminal::ANSI::DIM
+        reset = Terminal::ANSI::RESET
+        return text if text.empty?
+
+        transformed = text.gsub(reset, "#{reset}#{dim}")
+        "#{dim}#{transformed}#{reset}"
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/ui/components/tooltip_overlay_component.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require_relative 'base_component'
+require_relative '../../terminal/text_metrics.rb'
+require_relative '../../../../core/models/selection_anchor.rb'
+module Shoko
+  module Adapters::Output::Ui::Components
+    # Unified overlay component that handles all tooltip/popup rendering
+    # including text selection highlighting, popup menus, and annotations.
+    #
+    # This component consolidates the scattered rendering logic and provides
+    # consistent coordinate handling for the fragile tooltip system.
+    class TooltipOverlayComponent < BaseComponent
+      include Adapters::Output::Ui::Constants::UI
+
+      def initialize(controller, coordinate_service:)
+        super()
+        @controller = controller
+        @coordinate_service = coordinate_service
+        @last_selection_segments = []
+        @geometry_cache_key = nil
+        @geometry_cache = nil
+      end
+
+      # Render all overlay elements: highlights, popups, tooltips
+      def do_render(surface, bounds)
+        # Render in specific order to ensure proper layering
+        clear_previous_selection_artifacts(surface, bounds)
+        render_saved_annotations(surface, bounds)
+        render_active_selection(surface, bounds)
+        render_popup_menu(surface, bounds)
+        render_annotations_overlay(surface, bounds)
+        render_annotation_editor_overlay(surface, bounds)
+        render_toast_notification(surface, bounds)
+      end
+
+      private
+
+      def render_saved_annotations(surface, bounds)
+        state = @controller.state
+        anns = state.get(%i[reader annotations])
+        return unless anns
+
+        current_ch = state.get(%i[reader current_chapter])
+        chapter_annotations = anns.select { |annotation| annotation['chapter_index'] == current_ch }
+        chapter_annotations.each do |annotation|
+          render_text_highlight(surface, bounds, annotation['range'], HIGHLIGHT_BG_SAVED)
+        end
+      end
+
+      def render_active_selection(surface, bounds)
+        # Render current selection highlight
+        selection_range = @controller.state.get(%i[reader selection])
+
+        unless selection_range
+          # No active selection; keep any previously rendered segments for one clear pass
+          @pending_clear = true if @last_selection_segments.any?
+          return
+        end
+
+        # Reset tracking for this frame
+        @last_selection_segments.clear
+        render_text_highlight(surface, bounds, selection_range, HIGHLIGHT_BG_ACTIVE)
+      end
+
+      def render_popup_menu(surface, bounds)
+        popup_menu = @controller.state.get(%i[reader popup_menu])
+        return unless popup_menu&.visible
+
+        # Unified component rendering path
+        popup_menu.render(surface, bounds)
+      end
+
+      def render_annotations_overlay(surface, bounds)
+        overlay = @controller.state.get(%i[reader annotations_overlay])
+        return unless overlay.respond_to?(:visible?) && overlay.visible?
+
+        overlay.render(surface, bounds)
+      end
+
+      def render_annotation_editor_overlay(surface, bounds)
+        overlay = @controller.state.get(%i[reader annotation_editor_overlay])
+        return unless overlay.respond_to?(:visible?) && overlay.visible?
+
+        overlay.render(surface, bounds)
+      end
+
+      def render_toast_notification(surface, bounds)
+        message = Application::Selectors::ReaderSelectors.message(@controller.state)
+        message = message.to_s
+        return if message.empty?
+
+        ui = Adapters::Output::Ui::Constants::UI
+        width = bounds.width
+        max_width = [width - 2, 1].max
+        label_max = [max_width - 1, 1].max
+        label = " #{message} "
+        label = Shoko::Adapters::Output::Terminal::TextMetrics.truncate_to(label, label_max)
+        content = "|#{label}"
+        col = [width - Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(content) + 1, 1].max
+
+        toast = "#{Terminal::ANSI::RESET}#{ui::TOAST_ACCENT}|#{ui::TOAST_FG}#{label}#{Terminal::ANSI::RESET}"
+        surface.write(bounds, 1, col, toast)
+      end
+
+      def render_text_highlight(surface, bounds, range, color)
+        rendered_lines = Application::Selectors::ReaderSelectors.rendered_lines(@controller.state)
+        return if rendered_lines.empty?
+
+        normalized_range = @coordinate_service.normalize_selection_range(range, rendered_lines)
+        return unless normalized_range
+
+        start_anchor = Shoko::Core::Models::SelectionAnchor.from(normalized_range[:start])
+        end_anchor = Shoko::Core::Models::SelectionAnchor.from(normalized_range[:end])
+        return unless start_anchor && end_anchor
+
+        cache = geometry_cache_for(rendered_lines)
+        ordered = cache[:ordered]
+        index_by_key = cache[:index_by_key]
+        return if ordered.empty?
+
+        start_idx = index_by_key[start_anchor.geometry_key]
+        end_idx = index_by_key[end_anchor.geometry_key]
+        return unless start_idx && end_idx
+
+        ordered[start_idx..end_idx].each do |geometry|
+          start_cell = geometry.key == start_anchor.geometry_key ? start_anchor.cell_index : 0
+          end_cell = geometry.key == end_anchor.geometry_key ? end_anchor.cell_index : geometry.cells.length
+          render_geometry_highlight(surface, bounds, geometry, start_cell, end_cell, color)
+        end
+      end
+
+      def render_geometry_highlight(surface, bounds, geometry, start_cell, end_cell, color)
+        return if end_cell <= start_cell
+
+        start_char = char_index_for_cell(geometry, start_cell)
+        end_char = char_index_for_cell(geometry, end_cell)
+        return if end_char <= start_char
+
+        segment_text = geometry.plain_text[start_char...end_char]
+        return if segment_text.nil? || segment_text.empty?
+
+        highlight = "#{color}#{COLOR_TEXT_PRIMARY}#{segment_text}#{Terminal::ANSI::RESET}"
+        start_col = screen_column_for_cell(geometry, start_cell)
+        surface.write_abs(bounds, geometry.row, start_col, highlight)
+        record_selection_segment(geometry.row, start_col, segment_text)
+      end
+
+      def screen_column_for_cell(geometry, cell_index)
+        if cell_index <= 0
+          geometry.column_origin
+        elsif cell_index >= geometry.cells.length
+          geometry.column_origin + geometry.visible_width
+        else
+          geometry.column_origin + geometry.cells[cell_index].screen_x
+        end
+      end
+
+      def char_index_for_cell(geometry, cell_index)
+        cells = geometry.cells
+        return 0 if cells.empty?
+
+        if cell_index <= 0
+          0
+        elsif cell_index >= cells.length
+          geometry.plain_text.length
+        else
+          cells[cell_index].char_start
+        end
+      end
+
+      def geometry_cache_for(rendered_lines)
+        cache_key = rendered_lines.object_id
+        return @geometry_cache if @geometry_cache_key == cache_key && @geometry_cache
+
+        geometry_by_key = {}
+        rendered_lines.each do |key, info|
+          geometry = info[:geometry]
+          next unless geometry
+
+          geometry_by_key[key] = geometry
+        end
+        ordered = order_geometry(geometry_by_key.values)
+        index_by_key = {}
+        ordered.each_with_index { |geo, idx| index_by_key[geo.key] = idx }
+
+        @geometry_cache_key = cache_key
+        @geometry_cache = { ordered: ordered, index_by_key: index_by_key }
+      end
+
+      def order_geometry(geometries)
+        geometries.sort_by do |geo|
+          [geo.page_id || 0, geo.line_offset || 0, geo.column_id || 0, geo.row || 0, geo.column_origin || 0]
+        end
+      end
+
+      def record_selection_segment(row, col, text)
+        @last_selection_segments << {
+          row: row,
+          col: col,
+          text: text,
+        }
+      end
+
+      # If selection was present on previous frame but not this one, explicitly repaint
+      # the previously highlighted character cells to clear any lingering background color
+      def clear_previous_selection_artifacts(surface, bounds)
+        return unless @pending_clear && @last_selection_segments.any?
+
+        @last_selection_segments.each do |seg|
+          safe_text = seg[:text] || ''
+          reset = Terminal::ANSI::RESET
+          repaint = "#{reset}#{COLOR_TEXT_PRIMARY}#{safe_text}#{reset}"
+          surface.write_abs(bounds, seg[:row], seg[:col], repaint)
+        end
+
+        @last_selection_segments.clear
+        @pending_clear = false
+      end
+
+      # Column bounds and overlap checks are now handled by CoordinateService
+    end
+  end
+end

data/lib/shoko/adapters/output/ui/components/ui/box_drawer.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../../../terminal/text_metrics.rb'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    module UI
+      # Helper for drawing bordered boxes with optional labels.
+      module BoxDrawer
+        def draw_box(surface, bounds, row, col, height, width, label: nil)
+          # Top border
+          hline = '─' * (width - 2)
+          surface.write(bounds, row, col, "╭#{hline}╮")
+          if label && width > 4
+            label_text = "[ #{label} ]"
+            available = width - 3
+            clipped = Shoko::Adapters::Output::Terminal::TextMetrics.truncate_to(label_text, available, start_column: bounds.x + col)
+            surface.write(bounds, row, col + 2, clipped) unless clipped.empty?
+          end
+          # Sides
+          (1...(height - 1)).each do |index|
+            y_pos = row + index
+            surface.write(bounds, y_pos, col, '│')
+            surface.write(bounds, y_pos, col + width - 1, '│')
+          end
+          # Bottom
+          surface.write(bounds, row + height - 1, col, "╰#{hline}╯")
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/ui/components/ui/list_helpers.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    module UI
+      # Shared helpers for list-based components to keep pagination logic consistent.
+      module ListHelpers
+        module_function
+
+        def visible_window(total_items, per_page, selected)
+          return [0, 0] if total_items <= 0 || per_page <= 0
+
+          clamped_selected = selected.clamp(0, total_items - 1)
+          start_index = if clamped_selected < per_page
+                          0
+                        else
+                          clamped_selected - per_page + 1
+                        end
+          max_start = [total_items - per_page, 0].max
+          start_index = [start_index, max_start].min
+          end_index = [start_index + per_page - 1, total_items - 1].min
+          [start_index, end_index]
+        end
+
+        def slice_visible(items, per_page, selected)
+          total = items.length
+          start_index, end_index = visible_window(total, per_page, selected)
+          [start_index, items[start_index..end_index] || []]
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/ui/components/ui/overlay_layout.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative '../../../terminal/terminal.rb'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    module UI
+      # Calculates overlay dimensions based on viewport bounds.
+      class OverlaySizing
+        def initialize(width_ratio:, width_padding:, min_width:, height_ratio:, height_padding:, min_height:)
+          @width_ratio = width_ratio
+          @width_padding = width_padding
+          @min_width = min_width
+          @height_ratio = height_ratio
+          @height_padding = height_padding
+          @min_height = min_height
+        end
+
+        def width_for(total_width)
+          clamp_dimension(total_width, ratio: @width_ratio, padding: @width_padding, min: @min_width)
+        end
+
+        def height_for(total_height)
+          clamp_dimension(total_height, ratio: @height_ratio, padding: @height_padding, min: @min_height)
+        end
+
+        private
+
+        def clamp_dimension(total, ratio:, padding:, min:)
+          base = [(total * ratio).floor, total - padding].min
+          upper = total - padding
+          lower = [min, upper].min
+          base.clamp(lower, upper)
+        end
+      end
+
+      # Provides centered overlay placement and frame geometry helpers.
+      class OverlayLayout
+        attr_reader :origin_x, :origin_y, :width, :height
+
+        def initialize(origin_x:, origin_y:, width:, height:)
+          @origin_x = origin_x
+          @origin_y = origin_y
+          @width = width
+          @height = height
+        end
+
+        def self.centered(bounds, width:, height:)
+          origin_x = [(bounds.width - width) / 2, 1].max + 1
+          origin_y = [(bounds.height - height) / 2, 1].max + 1
+          new(origin_x: origin_x, origin_y: origin_y, width: width, height: height)
+        end
+
+        def inner_x
+          origin_x + 1
+        end
+
+        def inner_y
+          origin_y + 1
+        end
+
+        def inner_width
+          width - 2
+        end
+
+        def inner_height
+          height - 2
+        end
+
+        def fill_background(surface, bounds, background:)
+          reset = Terminal::ANSI::RESET
+          height.times do |offset|
+            surface.write(bounds, origin_y + offset, origin_x, "#{background}#{' ' * width}#{reset}")
+          end
+        end
+      end
+    end
+  end
+end