shoko 0.1.3 → 0.1.5

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

@@ -1,217 +0,0 @@
-# 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

@@ -1,88 +0,0 @@
-# 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

@@ -1,224 +0,0 @@
-# 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

@@ -1,32 +0,0 @@
-# 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

@@ -1,33 +0,0 @@
-# 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

@@ -1,79 +0,0 @@
-# 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