shoko 0.1.3 → 0.1.5

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

@@ -1,185 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base_component'
-require_relative 'ui/box_drawer'
-require_relative 'ui/overlay_layout'
-require_relative 'annotations_overlay/list_renderer'
-
-module Shoko
-  module Adapters::Output::Ui::Components
-    # Centered overlay listing annotations above the reading surface.
-    class AnnotationsOverlayComponent < BaseComponent
-      include Adapters::Output::Ui::Constants::UI
-      include UI::BoxDrawer
-
-      def initialize(state)
-        super()
-        @state = state
-        @visible = true
-        @selected_index = (@state.get(%i[reader sidebar_annotations_selected]) || 0).to_i
-        @overlay_sizing = UI::OverlaySizing.new(
-          width_ratio: 0.6,
-          width_padding: 8,
-          min_width: 48,
-          height_ratio: 0.5,
-          height_padding: 6,
-          min_height: 12
-        )
-      end
-
-      def visible?
-        @visible
-      end
-
-      def hide
-        @visible = false
-      end
-
-      def selected_index=(index)
-        @selected_index = index.to_i
-      end
-
-      def handle_key(key)
-        entries = annotations
-        return { type: :close } if close_when_empty?(entries, key)
-
-        navigation_action(key) || selection_action(key) || close_action(key)
-      end
-
-      def current_annotation
-        entries = annotations
-        entries.empty? ? nil : entries[@selected_index]
-      end
-
-      def render(surface, bounds)
-        do_render(surface, bounds)
-      end
-
-      def do_render(surface, bounds)
-        return unless @visible
-
-        entries = annotations
-        layout = overlay_layout(bounds)
-
-        layout.fill_background(surface, bounds, background: POPUP_BG_DEFAULT)
-        draw_box(surface, bounds, layout.origin_y, layout.origin_x, layout.height, layout.width, label: 'Annotations')
-        render_context = AnnotationsOverlay::ListRenderer::RenderContext.new(
-          surface: surface,
-          bounds: bounds,
-          layout: layout,
-          entries: entries,
-          selected_index: @selected_index
-        )
-        list_renderer.render(render_context)
-        draw_footer(surface, bounds, layout)
-      end
-
-      private
-
-      def annotations
-        @annotations = (@state.get(%i[reader annotations]) || []).map { |ann| symbolize_keys(ann) }
-        clamp_selection!
-        @annotations
-      end
-
-      def clamp_selection!
-        count = @annotations.length
-        @selected_index = if count.zero?
-                            0
-                          else
-                            @selected_index.clamp(0, count - 1)
-                          end
-      end
-
-      def move_selection(delta)
-        entries = annotations
-        return if entries.empty?
-
-        new_index = (@selected_index + delta).clamp(0, entries.length - 1)
-        return if new_index == @selected_index
-
-        @selected_index = new_index
-        { type: :selection_change, index: @selected_index }
-      end
-
-      def draw_footer(surface, bounds, layout)
-        hint = "#{COLOR_TEXT_DIM}Use ↑/↓ to navigate • Enter to open#{Terminal::ANSI::RESET}"
-        surface.write(bounds, layout.origin_y + layout.height - 2, layout.origin_x + 2, hint)
-      end
-
-      def calculate_width(total_width)
-        @overlay_sizing.width_for(total_width)
-      end
-
-      def calculate_height(total_height)
-        @overlay_sizing.height_for(total_height)
-      end
-
-      def up_key?(key)
-        Adapters::Input::KeyDefinitions::NAVIGATION[:up].include?(key)
-      end
-
-      def down_key?(key)
-        Adapters::Input::KeyDefinitions::NAVIGATION[:down].include?(key)
-      end
-
-      def confirm_key?(key)
-        Adapters::Input::KeyDefinitions::ACTIONS[:confirm].include?(key)
-      end
-
-      def cancel_key?(key)
-        Adapters::Input::KeyDefinitions::ACTIONS[:cancel].include?(key)
-      end
-
-      def edit_key?(key)
-        %w[e E].include?(key)
-      end
-
-      def delete_key?(key)
-        key == 'd'
-      end
-
-      def close_when_empty?(entries, key)
-        entries.empty? && cancel_key?(key)
-      end
-
-      def navigation_action(key)
-        return move_selection(-1) if up_key?(key)
-
-        move_selection(1) if down_key?(key)
-      end
-
-      def selection_action(key)
-        annotation = current_annotation
-        return nil unless annotation
-
-        return { type: :open, annotation: annotation } if confirm_key?(key)
-        return { type: :edit, annotation: annotation } if edit_key?(key)
-
-        { type: :delete, annotation: annotation } if delete_key?(key)
-      end
-
-      def close_action(key)
-        { type: :close } if cancel_key?(key)
-      end
-
-      def overlay_layout(bounds)
-        width = calculate_width(bounds.width)
-        height = calculate_height(bounds.height)
-        UI::OverlayLayout.centered(bounds, width: width, height: height)
-      end
-
-      def list_renderer
-        @list_renderer ||= AnnotationsOverlay::ListRenderer.new
-      end
-
-      def symbolize_keys(annotation)
-        return annotation unless annotation.is_a?(Hash)
-
-        annotation.transform_keys do |key|
-          key.is_a?(String) ? key.to_sym : key
-        end
-      end
-    end
-  end
-end

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

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'component_interface'
-
-module Shoko
-  module Adapters::Output::Ui::Components
-    # Base implementation for all UI components following ComponentInterface
-    class BaseComponent
-      include ComponentInterface
-
-      attr_reader :dependencies
-
-      def initialize(dependencies = nil)
-        @dependencies = dependencies
-        @initialized = false
-        @needs_update = true
-      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)
-        ensure_mounted
-
-        # Always render for now to debug display issues
-        do_render(surface, bounds)
-        mark_updated
-      end
-
-      # Override this method in subclasses for actual rendering logic
-      def do_render(surface, bounds)
-        # to be implemented by subclasses
-      end
-
-      # Handle input key for this component
-      # Return :handled or :pass_through
-      def handle_input(_key)
-        :pass_through
-      end
-
-      # Component height calculation contract
-      # @param available_height [Integer] Total height available from parent
-      # @return [Integer, :flexible, :fill] Height requirement:
-      #   - Integer: Fixed height in rows
-      #   - :flexible: Use as much space as needed, up to available
-      #   - :fill: Take all remaining space after fixed components
-      def preferred_height(_available_height)
-        :flexible
-      end
-
-      # Component lifecycle methods
-
-      # Called once when component is first initialized with a parent
-      def mount
-        ensure_mounted
-      end
-
-      # Called when component is removed from the component tree
-      def unmount
-        ensure_unmounted
-      end
-
-      # Mark component as needing a re-render
-      def invalidate
-        @needs_update = true
-      end
-
-      # Check if component needs to be re-rendered
-      def needs_update?
-        @needs_update
-      end
-
-      # Mark component as updated (called automatically after render)
-      def mark_updated
-        @needs_update = false
-      end
-
-      # Override in subclasses for mount logic
-      def on_mount
-        # no-op by default
-      end
-
-      # Override in subclasses for cleanup logic
-      def on_unmount
-        # no-op by default
-      end
-
-      # Observer pattern support for state changes
-      def state_changed(_path, _old_value, _new_value)
-        invalidate
-      end
-
-      private
-
-      def ensure_mounted
-        return if @initialized
-
-        on_mount
-        @initialized = true
-      end
-
-      def ensure_unmounted
-        return unless @initialized
-
-        on_unmount
-        @initialized = false
-      end
-    end
-  end
-end

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

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

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

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