shoko 0.1.3 → 0.1.5

data/lib/shoko/adapters/ui/components/menu_design/table_renderer.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative '../../../../shared/terminal/text_metrics'
+require_relative '../../../../shared/terminal/ansi'
+require_relative 'theme_tokens'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module MenuDesign
+          # Shared table/list row rendering with consistent selection semantics.
+          class TableRenderer
+            def initialize(surface, bounds, tokens: ThemeTokens.new)
+              @surface = surface
+              @bounds = bounds
+              @tokens = tokens
+            end
+
+            def render_header(row:, indent:, headers:, widths:, gap: 2, divider_char: '─')
+              normalized = headers.map { |h| h.to_s.upcase }
+              line = compose_line(normalized, widths, gap: gap)
+              styled = "#{Shoko::Shared::Terminal::Ansi::BOLD}#{@tokens.panel_heading}#{line}#{@tokens.reset}"
+              @surface.write(@bounds, row, indent, styled)
+              divider = divider_char * [Shoko::Shared::Terminal::TextMetrics.visible_length(line), 1].max
+              @surface.write(@bounds, row + 1, indent, "#{@tokens.divider}#{divider}#{@tokens.reset}")
+            end
+
+            def render_row(row:, indent:, cells:, widths:, selected:, gap: 2, pointer: true)
+              line = compose_line(cells, widths, gap: gap)
+              if selected
+                text = if pointer
+                         @tokens.style_selected(line)
+                       else
+                         "#{Shoko::Shared::Terminal::Ansi::BOLD}#{@tokens.selection_fg}#{line}#{@tokens.reset}"
+                       end
+              else
+                text = pointer ? @tokens.style_unselected(line) : "#{@tokens.primary}#{line}#{@tokens.reset}"
+              end
+              @surface.write(@bounds, row, indent, text)
+            end
+
+            private
+
+            def compose_line(cells, widths, gap:)
+              sep = ' ' * gap
+              cells.each_with_index.map do |cell, index|
+                width = widths[index].to_i
+                text = cell.to_s
+                clipped = Shoko::Shared::Terminal::TextMetrics.truncate_to(text, width)
+                Shoko::Shared::Terminal::TextMetrics.pad_right(clipped, width)
+              end.join(sep)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/ui/components/menu_design/theme_tokens.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative '../../constants/ui_constants'
+require_relative '../../../../shared/terminal/ansi'
+require_relative '../../../../shared/terminal/text_metrics'
+require_relative 'icon_set'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module MenuDesign
+          # Token facade for consistent menu palette and selection styles.
+          class ThemeTokens
+            include Shoko::Adapters::Ui::Constants::Ui
+
+            def reset = Shoko::Shared::Terminal::Ansi::RESET
+            def primary = COLOR_TEXT_PRIMARY
+            def accent = COLOR_TEXT_ACCENT
+            def dim = MENU_MUTED_FG
+            def success = COLOR_TEXT_SUCCESS
+            def warning = COLOR_TEXT_WARNING
+            def error = COLOR_TEXT_ERROR
+            def divider = MENU_DIVIDER_FG
+            def heading = "#{Shoko::Shared::Terminal::Ansi::BOLD}#{MENU_TITLE_FG}"
+            def panel_heading = "#{Shoko::Shared::Terminal::Ansi::BOLD}#{primary}"
+            def header_bg = MENU_HEADER_BG
+            def selection_bg = MENU_SELECTION_BG
+            def selection_fg = MENU_SELECTION_TEXT
+
+            def brand_badge
+              "#{Shoko::Shared::Terminal::Ansi::BOLD}#{accent}SHOKO#{reset}"
+            end
+
+            def cursor_glyph
+              IconSet.ascii_icons? ? '|' : '▏'
+            end
+
+            def style_selected(text)
+              "#{selection_bg}#{selection_fg}#{selection_pointer}#{normalize_text(text)}#{reset}"
+            end
+
+            def style_unselected(text)
+              "#{primary}#{' ' * selection_slot_width}#{normalize_text(text)}#{reset}"
+            end
+
+            def selection_pointer
+              IconSet.selection_pointer
+            end
+
+            def selection_slot_width
+              Shoko::Shared::Terminal::TextMetrics.visible_length(selection_pointer)
+            end
+
+            private
+
+            def normalize_text(text)
+              value = text.to_s
+              return value if value.encoding == Encoding::UTF_8 && value.valid_encoding?
+
+              value.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: '')
+            rescue Encoding::UndefinedConversionError, Encoding::InvalidByteSequenceError, Encoding::CompatibilityError
+              value
+                .dup
+                .force_encoding(Encoding::BINARY)
+                .encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: '')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/ui/components/rect.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        Rect = Struct.new(:x, :y, :width, :height, keyword_init: true) do
+          def bottom
+            y + height - 1
+          end
+
+          def right
+            x + width - 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/ui/components/render_style.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/models/block_type'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        # Small helper for composing styled strings and common UI elements.
+        module RenderStyle
+          DEFAULT_PALETTE = Shoko::Adapters::Ui::Constants::Themes::DEFAULT_PALETTE
+
+          SUPERSCRIPT_MAP = {
+            '0' => '⁰', '1' => '¹', '2' => '²', '3' => '³', '4' => '⁴',
+            '5' => '⁵', '6' => '⁶', '7' => '⁷', '8' => '⁸', '9' => '⁹',
+            '+' => '⁺', '-' => '⁻', '=' => '⁼', '(' => '⁽', ')' => '⁾',
+            'i' => 'ⁱ', 'n' => 'ⁿ'
+          }.freeze
+
+          SUBSCRIPT_MAP = {
+            '0' => '₀', '1' => '₁', '2' => '₂', '3' => '₃', '4' => '₄',
+            '5' => '₅', '6' => '₆', '7' => '₇', '8' => '₈', '9' => '₉',
+            '+' => '₊', '-' => '₋', '=' => '₌', '(' => '₍', ')' => '₎',
+            'a' => 'ₐ', 'e' => 'ₑ', 'h' => 'ₕ', 'i' => 'ᵢ', 'j' => 'ⱼ',
+            'k' => 'ₖ', 'l' => 'ₗ', 'm' => 'ₘ', 'n' => 'ₙ', 'o' => 'ₒ',
+            'p' => 'ₚ', 'r' => 'ᵣ', 's' => 'ₛ', 't' => 'ₜ', 'u' => 'ᵤ',
+            'v' => 'ᵥ', 'x' => 'ₓ'
+          }.freeze
+
+          @palette = DEFAULT_PALETTE.dup
+
+          class << self
+            def configure(palette)
+              @palette = DEFAULT_PALETTE.merge(palette || {})
+            end
+
+            def palette
+              @palette || DEFAULT_PALETTE
+            end
+
+            def color(key)
+              palette[key] || DEFAULT_PALETTE[key]
+            end
+
+            def primary(text)
+              color(:primary) + text.to_s + Shoko::Shared::Terminal::Ansi::RESET
+            end
+
+            def accent(text)
+              color(:accent) + text.to_s + Shoko::Shared::Terminal::Ansi::RESET
+            end
+
+            def dim(text)
+              color(:dim) + text.to_s + Shoko::Shared::Terminal::Ansi::RESET
+            end
+
+            def selection_pointer
+              Shoko::Adapters::Ui::Constants::Ui::SELECTION_POINTER
+            end
+
+            def selection_pointer_colored
+              color(:accent) + selection_pointer + Shoko::Shared::Terminal::Ansi::RESET
+            end
+
+            def styled_segment(text, styles = {}, metadata: {})
+              content = transform_inline_position(text.to_s, styles)
+              return content if content.empty?
+
+              codes = []
+              block_type = canonical_block_type(metadata)
+              highlight_allowed = metadata.key?(:highlight_enabled) ? metadata[:highlight_enabled] : true
+
+              color_code = color_for(styles, block_type, highlight_allowed)
+              codes << color_code if color_code
+
+              codes << Shoko::Shared::Terminal::Ansi::BOLD if styles[:bold] || block_type == :heading
+              codes << Shoko::Shared::Terminal::Ansi::ITALIC if styles[:italic] || styles[:quote] || block_type == :quote
+              codes << Shoko::Shared::Terminal::Ansi::UNDERLINE if styles[:underline]
+              codes << Shoko::Shared::Terminal::Ansi::STRIKETHROUGH if styles[:strikethrough] || styles[:strike]
+              codes << Shoko::Shared::Terminal::Ansi::DIM if styles[:prefix] || styles[:dim]
+
+              codes.join + content + Shoko::Shared::Terminal::Ansi::RESET
+            end
+
+            private
+
+            def transform_inline_position(content, styles)
+              return content unless styles[:superscript] || styles[:subscript]
+
+              map = styles[:superscript] ? SUPERSCRIPT_MAP : SUBSCRIPT_MAP
+              content.each_char.map do |char|
+                map[char] || map[char.downcase] || char
+              end.join
+            end
+
+            def canonical_block_type(metadata)
+              return nil unless metadata
+
+              raw = metadata[:block_type] || metadata['block_type']
+              Shoko::Core::Models::BlockType.canonical(raw) || raw
+            end
+
+            def color_for(styles, block_type, highlight_allowed)
+              if styles[:code] || block_type == :code
+                color(:code)
+              elsif styles[:accent] || styles[:highlight] || styles[:keyword]
+                color(:accent)
+              elsif block_type == :heading
+                highlight_allowed ? color(:heading) : color(:primary)
+              elsif block_type == :quote || styles[:quote]
+                highlight_allowed ? color(:quote) : color(:primary)
+              elsif block_type == :separator
+                color(:separator)
+              elsif styles[:prefix]
+                color(:prefix)
+              else
+                color(:primary)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/ui/components/screen_component.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'base_component'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        # Universal screen component that can render any screen type
+        # Provides a unified interface for screen rendering
+        class ScreenComponent < BaseComponent
+          def initialize(screen_manager)
+            super()
+            @screen_manager = screen_manager
+          end
+
+          def render(surface, bounds)
+            @screen_manager.render_current_screen(surface, bounds)
+          end
+
+          def preferred_height(_available_height)
+            :fill
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/ui/components/screens/annotation_detail_screen_component.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require_relative '../base_component'
+require_relative '../../constants/ui_constants'
+require_relative '../ui/text_utils'
+require_relative '../menu_design/frame_renderer'
+require_relative '../menu_design/layout'
+require_relative '../menu_design/status_renderer'
+require_relative '../../../../shared/terminal/text_sanitizer'
+require_relative '../../../../shared/terminal/ansi'
+require_relative 'annotation_rendering_helpers'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module Screens
+          # Detailed view for a selected annotation with readable sections.
+          class AnnotationDetailScreenComponent < BaseComponent
+            include Adapters::Ui::Constants::Ui
+            include Ui::TextUtils
+            include AnnotationScreenRendering
+
+            def initialize(dependencies: nil, menu_visual_profile: nil)
+              super()
+              @dependencies = dependencies
+              @menu_visual_profile = menu_visual_profile
+              @menu_state_reader = nil
+            end
+
+            def do_render(surface, bounds)
+              annotation = selected_annotation
+              view = annotation ? AnnotationView.new(annotation) : nil
+
+              frame = MenuDesign::FrameRenderer.new(surface, bounds)
+              frame.render_title(title: 'Annotation Detail', hint: 'O open  E edit  D delete  ESC back')
+              frame.render_divider
+
+              unless view
+                render_empty(surface, bounds)
+                frame.render_footer(text: 'No annotation selected')
+                return
+              end
+
+              layout = compute_layout(bounds)
+              render_status(surface, bounds, layout, view)
+              render_sections(surface, bounds, layout, view)
+              frame.render_footer(text: footer_text(view))
+            end
+
+            def preferred_height(_available_height)
+              :fill
+            end
+
+            private
+
+            def render_empty(surface, bounds)
+              MenuDesign::StatusRenderer.new(surface, bounds).render_empty(
+                row: bounds.height / 2,
+                indent: 2,
+                message: 'Select an annotation from the list to inspect details.',
+                color: COLOR_TEXT_DIM
+              )
+            end
+
+            def render_status(surface, bounds, layout, annotation)
+              left = "Book • #{resolve_book_label}"
+              right_parts = [
+                "Ch #{annotation.chapter_index || '—'}",
+                annotation.page_meta && "Page #{annotation.page_meta}"
+              ].compact
+
+              MenuDesign::StatusRenderer.new(surface, bounds).render_status(
+                row: layout[:status_row],
+                indent: layout[:content_indent],
+                left: truncate_text(left, [layout[:content_width] - 10, 8].max),
+                right: right_parts.join('  •  '),
+                width: layout[:content_width],
+                left_color: COLOR_TEXT_DIM,
+                right_color: COLOR_TEXT_DIM
+              )
+            end
+
+            def render_sections(surface, bounds, layout, annotation)
+              available_rows = [layout[:content_bottom] - layout[:content_top] + 1, 6].max
+              quote_budget = [[(available_rows * 0.55).floor, 4].max, available_rows - 3].min
+              note_budget = [available_rows - quote_budget - 3, 2].max
+
+              quote_lines = wrap_block(annotation.text, layout[:content_width] - 3, empty: 'No selected text.')
+              note_lines = wrap_block(annotation.note, layout[:content_width] - 3, empty: 'No note added yet.')
+
+              row = layout[:content_top]
+              row = render_section(
+                surface,
+                bounds,
+                row,
+                layout[:content_indent],
+                layout[:content_width],
+                'Selected Text',
+                quote_lines,
+                quote_budget,
+                prefix: '│ '
+              )
+
+              row += 1
+              render_section(
+                surface,
+                bounds,
+                row,
+                layout[:content_indent],
+                layout[:content_width],
+                'Note',
+                note_lines,
+                note_budget,
+                prefix: '  '
+              )
+            end
+
+            def render_section(surface, bounds, start_row, indent, width, title, lines, budget, prefix:)
+              title_style = "#{Shoko::Shared::Terminal::Ansi::BOLD}#{COLOR_TEXT_ACCENT}"
+              reset = Shoko::Shared::Terminal::Ansi::RESET
+              surface.write(bounds, start_row, indent, "#{title_style}#{title}#{reset}")
+              surface.write(bounds, start_row + 1, indent, "#{COLOR_TEXT_DIM}#{'─' * width}#{reset}")
+
+              usable = [budget, 1].max
+              clipped = clip_lines(lines, usable)
+              clipped.each_with_index do |line, offset|
+                content = truncate_text("#{prefix}#{line}", width)
+                surface.write(bounds, start_row + 2 + offset, indent, pad_right(content, width))
+              end
+
+              start_row + 2 + usable
+            end
+
+            def clip_lines(lines, max_lines)
+              return [] if max_lines <= 0
+              return lines.first(max_lines) if lines.length <= max_lines
+
+              clipped = lines.first(max_lines)
+              clipped[-1] = truncate_text('…', [clipped[-1].to_s.length, 1].max)
+              clipped
+            end
+
+            def wrap_block(text, width, empty:)
+              clean = safe_text(text.to_s)
+              clean = empty if clean.strip.empty?
+              wrap_text(clean, [width, 8].max)
+            end
+
+            def compute_layout(bounds)
+              content_width = MenuDesign::Layout.centered_content_width(bounds, preferred: 104, min: 52,
+                                                                        horizontal_padding: 8)
+              indent = MenuDesign::Layout.centered_indent(bounds, content_width)
+
+              {
+                status_row: 3,
+                content_indent: indent,
+                content_width: content_width,
+                content_top: 5,
+                content_bottom: bounds.height - 2,
+              }
+            end
+
+            def footer_text(annotation)
+              saved = annotation.formatted_date.to_s.strip
+              saved = 'unknown' if saved.empty?
+              "Saved #{saved}"
+            end
+
+            def selected_annotation
+              ann = menu_state_reader&.selected_annotation
+              ann if ann.is_a?(Hash)
+            end
+
+            def menu_state_reader
+              return @menu_state_reader if @menu_state_reader
+
+              @menu_state_reader = @dependencies&.menu_state_reader
+            end
+
+            def safe_text(text)
+              Shoko::Shared::Terminal::TextSanitizer.sanitize(
+                text,
+                preserve_newlines: false,
+                preserve_tabs: false
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end