shoko 0.1.0

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

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require_relative 'base_component'
+require_relative 'render_style'
+require_relative 'ui/overlay_layout'
+require_relative 'annotation_editor_overlay/footer_renderer'
+require_relative 'annotation_editor_overlay/geometry'
+require_relative 'annotation_editor_overlay/note_renderer'
+require_relative '../../terminal/text_metrics.rb'
+require_relative '../../../input/key_definitions.rb'
+require_relative '../../terminal/terminal_sanitizer.rb'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    # Overlay for creating/editing annotations without leaving the reader view.
+    class AnnotationEditorOverlayComponent < BaseComponent
+      include Adapters::Output::Ui::Constants::UI
+
+      SAVE_KEYS = ["\x13"].freeze # Ctrl+S
+      BACKSPACE_KEYS = ["\x08", "\x7F", '\b'].freeze
+
+      attr_reader :visible, :selected_text, :note, :chapter_index, :annotation_id
+
+      def initialize(selected_text:, range:, chapter_index:, annotation: nil)
+        super()
+        @selected_text = (selected_text || '').dup
+        @range = range
+        @chapter_index = chapter_index
+        @annotation_id = annotation.is_a?(Hash) ? (annotation[:id] || annotation['id']) : nil
+        note_source = annotation.is_a?(Hash) ? (annotation[:note] || annotation['note']) : nil
+        @note = (note_source || '').dup
+        @cursor_pos = @note.length
+        @visible = true
+        @button_regions = {}
+        @overlay_sizing = UI::OverlaySizing.new(
+          width_ratio: 0.7,
+          width_padding: 10,
+          min_width: 60,
+          height_ratio: 0.6,
+          height_padding: 6,
+          min_height: 16
+        )
+      end
+
+      def visible?
+        @visible
+      end
+
+      def hide
+        @visible = false
+      end
+
+      def selection_range
+        @range
+      end
+
+      def render(surface, bounds)
+        do_render(surface, bounds)
+      end
+
+      def do_render(surface, bounds)
+        return unless @visible
+
+        layout = overlay_layout(bounds)
+
+        render_panel(surface, bounds, layout)
+
+        geometry = AnnotationEditorOverlay::Geometry.new(layout)
+        render_header(surface, bounds, geometry)
+        render_selection_summary(surface, bounds, geometry)
+        render_field_label(surface, bounds, geometry)
+        note_renderer = AnnotationEditorOverlay::NoteRenderer.new(
+          background: ANNOTATION_PANEL_BG,
+          text_color: theme_primary,
+          cursor_color: theme_accent,
+          geometry: geometry,
+          placeholder_text: 'Write your annotation...',
+          placeholder_color: COLOR_TEXT_DIM
+        )
+        note_renderer.render(surface, bounds, note: @note, cursor_pos: @cursor_pos)
+
+        footer_renderer = AnnotationEditorOverlay::FooterRenderer.new(
+          background: ANNOTATION_PANEL_BG,
+          text_fg: theme_primary,
+          key_fg: COLOR_TEXT_DIM
+        )
+        @button_regions = footer_renderer.render(surface, bounds, geometry)
+      end
+
+      # Handles key input, returning an event hash when an action should be taken.
+      def handle_key(key)
+        return { type: :cancel } if cancel_key?(key)
+        return handle_save if save_key?(key)
+
+        case key
+        when *BACKSPACE_KEYS
+          handle_backspace
+        when "\r", "\n"
+          insert_newline
+        else
+          insert_character(key)
+        end
+        nil
+      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 handle_backspace
+        return if @cursor_pos.zero?
+
+        @note.slice!(@cursor_pos - 1)
+        @cursor_pos -= 1
+      end
+
+      def handle_enter
+        insert_newline
+      end
+
+      def handle_character(key)
+        insert_character(key)
+      end
+
+      def insert_newline
+        insert_text("\n")
+      end
+
+      def insert_character(key)
+        return unless printable?(key)
+
+        insert_text(key)
+      end
+
+      def insert_text(str)
+        @note.insert(@cursor_pos, str)
+        @cursor_pos += str.length
+      end
+
+      def printable?(key)
+        Shoko::Adapters::Output::Terminal::TerminalSanitizer.printable_char?(key.to_s)
+      end
+
+      def save_key?(key)
+        SAVE_KEYS.include?(key)
+      end
+
+      def cancel_key?(key)
+        Adapters::Input::KeyDefinitions::ACTIONS[:cancel].include?(key)
+      end
+
+      def handle_save
+        { type: :save, note: @note }
+      end
+
+      def handle_click(col, row)
+        return nil unless @visible && @button_regions
+
+        @button_regions.each do |key, region|
+          next unless row == region[:row]
+          next unless col.between?(region[:col], region[:col] + region[:width] - 1)
+
+          return handle_save if key == :save
+          return { type: :cancel } if key == :cancel
+        end
+
+        nil
+      end
+
+      private
+
+      def render_panel(surface, bounds, layout)
+        layout.fill_background(surface, bounds, background: ANNOTATION_PANEL_BG)
+      end
+
+      def render_header(surface, bounds, geometry)
+        reset = Terminal::ANSI::RESET
+        title = 'Annotation'
+        surface.write(bounds, geometry.header_row, geometry.content_x,
+                      "#{ANNOTATION_PANEL_BG}#{ANNOTATION_HEADER_FG}#{title}#{reset}")
+      end
+
+      def render_selection_summary(surface, bounds, geometry)
+        reset = Terminal::ANSI::RESET
+        summary = selection_summary_text(geometry)
+        return if summary.empty?
+
+        surface.write(bounds, geometry.subheader_row, geometry.content_x,
+                      "#{ANNOTATION_PANEL_BG}#{summary}#{reset}")
+      end
+
+      def render_field_label(surface, bounds, geometry)
+        label = 'Note'
+        surface.write(bounds, geometry.label_row, geometry.content_x,
+                      "#{ANNOTATION_PANEL_BG}#{COLOR_TEXT_DIM}#{label}#{Terminal::ANSI::RESET}")
+      end
+
+      def selection_summary_text(geometry)
+        sanitized = Shoko::Adapters::Output::Terminal::TerminalSanitizer.sanitize(@selected_text.to_s,
+                                                        preserve_newlines: false,
+                                                        preserve_tabs: false)
+        condensed = sanitized.gsub(/\s+/, ' ').strip
+        return "#{COLOR_TEXT_DIM}Write your note below" if condensed.empty?
+
+        label = 'Selected: '
+        max = geometry.content_width - Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(label)
+        snippet = Shoko::Adapters::Output::Terminal::TextMetrics.truncate_to(condensed, [max, 1].max)
+        "#{COLOR_TEXT_DIM}#{label}#{theme_primary}#{snippet}"
+      end
+
+      def theme_accent
+        Shoko::Adapters::Output::Ui::Components::RenderStyle.color(:accent)
+      rescue StandardError
+        COLOR_TEXT_ACCENT
+      end
+
+      def theme_primary
+        Shoko::Adapters::Output::Ui::Components::RenderStyle.color(:primary)
+      rescue StandardError
+        COLOR_TEXT_PRIMARY
+      end
+
+      def overlay_layout(bounds)
+        width = calculate_width(bounds.width)
+        height = calculate_height(bounds.height)
+        UI::OverlayLayout.centered(bounds, width: width, height: height)
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/ui/components/annotations_overlay/list_renderer.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require_relative '../ui/text_utils'
+require_relative '../ui/list_helpers'
+require_relative '../../../terminal/text_metrics.rb'
+require_relative '../../../terminal/terminal.rb'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    # Namespace for annotations overlay helpers.
+    module AnnotationsOverlay
+      # Renders the annotations list and header within the overlay.
+      class ListRenderer
+        include Adapters::Output::Ui::Constants::UI
+
+        # Rendering inputs for the annotations overlay list.
+        RenderContext = Struct.new(:surface, :bounds, :layout, :entries, :selected_index, keyword_init: true)
+
+        ColumnWidths = Struct.new(:idx, :snippet, :note, :date, keyword_init: true)
+
+        def render(context)
+          draw_title(context)
+          draw_entries(context)
+        end
+
+        private
+
+        def draw_title(context)
+          surface = context.surface
+          bounds = context.bounds
+          layout = context.layout
+          count = context.entries.length
+          origin_x = layout.origin_x
+          reset = Terminal::ANSI::RESET
+          title = "#{COLOR_TEXT_ACCENT}📝 Annotations (#{count})#{reset}"
+          title_row = layout.origin_y + 1
+          title_col = origin_x + 2
+          surface.write(bounds, title_row, title_col, title)
+
+          info_plain = '[Enter] Open • [e] Edit • [d] Delete • [Esc] Close'
+          info_col = origin_x + [layout.width - Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(info_plain) - 2, 2].max
+          surface.write(bounds, title_row, info_col, "#{COLOR_TEXT_DIM}#{info_plain}#{reset}")
+        end
+
+        def draw_entries(context)
+          layout = context.layout
+          entries = context.entries
+          list_top = layout.origin_y + 3
+          list_height = [layout.height - 5, 1].max
+          inner_width = layout.width - 4
+
+          if entries.empty?
+            render_empty(context)
+            return
+          end
+
+          columns = build_columns(inner_width)
+          render_header(context, columns, list_top)
+          render_rows(context, columns, list_top, list_height)
+        end
+
+        def render_empty(context)
+          surface = context.surface
+          bounds = context.bounds
+          layout = context.layout
+          message = "#{COLOR_TEXT_DIM}No annotations yet#{Terminal::ANSI::RESET}"
+          row = layout.origin_y + (layout.height / 2)
+          col = layout.origin_x + [(layout.width - Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(message)) / 2,
+                                   2].max
+          surface.write(bounds, row, col, message)
+        end
+
+        def build_columns(inner_width)
+          idx_width = 4
+          date_width = [12, inner_width / 5].max
+          remaining = inner_width - idx_width - date_width - 2
+          remaining = 12 if remaining < 12
+          snippet_width = [(remaining * 0.6).floor, 8].max
+          note_width = [remaining - snippet_width, 6].max
+          ColumnWidths.new(idx: idx_width, snippet: snippet_width, note: note_width, date: date_width)
+        end
+
+        def render_header(context, columns, list_top)
+          surface = context.surface
+          bounds = context.bounds
+          layout = context.layout
+          header = [
+            '  ',
+            UI::TextUtils.pad_right('#', columns.idx),
+            ' ',
+            UI::TextUtils.pad_right('Snippet', columns.snippet),
+            ' ',
+            UI::TextUtils.pad_right('Note', columns.note),
+            ' ',
+            UI::TextUtils.pad_right('Saved', columns.date),
+          ].join
+          surface.write(bounds, list_top - 1, layout.origin_x + 2,
+                        "#{COLOR_TEXT_DIM}#{header}#{Terminal::ANSI::RESET}")
+        end
+
+        def render_rows(context, columns, list_top, list_height)
+          surface = context.surface
+          bounds = context.bounds
+          layout = context.layout
+          selected_index = context.selected_index
+          entries = context.entries
+          start_index, visible = UI::ListHelpers.slice_visible(entries, list_height, selected_index)
+          list_col = layout.origin_x + 2
+
+          visible.each_with_index do |annotation, offset|
+            entry_index = start_index + offset
+            is_selected = entry_index == selected_index
+            line_color = is_selected ? SELECTION_HIGHLIGHT : COLOR_TEXT_PRIMARY
+            pointer = is_selected ? '▸' : ' '
+
+            line = build_line(annotation, entry_index, columns, pointer)
+            surface.write(bounds, list_top + offset, list_col, "#{line_color}#{line}#{Terminal::ANSI::RESET}")
+          end
+        end
+
+        def build_line(annotation, entry_index, columns, pointer)
+          snippet = format_cell(annotation[:text], columns.snippet)
+          note = format_cell(annotation[:note], columns.note)
+          saved = format_cell(saved_text(annotation), columns.date)
+          idx_text = UI::TextUtils.pad_right((entry_index + 1).to_s, columns.idx)
+
+          [pointer, ' ', idx_text, ' ', snippet, ' ', note, ' ', saved].join
+        end
+
+        def format_cell(value, width)
+          text = value.to_s.tr("\n", ' ')
+          UI::TextUtils.pad_right(UI::TextUtils.truncate_text(text, width), width)
+        end
+
+        def saved_text(annotation)
+          saved_at = annotation[:updated_at] || annotation[:created_at]
+          saved_at ? saved_at.to_s.split('T').first : '-'
+        end
+      end
+    end
+  end
+end

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

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

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