shoko 0.1.3 → 0.1.5

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative '../base_component'
+require_relative '../rect'
+
+module Shoko
+  module Adapters
+    module Ui
+      module 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
+
+              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
+  end
+end

data/lib/shoko/adapters/ui/components/layouts/horizontal_three.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative '../base_component'
+require_relative '../rect'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module Layouts
+          # Horizontal layout that splits children left, center, and right.
+          # Uses left/right preferred widths and assigns remaining space to center.
+          class HorizontalThree < BaseComponent
+            include Adapters::Ui::Constants::Ui
+
+            def initialize(left_child, center_child, right_child)
+              super(nil)
+              @left_child = left_child
+              @center_child = center_child
+              @right_child = right_child
+            end
+
+            def do_render(surface, bounds)
+              return unless @center_child
+
+              x = bounds.x
+              y = bounds.y
+              w = bounds.width
+              h = bounds.height
+
+              left_width = resolve_left_width(w)
+              remaining = [w - left_width, 0].max
+              right_width = resolve_right_width(w, remaining)
+              center_width = [w - left_width - right_width, 0].max
+
+              if left_width.positive? && @left_child
+                left_bounds = Rect.new(x: x, y: y, width: left_width, height: h)
+                @left_child.render(surface, left_bounds)
+              end
+
+              if center_width.positive?
+                center_bounds = Rect.new(x: x + left_width, y: y, width: center_width, height: h)
+                @center_child.render(surface, center_bounds)
+              end
+
+              return unless right_width.positive? && @right_child
+
+              right_bounds = Rect.new(x: x + left_width + center_width, y: y, width: right_width, height: h)
+              @right_child.render(surface, right_bounds)
+            end
+
+            private
+
+            def resolve_left_width(total_width)
+              return 0 unless @left_child
+
+              pref = @left_child.preferred_width(total_width)
+              resolve_width(pref, total_width)
+            end
+
+            def resolve_right_width(total_width, remaining)
+              return 0 unless @right_child
+
+              pref = begin
+                @right_child.preferred_width(total_width, nil, available_width: remaining)
+              rescue ArgumentError
+                @right_child.preferred_width(total_width)
+              end
+              width = resolve_width(pref, remaining)
+
+              return 0 if width <= 0
+              return 0 if remaining - width < MIN_WIDTH
+
+              width
+            end
+
+            def resolve_width(pref, max_width)
+              case pref
+              when Integer
+                [pref, max_width].min
+              when :flexible
+                max_width / 3
+              when :hidden, nil
+                0
+              else
+                0
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative '../base_component'
+require_relative '../rect'
+
+module Shoko
+  module Adapters
+    module Ui
+      module 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 ? 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
+  end
+end

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require_relative 'base_component'
+require_relative 'layouts/vertical'
+require_relative 'screens/menu_screen_component'
+require_relative 'screens/browse_screen_component'
+require_relative 'screens/library_screen_component'
+require_relative 'screens/settings_screen_component'
+require_relative 'screens/dictionary_settings_screen_component'
+require_relative 'screens/download_books_screen_component'
+require_relative 'screens/annotations_screen_component'
+require_relative 'screens/annotation_edit_screen_component'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        # Root component for the main menu system
+        class MainMenuComponent < BaseComponent
+          def initialize(main_menu, menu_ui_dependencies:, menu_visual_profile: nil)
+            super()
+            @main_menu = main_menu
+            @observer_registry = main_menu.observer_registry
+            @menu_ui_dependencies = menu_ui_dependencies
+            @menu_visual_profile = menu_visual_profile
+            @catalog = @main_menu.catalog
+
+            setup_screen_components
+
+            # Initialize current screen
+            @current_screen = @screen_components[:menu]
+
+            # Observe mode changes to switch active component
+            @observer_registry.add_observer(self, %i[menu mode], %i[menu selected])
+          end
+
+          def state_changed(path, _old_value, new_value)
+            return unless path == %i[menu mode]
+
+            mapped = case new_value
+                     when :search then :browse
+                     when :dictionary_search then :dictionary
+                     when :download_search, :download then :download
+                     else new_value
+                     end
+            @current_screen = @screen_components[mapped] || @screen_components[:menu]
+          end
+
+          def do_render(surface, bounds)
+            current_screen&.render(surface, bounds)
+          end
+
+          def preferred_height(_available_height)
+            :fill
+          end
+
+          attr_reader :current_screen
+
+          # Delegate screen-specific methods
+          def browse_screen
+            @screen_components[:browse]
+          end
+
+          def library_screen
+            @screen_components[:library]
+          end
+
+          # recent screen removed
+
+          def settings_screen
+            @screen_components[:settings]
+          end
+
+          def download_books_screen
+            @screen_components[:download]
+          end
+
+          def annotations_screen
+            @screen_components[:annotations]
+          end
+
+          def annotation_detail_screen
+            @screen_components[:annotation_detail]
+          end
+
+          private
+
+          def setup_screen_components
+            @screen_components = {
+              menu: Screens::MenuScreenComponent.new(@observer_registry, @menu_ui_dependencies,
+                                                     menu_visual_profile: @menu_visual_profile),
+              browse: Screens::BrowseScreenComponent.new(@catalog, @observer_registry, @menu_ui_dependencies,
+                                                         menu_visual_profile: @menu_visual_profile),
+              library: Screens::LibraryScreenComponent.new(@observer_registry, @menu_ui_dependencies,
+                                                           menu_visual_profile: @menu_visual_profile),
+              settings: Screens::SettingsScreenComponent.new(@catalog, dependencies: @menu_ui_dependencies,
+                                                                       menu_visual_profile: @menu_visual_profile),
+              dictionary: Screens::DictionarySettingsScreenComponent.new(
+                dependencies: @menu_ui_dependencies,
+                menu_visual_profile: @menu_visual_profile
+              ),
+              download: Screens::DownloadBooksScreenComponent.new(
+                dependencies: @menu_ui_dependencies,
+                menu_visual_profile: @menu_visual_profile
+              ),
+              annotations: Screens::AnnotationsScreenComponent.new(
+                dependencies: @menu_ui_dependencies,
+                menu_visual_profile: @menu_visual_profile
+              ),
+              annotation_editor: Screens::AnnotationEditScreenComponent.new(
+                @menu_ui_dependencies,
+                menu_visual_profile: @menu_visual_profile
+              ),
+              annotation_detail: Screens::AnnotationDetailScreenComponent.new(
+                dependencies: @menu_ui_dependencies,
+                menu_visual_profile: @menu_visual_profile
+              ),
+            }
+          end
+
+          public
+
+          def annotation_edit_screen
+            @screen_components[:annotation_editor]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative '../../../../shared/terminal/text_metrics'
+require_relative 'theme_tokens'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module MenuDesign
+          # Canonical top/bottom shell renderer for menu-mode screens.
+          class FrameRenderer
+            SHELL_MAX_WIDTH = 98
+            SHELL_MIN_WIDTH = 40
+            SHELL_MARGIN = 4
+
+            def initialize(surface, bounds, tokens: ThemeTokens.new)
+              @surface = surface
+              @bounds = bounds
+              @tokens = tokens
+            end
+
+            def render_title(title:, hint: nil, row: 1, indent: 2)
+              shell = shell_metrics
+              write_title_row(row, shell[:indent], shell[:width], title.to_s, indent)
+              write_hint(row, shell[:indent], shell[:width], hint) if hint && !hint.to_s.strip.empty?
+            end
+
+            def render_divider(row: 2, indent: 1, width: nil, char: '─')
+              shell = divider_shell(indent, width)
+              line = char * [shell[:width], 1].max
+              @surface.write(@bounds, row, shell[:indent], "#{@tokens.divider}#{line}#{@tokens.reset}")
+            end
+
+            def render_footer(text: nil, row: nil, indent: 2)
+              row ||= @bounds.height - 1
+              return if text.to_s.strip.empty?
+
+              shell = shell_metrics
+              inner = [shell[:width] - 4, 1].max
+              clipped = Shoko::Shared::Terminal::TextMetrics.truncate_to(text.to_s, inner)
+              content_col = [shell[:indent], indent].max
+              @surface.write(@bounds, row, content_col, "#{@tokens.dim}#{clipped}#{@tokens.reset}")
+            end
+
+            private
+
+            def shell_metrics
+              width = [@bounds.width - SHELL_MARGIN, SHELL_MAX_WIDTH].min
+              width = [width, SHELL_MIN_WIDTH].max
+              width = [width, @bounds.width - 2].min
+              indent = ((@bounds.width - width) / 2).floor
+              indent = indent.clamp(2, [@bounds.width - width, 2].max)
+              { indent: indent, width: width }
+            end
+
+            def divider_shell(indent, width)
+              return shell_metrics if full_width_divider?(indent, width)
+
+              usable = width || (@bounds.width - indent + 1)
+              { indent: indent, width: [usable, 1].max }
+            end
+
+            def write_title_row(row, shell_indent, shell_width, title, indent)
+              brand = @tokens.brand_badge
+              content_col = [shell_indent, indent].max
+              @surface.write(@bounds, row, content_col, brand)
+
+              brand_w = Shoko::Shared::Terminal::TextMetrics.visible_length('SHOKO')
+              title_col = content_col + brand_w + 2
+              max_title_w = [shell_width - (title_col - shell_indent) - 2, 1].max
+              clipped_title = Shoko::Shared::Terminal::TextMetrics.truncate_to(title, max_title_w)
+              @surface.write(@bounds, row, title_col, "#{@tokens.heading}#{clipped_title}#{@tokens.reset}")
+            end
+
+            def write_hint(row, shell_indent, shell_width, hint)
+              hint_text = hint.to_s
+              hint_width = Shoko::Shared::Terminal::TextMetrics.visible_length(hint_text)
+              min_col = shell_indent + 20
+              max_col = shell_indent + shell_width - hint_width - 1
+              col = [max_col, min_col].max
+              @surface.write(@bounds, row, col, "#{@tokens.dim}#{hint_text}#{@tokens.reset}")
+            end
+
+            def full_width_divider?(indent, width)
+              indent.to_i <= 1 && width.nil?
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module MenuDesign
+          # Centralized icon lookup with optional ASCII fallback for limited fonts.
+          module IconSet
+            ICONS = {
+              browse: '󱉟',
+              library: '',
+              annotations: '',
+              download: '',
+              settings: '',
+              quit: '',
+              back: '',
+              view_mode: '',
+              line_spacing: '',
+              page_mode: '',
+              page_numbers: '',
+              highlight: '',
+              dictionary: '',
+              images: '',
+              wipe: '',
+              checkbox: '',
+            }.freeze
+
+            ASCII = {
+              browse: '[B]',
+              library: '[L]',
+              annotations: '[A]',
+              download: '[D]',
+              settings: '[S]',
+              quit: '[Q]',
+              back: '<-',
+              view_mode: '[V]',
+              line_spacing: '[LS]',
+              page_mode: '[PM]',
+              page_numbers: '[#]',
+              highlight: '[H]',
+              dictionary: '[Dict]',
+              images: '[Img]',
+              wipe: '[!]',
+              checkbox: '',
+            }.freeze
+
+            module_function
+
+            def icon_for(key)
+              return ASCII[key].to_s if ascii_icons?
+
+              ICONS[key].to_s
+            end
+
+            def selection_pointer
+              ascii_icons? ? '> ' : '▸ '
+            end
+
+            def ascii_icons?
+              val = ENV.fetch('SHOKO_ASCII_ICONS', '').to_s.strip.downcase
+              %w[1 true yes on].include?(val)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module MenuDesign
+          # Shared layout math for centered menu content blocks.
+          module Layout
+            module_function
+
+            def centered_content_width(bounds, preferred:, min: 24, horizontal_padding: 6)
+              width = [bounds.width - horizontal_padding, preferred].min
+              [[width, min].max, [bounds.width - 2, min].max].min
+            end
+
+            def centered_indent(bounds, content_width, min: 2)
+              indent = ((bounds.width - content_width) / 2).floor
+              indent.clamp(min, [bounds.width - content_width, min].max)
+            end
+
+            def centered_row(bounds, top:, bottom:, content_rows:)
+              return top if content_rows <= 0
+
+              row = (bounds.height - content_rows) / 2
+              row.clamp(top, [bottom - content_rows, top].max)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative '../../../../shared/terminal/text_metrics'
+require_relative 'theme_tokens'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module MenuDesign
+          # Shared horizontal progress bar rendering for menu workflows.
+          class ProgressRenderer
+            def initialize(surface, bounds, tokens: ThemeTokens.new)
+              @surface = surface
+              @bounds = bounds
+              @tokens = tokens
+            end
+
+            def render(row:, indent:, width:, progress:, filled_char: '━', empty_char: '─')
+              usable = [width.to_i, 14].max
+              ratio = progress.to_f.clamp(0.0, 1.0)
+              pct = (ratio * 100).round
+              meter_w = [usable - 7, 8].max
+              filled = (meter_w * ratio).round
+              line = "#{@tokens.divider}⟮#{@tokens.reset}"
+              line += "#{@tokens.accent}#{filled_char * filled}#{@tokens.reset}"
+              line += "#{@tokens.divider}#{empty_char * (meter_w - filled)}#{@tokens.reset}" if filled < meter_w
+              line += "#{@tokens.divider}⟯#{@tokens.reset} #{@tokens.dim}#{pct}%#{@tokens.reset}"
+              @surface.write(@bounds, row, indent, line)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative '../../../../shared/terminal/text_metrics'
+require_relative 'theme_tokens'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module MenuDesign
+          # Consistent search field rendering for menu list screens.
+          class SearchFieldRenderer
+            def initialize(surface, bounds, tokens: ThemeTokens.new)
+              @surface = surface
+              @bounds = bounds
+              @tokens = tokens
+            end
+
+            def render(label:, query:, cursor:, row:, indent:, width:, active:)
+              label_text = label.to_s.upcase
+              @surface.write(@bounds, row, indent, "#{@tokens.dim}#{label_text}#{@tokens.reset}")
+
+              usable = [width.to_i, 10].max
+              inner = [usable - 4, 1].max
+              text = query.to_s.dup
+              c = cursor.to_i.clamp(0, text.length)
+              text.insert(c, @tokens.cursor_glyph)
+              clipped = Shoko::Shared::Terminal::TextMetrics.truncate_to(text, inner)
+              body = Shoko::Shared::Terminal::TextMetrics.pad_right(clipped, inner)
+
+              border_color = active ? @tokens.accent : @tokens.divider
+              text_color = active ? @tokens.primary : @tokens.dim
+              line = "#{border_color}[#{@tokens.reset} #{text_color}#{body}#{@tokens.reset} #{border_color}]#{@tokens.reset}"
+              @surface.write(@bounds, row + 1, indent, line)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative '../../../../shared/terminal/text_metrics'
+require_relative 'theme_tokens'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module MenuDesign
+          # Unified status and empty-state rendering for menu screens.
+          class StatusRenderer
+            def initialize(surface, bounds, tokens: ThemeTokens.new)
+              @surface = surface
+              @bounds = bounds
+              @tokens = tokens
+            end
+
+            def render_status(row:, indent:, left:, right: nil, width: nil, left_color: nil, right_color: nil)
+              left_color ||= @tokens.dim
+              right_color ||= @tokens.dim
+              @surface.write(@bounds, row, indent, "#{left_color}#{left}#{@tokens.reset}")
+              return if right.to_s.empty?
+
+              left_width = Shoko::Shared::Terminal::TextMetrics.visible_length(left.to_s)
+              area_right = if width.to_i.positive?
+                             [indent + width.to_i - 1, @bounds.width].min
+                           else
+                             @bounds.width
+                           end
+              min_col = indent + left_width + 2
+              max_right_width = [area_right - min_col + 1, 1].max
+              clipped_right = Shoko::Shared::Terminal::TextMetrics.truncate_to(right.to_s, max_right_width)
+              right_width = Shoko::Shared::Terminal::TextMetrics.visible_length(clipped_right)
+              max_col = area_right - right_width + 1
+              col = [max_col, min_col].max
+              @surface.write(@bounds, row, col, "#{right_color}#{clipped_right}#{@tokens.reset}")
+            end
+
+            def render_empty(row:, indent:, message:, color: nil)
+              color ||= @tokens.dim
+              @surface.write(@bounds, row, indent, "#{color}#{message}#{@tokens.reset}")
+            end
+          end
+        end
+      end
+    end
+  end
+end