shoko 0.1.0

data/lib/shoko/adapters/output/ui/components/screens/annotation_rendering_helpers.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require_relative '../ui/text_utils'
+require_relative '../../../terminal/text_metrics.rb'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    module Screens
+      # Normalized view of annotation data for screen rendering.
+      class AnnotationView
+        def initialize(annotation)
+          @annotation = annotation.is_a?(Hash) ? annotation : {}
+        end
+
+        def text
+          fetch(:text).to_s
+        end
+
+        def note
+          fetch(:note).to_s
+        end
+
+        def chapter_index
+          fetch(:chapter_index)
+        end
+
+        def id
+          fetch(:id)
+        end
+
+        def formatted_date
+          created = fetch(:created_at)
+          created.to_s.tr('T', ' ').sub('Z', '')
+        end
+
+        def page_meta
+          curr = fetch(:page_current)
+          total = fetch(:page_total)
+          return nil unless curr && total
+
+          mode = fetch(:page_mode).to_s
+          label = mode.empty? ? '' : "#{mode}: "
+          "#{label}#{curr}/#{total}"
+        end
+
+        private
+
+        def fetch(key)
+          @annotation[key] || @annotation[key.to_s]
+        end
+      end
+
+      # Text box helper for annotation screens.
+      class AnnotationTextBox
+        BOX_COLUMN = 2
+        TEXT_COLUMN = 4
+        BOX_SPACING = 2
+        MIN_HEIGHT = 6
+        BOTTOM_PADDING = 3
+
+        attr_reader :row, :height, :width, :label, :text
+
+        def initialize(row:, height:, width:, label:, text:)
+          @row = row
+          @height = height
+          @width = width
+          @label = label
+          @text = text.to_s
+        end
+
+        def inner_width
+          width - 4
+        end
+
+        def frame_args
+          {
+            row: row,
+            height: height,
+            width: width,
+            label: label,
+          }
+        end
+
+        def each_visible_line(&block)
+          return enum_for(__method__) unless block
+
+          lines = UI::TextUtils.wrap_text(text, inner_width)
+          lines.first(max_lines).each_with_index(&block)
+        end
+
+        def render(context, drawer:, color_prefix:)
+          drawer.draw_box(
+            context.surface,
+            context.bounds,
+            row,
+            BOX_COLUMN,
+            height,
+            width,
+            label: label
+          )
+          render_lines(context, color_prefix: color_prefix)
+        end
+
+        def render_lines(context, color_prefix:)
+          each_visible_line do |line, index|
+            padded = UI::TextUtils.pad_right(line, inner_width)
+            context.surface.write(
+              context.bounds,
+              row + 1 + index,
+              TEXT_COLUMN,
+              "#{color_prefix}#{padded}#{context.reset}"
+            )
+          end
+        end
+
+        def cursor_position(cursor)
+          cursor_lines = UI::TextUtils.wrap_text(text[0, cursor], inner_width)
+          cursor_row = row + 1 + [cursor_lines.length - 1, 0].max
+          cursor_col = TEXT_COLUMN + Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(cursor_lines.last || '')
+          [cursor_row, cursor_col]
+        end
+
+        def next_box(total_height:, label:, text:)
+          next_row = row + height + BOX_SPACING
+          next_height = [total_height - next_row - BOTTOM_PADDING, MIN_HEIGHT].max
+          AnnotationTextBox.new(row: next_row, height: next_height, width: width, label: label, text: text)
+        end
+
+        private
+
+        def max_lines
+          [height - 2, 0].max
+        end
+      end
+
+      # Menu-state helper for annotation edit screens.
+      class AnnotationEditState
+        def initialize(state)
+          @state = state
+        end
+
+        def text
+          (@state.get(%i[menu annotation_edit_text]) || '').to_s
+        end
+
+        def cursor(text = self.text)
+          (@state.get(%i[menu annotation_edit_cursor]) || text.length).to_i
+        end
+
+        def update_from
+          current_text = text
+          current_cursor = cursor(current_text)
+          updated = yield(current_text, current_cursor)
+          update(text: updated[0], cursor: updated[1]) if updated
+        end
+
+        def update(text:, cursor:)
+          @state.dispatch(Shoko::Application::Actions::UpdateMenuAction.new(
+                            annotation_edit_text: text,
+                            annotation_edit_cursor: cursor
+                          ))
+        end
+
+        def selected_annotation
+          ann = @state.get(%i[menu selected_annotation])
+          ann if ann.is_a?(Hash)
+        end
+
+        def annotation_update_payload
+          annotation = selected_annotation || {}
+          path = @state.get(%i[menu selected_annotation_book])
+          ann_id = annotation[:id] || annotation['id']
+          return nil unless path && ann_id
+
+          { path: path, ann_id: ann_id, text: text }
+        end
+
+        def refresh_annotations(service)
+          @state.dispatch(
+            Shoko::Application::Actions::UpdateMenuAction.new(annotations_all: service.list_all)
+          )
+        end
+
+        def return_to_annotations_list
+          @state.dispatch(Shoko::Application::Actions::UpdateMenuAction.new(mode: :annotations))
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/ui/components/screens/annotations_screen_component.rb

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+require_relative '../base_component'
+require_relative '../../constants/ui_constants'
+require_relative '../../../terminal/terminal_sanitizer.rb'
+require_relative '../ui/text_utils'
+require_relative '../ui/list_helpers'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    module Screens
+      # Annotations screen component for viewing and managing annotations
+      class AnnotationsScreenComponent < BaseComponent
+        include Adapters::Output::Ui::Constants::UI
+        include UI::TextUtils
+
+        def initialize(state)
+          super()
+          @state = state
+          @selected = 0
+          @list = []
+          @mode = :book
+          @current_book_path = nil
+          @current_annotation = nil
+          refresh_data
+        end
+
+        attr_reader :selected, :current_annotation, :current_book_path
+
+        def selected=(value)
+          @selected = [value, 0].max
+          update_current_annotation
+        end
+
+        def navigate(direction)
+          annotations = current_annotations
+          return if annotations.empty?
+
+          case direction
+          when :up
+            @selected = [@selected - 1, 0].max
+          when :down
+            @selected = [@selected + 1, annotations.length - 1].min
+          end
+
+          update_current_annotation
+        end
+
+        # Normalize raw annotations (string-keyed hashes) into symbol-keyed items
+        # Includes page metadata when present
+        # (duplicate normalize_list method removed)
+
+        def refresh_data
+          prev_selected = @selected
+          path = @state.get(%i[reader book_path])
+          if path && !path.to_s.empty?
+            @mode = :book
+            @current_book_path = path
+            raw = @state.get(%i[reader annotations]) || []
+            @list = normalize_list(raw).map { |a| a.merge(book_path: path) }
+          else
+            @mode = :all
+            mapping = @state.get(%i[menu annotations_all]) || {}
+            flattened = []
+            mapping.each do |book_path, items|
+              normalize_list(items).each do |a|
+                flattened << a.merge(book_path: book_path)
+              end
+            end
+            @list = flattened
+          end
+
+          annotations = current_annotations
+          upper = [annotations.length - 1, 0].max
+          @selected = prev_selected.clamp(0, upper)
+          update_current_annotation
+        end
+
+        def do_render(surface, bounds)
+          # Ensure data is fresh each render
+          refresh_data
+          height = bounds.height
+          width = bounds.width
+
+          # Header
+          reset = Terminal::ANSI::RESET
+          count = current_annotations.length
+          all_mode = (@mode == :all)
+          book_label = if @current_book_path
+                         raw = File.basename(@current_book_path)
+                         Shoko::Adapters::Output::Terminal::TerminalSanitizer.sanitize(raw, preserve_newlines: false,
+                                                                               preserve_tabs: false)
+                       else
+                         (all_mode ? 'All Books' : 'No book selected')
+                       end
+          header_left_plain = "📝 Annotations (#{count}) — #{book_label}"
+          header_left = "#{COLOR_TEXT_ACCENT}#{header_left_plain}#{reset}"
+
+          header_right_plain = '[Enter] Open • [e] Edit • [d] Delete'
+          header_right = "#{COLOR_TEXT_DIM}#{header_right_plain}#{reset}"
+
+          surface.write(bounds, 1, 2, header_left)
+          header_right_width = Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(header_right_plain)
+          header_left_width = Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(header_left_plain)
+          min_right_col = 2 + header_left_width + 2
+          right_aligned_col = width - header_right_width - 1
+          right_col = [right_aligned_col, min_right_col].max
+          surface.write(bounds, 1, right_col, header_right)
+          # Divider and column headers
+          surface.write(bounds, 2, 1, COLOR_TEXT_DIM + ('─' * width) + reset)
+          idx_w = 4
+          ch_w = 6
+          date_w = 10
+          book_w = all_mode ? 12 : 0
+          avail = width - (idx_w + ch_w + date_w + book_w + 8)
+          snippet_w = (avail * 0.55).to_i
+          note_w = avail - snippet_w
+          has_book_col = book_w.positive?
+          columns = [
+            '  ',
+            pad_right('#', idx_w),
+            '  ',
+            pad_right('Ch', ch_w),
+            '  ',
+            pad_right('Snippet', snippet_w),
+            '  ',
+            pad_right('Note', note_w),
+            (has_book_col ? "  #{pad_right('Book', book_w)}" : ''),
+            '  ',
+            pad_right('Date', date_w),
+          ].join
+          surface.write(bounds, 3, 1, COLOR_TEXT_DIM + columns + reset)
+
+          annotations = current_annotations
+
+          if annotations.empty?
+            render_empty_state(surface, bounds, width, height)
+          else
+            render_annotations_list(surface, bounds, width, height, annotations, has_book_col)
+          end
+
+          # Footer instructions
+          surface.write(bounds, height - 2, 2,
+                        "#{COLOR_TEXT_DIM}[↑/↓] Navigate • [Enter] Open • [d] Delete • [ESC] Back#{Terminal::ANSI::RESET}")
+        end
+
+        def preferred_height(_available_height)
+          :fill
+        end
+
+        private
+
+        def current_annotations
+          @list || []
+        end
+
+        def update_current_annotation
+          annotations = current_annotations
+          @current_annotation = annotations[@selected] if @selected < annotations.length
+          return unless @current_annotation
+
+          book_path = @current_annotation[:book_path]
+          return unless book_path
+
+          @current_book_path = book_path
+        end
+
+        def render_empty_state(surface, bounds, width, height)
+          reset = Terminal::ANSI::RESET
+          empty_text = "#{COLOR_TEXT_DIM}No annotations found#{reset}"
+          mid = height / 2
+          surface.write(bounds, mid,
+                        [(width - Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(empty_text) + 10) / 2, 1].max,
+                        empty_text)
+
+          help_text = "#{COLOR_TEXT_DIM}Annotations you create while reading will appear here#{reset}"
+          surface.write(bounds, mid + 2,
+                        [(width - Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(help_text) + 10) / 2, 1].max,
+                        help_text)
+        end
+
+        def render_annotations_list(surface, bounds, width, height, annotations, in_all)
+          list_start_row = 4
+          list_height = height - list_start_row - 2
+          return if list_height <= 0
+
+          start_index, visible_annotations = UI::ListHelpers.slice_visible(annotations, list_height, @selected)
+
+          visible_annotations.each_with_index do |annotation, index|
+            row = list_start_row + index
+            abs_idx = start_index + index
+            is_selected = (abs_idx == @selected)
+
+            render_annotation_item(surface, bounds, row, width, annotation, is_selected,
+                                   abs_idx, in_all)
+          end
+        end
+
+        def render_annotation_item(surface, bounds, row, width, annotation, is_selected,
+                                   absolute_index, in_all)
+          # Extract annotation details
+          text = (annotation[:text] || 'No text').to_s.tr("\n", ' ')
+          note = (annotation[:note] || '').to_s.tr("\n", ' ')
+          created = (annotation[:created_at] || '').to_s.split('T').first
+          chapter = annotation[:chapter_index]
+
+          # Column widths (match header)
+          idx_w = 4
+          ch_w = 6
+          date_w = 10
+          book_w = (in_all ? 12 : 0)
+          avail = width - (idx_w + ch_w + date_w + book_w + 8)
+          snippet_w = (avail * 0.6).to_i
+          note_w = avail - snippet_w
+
+          pointer = is_selected ? '▸' : ' '
+          idx = pad_left((absolute_index + 1).to_s, idx_w)
+          chv = chapter.nil? ? '-' : chapter.to_i
+          ch_col = pad_right(chv.to_s, ch_w)
+          snippet = pad_right(truncate_text(text, snippet_w), snippet_w)
+          note_tr = pad_right(truncate_text(note, note_w), note_w)
+          if in_all
+            bp = annotation[:book_path]
+            book = if bp
+                     raw = File.basename(bp)
+                     Shoko::Adapters::Output::Terminal::TerminalSanitizer.sanitize(raw, preserve_newlines: false,
+                                                                           preserve_tabs: false)
+                   else
+                     ''
+                   end
+            book_col = pad_right(truncate_text(book, book_w), book_w)
+            date_col = pad_right(truncate_text(created, date_w), date_w)
+            line = [pointer, ' ', idx, '  ', ch_col, '  ', snippet, '  ', note_tr,
+                    '  ', book_col, '  ', date_col].join
+          else
+            date_col = pad_right(truncate_text(created, date_w), date_w)
+            line = [pointer, ' ', idx, '  ', ch_col, '  ', snippet, '  ', note_tr,
+                    '  ', date_col].join
+          end
+
+          color = is_selected ? SELECTION_HIGHLIGHT : COLOR_TEXT_PRIMARY
+          surface.write(bounds, row, 1, color + line + Terminal::ANSI::RESET)
+        end
+
+        # truncate_text provided by UI::TextUtils
+
+        def normalize_list(raw)
+          (raw || []).map do |a|
+            {
+              text: a['text'],
+              note: a['note'],
+              id: a['id'],
+              range: a['range'],
+              chapter_index: a['chapter_index'],
+              created_at: a['created_at'],
+              updated_at: a['updated_at'],
+              page_current: a['page_current'],
+              page_total: a['page_total'],
+              page_mode: a['page_mode'],
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/ui/components/screens/base_screen_component.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative '../base_component'
+require_relative '../render_style'
+require_relative '../../../terminal/text_metrics.rb'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    module Screens
+      # Base component for all screen renderers
+      class BaseScreenComponent < BaseComponent
+        def initialize(services = nil)
+          super
+        end
+
+        # Screens typically take the full available height
+        def preferred_height(available_height)
+          available_height
+        end
+
+        protected
+
+        def write_header(surface, bounds, title, help_text = nil)
+          w = bounds.width
+          surface.write(bounds, 1, 2, title)
+          return unless help_text
+
+          help_width = Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(help_text)
+          surface.write(bounds, 1, [w - help_width - 2, w / 2].max, help_text)
+        end
+
+        def write_footer(surface, bounds, text)
+          surface.write(bounds, bounds.height - 1, 2, text)
+        end
+
+        def write_empty_message(surface, bounds, message)
+          col = [(bounds.width - Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(message)) / 2, 1].max
+          row = bounds.height / 2
+          surface.write(bounds, row, col, message)
+        end
+
+        def write_selection_pointer(surface, bounds, row, selected: true)
+          text = selected ? Shoko::Adapters::Output::Ui::Components::RenderStyle.selection_pointer_colored : '  '
+          surface.write(bounds, row, 2, text)
+        end
+      end
+    end
+  end
+end