shoko 0.1.0

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    # Standard interface contract for all UI components.
+    # Defines the required methods and behavior for component lifecycle.
+    module ComponentInterface
+      # Called once when component is first rendered
+      def mount
+        raise NotImplementedError, 'Components must implement #mount'
+      end
+
+      # Called when component is removed from the UI
+      def unmount
+        raise NotImplementedError, 'Components must implement #unmount'
+      end
+
+      # Render this component into the given surface within bounds
+      # @param surface [Surface] Terminal surface wrapper
+      # @param bounds [Rect] Local bounds for this component
+      def render(surface, bounds)
+        raise NotImplementedError, 'Components must implement #render'
+      end
+
+      # Handle input key for this component
+      # @param key [String] Input key
+      # @return [Symbol] :handled or :pass_through
+      def handle_input(_key)
+        :pass_through
+      end
+
+      # Component height calculation for layout
+      # @param available_height [Integer] Total height available from parent
+      # @return [Integer, Symbol] Height requirement
+      def preferred_height(_available_height)
+        :flexible
+      end
+
+      # Component width calculation for layout
+      # @param available_width [Integer] Total width available from parent
+      # @return [Integer, Symbol] Width requirement
+      def preferred_width(_available_width)
+        :flexible
+      end
+
+      # Check if component needs re-rendering
+      # @return [Boolean]
+      def needs_update?
+        true
+      end
+
+      # Mark component as updated (no longer needs re-render)
+      def mark_updated
+        # Default implementation - override if needed
+      end
+
+      # Validate that a class properly implements the interface
+      def self.validate_implementation!(klass)
+        required_methods = %i[mount unmount render]
+        missing = required_methods.reject { |method| klass.method_defined?(method) }
+
+        return if missing.empty?
+
+        raise ArgumentError, "#{klass} missing required methods: #{missing.join(', ')}"
+      end
+
+      # Helper method to ensure a component follows the interface
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # Class-level helpers mixed into components implementing the interface.
+      module ClassMethods
+        def validate_interface!
+          ComponentInterface.validate_implementation!(self)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative 'base_component'
+require_relative 'surface'
+require_relative 'reading/view_renderer_factory'
+require_relative 'reading/help_renderer'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    # ContentComponent coordinates the main reading content area.
+    # It switches between help and the active view renderer based on state.
+    class ContentComponent < BaseComponent
+      def initialize(controller)
+        super(controller&.dependencies) # Initialize BaseComponent with dependencies
+        @controller = controller
+        @view_renderer = nil
+        deps = controller&.dependencies
+        @help_renderer = Reading::HelpRenderer.new(deps)
+
+        state = @controller.state
+        # Observe core fields that affect content rendering via StateStore paths
+        state.add_observer(self, %i[reader current_chapter], %i[reader left_page], %i[reader right_page],
+                           %i[reader single_page], %i[reader current_page_index], %i[reader mode], %i[config view_mode])
+      end
+
+      # Observer callback triggered by ObserverStateStore
+      def state_changed(path, old_value, new_value)
+        # Reset renderer for mode changes or view mode changes
+        @view_renderer = nil if [%i[reader mode], %i[config view_mode]].include?(path)
+
+        # Call parent invalidate to properly trigger re-rendering
+        super
+      end
+
+      # Fill remaining space after fixed components
+      def preferred_height(_available_height)
+        :fill
+      end
+
+      def do_render(surface, bounds)
+        state = @controller.state
+
+        case state.get(%i[reader mode])
+        when :help
+          @help_renderer.render(surface, bounds)
+        else
+          view_renderer.render(surface, bounds)
+        end
+      end
+
+      private
+
+      def view_renderer
+        return @view_renderer if @view_renderer
+
+        @view_renderer = Reading::ViewRendererFactory.create(@controller.state,
+                                                             @controller.dependencies)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,191 @@
+# 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
+    # Enhanced popup menu that uses the coordinate service for consistent positioning
+    # and integrates with the clipboard service for reliable copy functionality.
+    class EnhancedPopupMenu < BaseComponent
+      include Adapters::Output::Ui::Constants::UI
+
+      attr_reader :visible, :selected_index, :x, :y, :width, :height
+
+      def initialize(selection_range, available_actions = nil, coordinate_service = nil,
+                     clipboard_service = nil, rendered_lines = nil)
+        super()
+        @coordinate_service = coordinate_service
+        @clipboard_service = clipboard_service
+        @rendered_lines = rendered_lines || {}
+
+        @selection_range = @coordinate_service.normalize_selection_range(selection_range, @rendered_lines)
+
+        unless @selection_range
+          @visible = false
+          return
+        end
+
+        @available_actions = available_actions || default_actions
+        @items = @available_actions.map { |action| action[:label] }
+        @selected_index = 0
+        @visible = true
+        @width = calculate_width
+        @height = @items.length
+
+        # Ensure we have at least one item before proceeding
+        unless @items.any?
+          @visible = false
+          return
+        end
+
+        # Calculate optimal position using coordinate service
+        position = popup_anchor_position(@selection_range[:end])
+        @x = position[:x]
+        @y = position[:y]
+      end
+
+      def do_render(surface, bounds)
+        return unless @visible
+
+        @items.each_with_index do |item, i|
+          render_menu_item(surface, bounds, item, i)
+        end
+      end
+
+      def handle_key(key)
+        return nil unless @visible
+
+        if Adapters::Input::KeyDefinitions::NAVIGATION[:up].include?(key)
+          move_selection(-1)
+          { type: :selection_change }
+        elsif Adapters::Input::KeyDefinitions::NAVIGATION[:down].include?(key)
+          move_selection(1)
+          { type: :selection_change }
+        elsif Adapters::Input::KeyDefinitions::ACTIONS[:confirm].include?(key)
+          execute_selected_action
+        elsif Adapters::Input::KeyDefinitions::ACTIONS[:cancel].include?(key)
+          { type: :cancel }
+        end
+      end
+
+      # Align with ComponentInterface naming; delegate to existing logic
+      def handle_input(key)
+        handle_key(key)
+      end
+
+      def handle_click(click_x, click_y)
+        return nil unless @visible && contains?(click_x, click_y)
+
+        clicked_index = click_y - @y
+        return nil unless clicked_index >= 0 && clicked_index < @items.length
+
+        @selected_index = clicked_index
+        execute_selected_action
+      end
+
+      def hide
+        @visible = false
+      end
+
+      def contains?(col, row)
+        bounds = Shoko::Adapters::Output::Ui::Components::Rect.new(x: @x, y: @y, width: @width, height: @height)
+        @coordinate_service.within_bounds?(col, row, bounds)
+      end
+
+      private
+
+      def default_actions
+        actions = []
+
+        # Always offer annotation creation
+        actions << {
+          label: 'Create Annotation',
+          action: :create_annotation,
+          icon: '󱓩',
+        }
+
+        # Only offer clipboard if available
+        if @clipboard_service&.available?
+          actions << {
+            label: 'Copy to Clipboard',
+            action: :copy_to_clipboard,
+            icon: '',
+          }
+        end
+
+        actions
+      end
+
+      def calculate_width
+        max_label_width = @items.map { |item| Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(item) }.max || 0
+        max_label_width + 6 # Padding for icon and spacing
+      end
+
+      def move_selection(direction)
+        return if @items.empty?
+
+        @selected_index = (@selected_index + direction) % @items.length
+      end
+
+      def execute_selected_action
+        action = @available_actions[@selected_index]
+        return { type: :cancel } unless action
+
+        {
+          type: :action,
+          action: action[:action],
+          data: {
+            selection_range: @selection_range,
+            action_config: action,
+          },
+        }
+      end
+
+      def popup_anchor_position(anchor_hash)
+        anchor = Shoko::Core::Models::SelectionAnchor.from(anchor_hash)
+        geometry = geometry_for_anchor(anchor)
+        return { x: 1, y: 1 } unless geometry
+
+        x = if anchor.cell_index >= geometry.cells.length
+              geometry.column_origin + geometry.visible_width
+            else
+              cell = geometry.cells[anchor.cell_index]
+              geometry.column_origin + cell.screen_x
+            end
+        y = geometry.row
+
+        @coordinate_service.calculate_popup_position({ x:, y: }, @width, @height)
+      end
+
+      def geometry_for_anchor(anchor)
+        return nil unless anchor
+
+        return nil unless @rendered_lines
+
+        entry = @rendered_lines[anchor.geometry_key]
+        (entry && entry[:geometry]) || nil
+      end
+
+      def render_menu_item(surface, bounds, item, index)
+        item_y = @y + index
+        is_selected = (index == @selected_index)
+        action = @available_actions[index]
+
+        # Colors
+        bg = is_selected ? TOOLTIP_BG_SELECTED : TOOLTIP_BG_DEFAULT
+        fg = is_selected ? TOOLTIP_FG_SELECTED : TOOLTIP_FG_DEFAULT
+
+        # Background
+        surface.write_abs(bounds, item_y, @x, "#{bg}#{' ' * @width}#{Terminal::ANSI::RESET}")
+
+        # Content with icon
+        indicator = is_selected ? '❯' : ' '
+        icon = action[:icon] || ' '
+        line_text = Shoko::Adapters::Output::Terminal::TextMetrics.pad_right("#{indicator}#{icon} #{item} ", @width)
+        surface.write_abs(bounds, item_y, @x, "#{bg}#{fg}#{line_text}#{Terminal::ANSI::RESET}")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require_relative 'base_component'
+require_relative 'surface'
+require_relative '../../terminal/text_metrics.rb'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    # Renders the bottom status area (page info + transient message).
+    class FooterComponent < BaseComponent
+      def initialize(view_model_provider = nil)
+        super()
+        @view_model_provider = view_model_provider
+        @cached_view_model = nil
+      end
+
+      def preferred_height(_available_height)
+        vm = resolve_view_model
+        return 0 unless vm
+
+        renderable_page_info?(vm) ? 1 : 0
+      end
+
+      def do_render(surface, bounds)
+        vm = resolve_view_model
+        return unless vm
+
+        return unless renderable_page_info?(vm)
+
+        render_page_info(surface, bounds, vm, bounds.height)
+      ensure
+        @cached_view_model = nil
+      end
+
+      private
+
+      def resolve_view_model
+        return nil unless @view_model_provider
+
+        @cached_view_model ||= @view_model_provider.call
+      rescue StandardError
+        nil
+      end
+
+      def renderable_page_info?(view_model)
+        disallowed_modes = %i[help]
+        return false if view_model.respond_to?(:mode) && disallowed_modes.include?(view_model.mode)
+        return false unless view_model.respond_to?(:show_page_numbers) && view_model.show_page_numbers
+
+        info = view_model.page_info
+        info && !info.empty?
+      end
+
+      def render_page_info(surface, bounds, view_model, row)
+        ui = Shoko::Adapters::Output::Ui::Constants::UI
+        width = bounds.width
+        info = view_model.page_info
+
+        if view_model.view_mode == :split && info[:left]
+          render_split_page_info(surface, bounds, info, width, row, ui)
+        else
+          render_single_page_info(surface, bounds, info, width, row, ui)
+        end
+      end
+
+      def render_single_page_info(surface, bounds, info, width, row, ui_constants)
+        current = info[:current].to_i
+        total = info[:total].to_i
+        return if current.zero? && total.zero?
+
+        label = page_label(current, total)
+        col = center_col(width, Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(label))
+        write_colored(surface, bounds, row, col, label, ui_constants::COLOR_TEXT_PRIMARY)
+      end
+
+      def render_split_page_info(surface, bounds, info, width, row, ui_constants)
+        left = info[:left]
+        right = info[:right]
+        return unless left
+
+        left_label = page_label(left[:current].to_i, left[:total].to_i)
+        left_col = quarter_center_col(width, Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(left_label), :left)
+        unless left_label.empty?
+          write_colored(surface, bounds, row, left_col, left_label,
+                        ui_constants::COLOR_TEXT_PRIMARY)
+        end
+
+        return unless right
+
+        right_label = page_label(right[:current].to_i, right[:total].to_i)
+        right_col = quarter_center_col(width, Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(right_label), :right)
+        return if right_label.empty?
+
+        write_colored(surface, bounds, row, right_col, right_label,
+                      ui_constants::COLOR_TEXT_PRIMARY)
+      end
+
+      # ----- helpers -----
+
+      def page_label(current, total)
+        total.positive? ? "#{current} / #{total}" : "Page #{current}"
+      end
+
+      def center_col(width, text_len)
+        [(width - text_len) / 2, 1].max
+      end
+
+      def quarter_center_col(width, text_len, side)
+        half = text_len / 2
+        return [(width / 4) - half, 1].max if side == :left
+
+        [(3 * width / 4) - half, 1].max
+      end
+
+      def write_colored(surface, bounds, row, col, text, color_prefix)
+        surface.write(bounds, row, col, color_prefix + text + Terminal::ANSI::RESET)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'base_component'
+require_relative 'surface'
+require_relative '../constants/ui_constants'
+require_relative '../../terminal/text_metrics.rb'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    # Renders the top header row (document title).
+    class HeaderComponent < BaseComponent
+      include Adapters::Output::Ui::Constants::UI
+
+      def initialize(view_model_provider = nil, theme = :dark)
+        super()
+        @view_model_provider = view_model_provider
+        @theme = theme
+      end
+
+      def preferred_height(_available_height)
+        1
+      end
+
+      def do_render(surface, bounds)
+        return unless @view_model_provider
+
+        view_model = @view_model_provider.call
+        return unless view_model.respond_to?(:document_title)
+
+        render_centered_title(surface, bounds, view_model.document_title.to_s)
+      end
+
+      private
+
+      def render_centered_title(surface, bounds, title)
+        return if title.empty?
+
+        reset = Terminal::ANSI::RESET
+        width = bounds.width
+        title_width = Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(title)
+        col = [(width - title_width) / 2, 1].max
+        surface.write(bounds, 1, col, "#{COLOR_TEXT_PRIMARY}#{title}#{reset}")
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/ui/components/layouts/horizontal.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative '../base_component'
+require_relative '../rect'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    module Layouts
+      # Horizontal layout that splits children left-to-right
+      # Supports collapsible left sidebar with dynamic width allocation
+      class Horizontal < BaseComponent
+        def initialize(left_child, right_child)
+          super(nil)
+          @left_child = left_child
+          @right_child = right_child
+        end
+
+        def do_render(surface, bounds)
+          return unless @left_child && @right_child
+
+          # Cache frequently used bounds
+          x = bounds.x
+          y = bounds.y
+          w = bounds.width
+          h = bounds.height
+
+          # Calculate widths based on left child's preferred width
+          left_width = calculate_left_width(w)
+          right_width = w - left_width
+
+          # Render left child (sidebar)
+          if left_width.positive?
+            left_bounds = Rect.new(x: x, y: y, width: left_width, height: h)
+            @left_child.render(surface, left_bounds)
+          end
+
+          # Render right child (content)
+          return unless right_width.positive?
+
+          right_x = x + left_width
+          right_bounds = Rect.new(x: right_x, y: y, width: right_width, height: h)
+          @right_child.render(surface, right_bounds)
+        end
+
+        private
+
+        def calculate_left_width(total_width)
+          return 0 unless @left_child.respond_to?(:preferred_width)
+
+          pref = @left_child.preferred_width(total_width)
+          case pref
+          when Integer
+            [pref, total_width].min
+          when :flexible
+            total_width / 3 # Default to 1/3 width
+          else
+            0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/ui/components/layouts/vertical.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative '../base_component'
+require_relative '../rect'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    module Layouts
+      # Simple vertical layout that stacks children top-to-bottom
+      # Respects preferred heights; assigns remaining space to first flexible child
+      class Vertical < BaseComponent
+        def initialize(children)
+          super(nil)
+          @children = children
+        end
+
+        def do_render(surface, bounds)
+          return if @children.nil? || @children.empty?
+
+          # Calculate heights using new contract
+          heights = calculate_child_heights(bounds.height)
+
+          # Render children
+          cursor_y = bounds.y
+          @children.each_with_index do |child, i|
+            height = heights[i] || 0
+            next if height <= 0
+
+            child_bounds = Rect.new(x: bounds.x, y: cursor_y, width: bounds.width, height: height)
+            child.render(surface, child_bounds)
+            cursor_y += height
+          end
+        end
+
+        private
+
+        def calculate_child_heights(total_height)
+          heights = []
+          remaining = total_height
+          fill_children = []
+
+          # First pass: allocate fixed heights
+          @children.each_with_index do |child, i|
+            pref = child.respond_to?(:preferred_height) ? child.preferred_height(total_height) : :flexible
+
+            case pref
+            when Integer
+              # Fixed height
+              height = [pref, remaining].min
+              heights[i] = height
+              remaining -= height
+            when :fill
+              # Fill remaining space (calculated in second pass)
+              fill_children << i
+              heights[i] = nil
+            else
+              # :flexible and any unknown values default to minimum space
+              heights[i] = 0
+            end
+          end
+
+          # Second pass: distribute remaining space to fill children
+          if fill_children.any?
+            target_height = remaining.positive? ? (remaining / fill_children.size) : 0
+            fill_children.each { |i| heights[i] = target_height }
+          end
+
+          heights
+        end
+      end
+    end
+  end
+end