shoko 0.1.0

data/lib/shoko/adapters/output/ui/components/reading/single_view_renderer.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require_relative 'base_view_renderer'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    module Reading
+      # Renderer for single-view reading mode (supports both dynamic and absolute page numbering)
+      class SingleViewRenderer < BaseViewRenderer
+        # Layout metrics for single-view rendering.
+        SingleLayout = Struct.new(
+          :col_width,
+          :content_height,
+          :spacing,
+          :displayable,
+          :col_start,
+          keyword_init: true
+        )
+
+        # Encapsulates per-render state shared across helpers.
+        RenderFrame = Struct.new(:surface, :bounds, :context, :layout, keyword_init: true)
+
+        private_constant :SingleLayout, :RenderFrame
+
+        def initialize(dependencies, page_numbering_mode: :dynamic)
+          super(dependencies)
+          @page_numbering_mode = page_numbering_mode
+        end
+
+        def render_with_context(surface, bounds, context)
+          mode = context.page_numbering_mode || @page_numbering_mode
+          if mode == :dynamic
+            render_dynamic_mode_with_context(surface, bounds, context)
+          else
+            render_absolute_mode_with_context(surface, bounds, context)
+          end
+        end
+
+        private
+
+        # Context-based rendering methods
+        def render_dynamic_mode_with_context(surface, bounds, context)
+          layout = single_layout(bounds, context.config)
+          frame = RenderFrame.new(surface: surface, bounds: bounds, context: context, layout: layout)
+
+          page_data = context.page_calculator&.get_page(context.current_page_index)
+          lines, line_offset = page_data ? dynamic_window(frame, page_data) : dynamic_fallback_window(frame)
+          render_single_column(frame, lines, line_offset)
+        end
+
+        def render_absolute_mode_with_context(surface, bounds, context)
+          chapter = context.current_chapter
+          return unless chapter
+
+          state_store = context&.state
+          return unless state_store
+
+          layout = single_layout(bounds, context.config)
+          frame = RenderFrame.new(surface: surface, bounds: bounds, context: context, layout: layout)
+
+          offset = state_store.get(%i[reader single_page]) || 0
+          chapter_index = state_store.get(%i[reader current_chapter]) || 0
+          lines, line_offset = fetch_window(
+            frame,
+            chapter_index: chapter_index,
+            offset: offset,
+            length: layout.displayable
+          )
+          render_single_column(frame, lines, line_offset)
+        end
+
+        def single_layout(bounds, config)
+          col_width, content_height, spacing, displayable = compute_layout(bounds, :single, config)
+          SingleLayout.new(
+            col_width: col_width,
+            content_height: content_height,
+            spacing: spacing,
+            displayable: displayable,
+            col_start: center_start_col(bounds.width, col_width)
+          )
+        end
+
+        def dynamic_window(frame, page_data)
+          context = frame.context
+          layout = frame.layout
+
+          line_offset = page_data[:start_line].to_i
+          end_line = page_data[:end_line].to_i
+          span_length = [end_line - line_offset + 1, layout.displayable].max
+          state = context.state
+          chapter_index = (page_data[:chapter_index] || state&.get(%i[reader current_chapter]) || 0).to_i
+          request = { chapter_index: chapter_index, offset: line_offset, length: span_length }
+
+          lines = page_data[:lines] || []
+          resolve_dynamic_lines(frame, lines, request)
+        end
+
+        def resolve_dynamic_lines(frame, lines, request)
+          return fetch_window(frame, request) if lines.empty?
+
+          line_offset = request.fetch(:offset)
+          snapped = snap_offset_to_image_start(lines, line_offset)
+          return [lines, line_offset] if snapped == line_offset
+
+          fetch_window(frame, request.merge(offset: snapped))
+        end
+
+        def dynamic_fallback_window(frame)
+          context = frame.context
+          layout = frame.layout
+
+          displayable = layout.displayable
+          chapter_index = context&.state&.get(%i[reader current_chapter]) || 0
+          offset = compute_dynamic_offset(context, displayable)
+          fetch_window(frame, chapter_index: chapter_index, offset: offset, length: displayable)
+        end
+
+        def fetch_window(frame, request)
+          context = frame.context
+          layout = frame.layout
+
+          fetch_wrapped_lines_with_offset(
+            document: context.document,
+            chapter_index: request.fetch(:chapter_index),
+            col_width: layout.col_width,
+            offset: request.fetch(:offset),
+            length: request.fetch(:length)
+          )
+        end
+
+        def compute_dynamic_offset(context, displayable)
+          pending = context.state.get(%i[reader pending_progress]) if context&.state
+          line_offset = pending && (pending[:line_offset] || pending['line_offset'])
+          return line_offset.to_i if line_offset
+
+          (context.current_page_index || 0) * [displayable, 1].max
+        end
+
+        def render_single_column(frame, lines, line_offset)
+          layout = frame.layout
+          context = frame.context
+
+          start_row = calculate_center_start_row(layout.content_height, lines.size, layout.spacing)
+          params = Adapters::Output::Rendering::Models::RenderParams.new(start_row: start_row, col_start: layout.col_start,
+                                            col_width: layout.col_width, context: context,
+                                            line_offset: line_offset,
+                                            page_id: context.current_page_index,
+                                            column_id: 0)
+          draw_lines(frame.surface, frame.bounds, lines, params)
+        end
+
+        # helpers provided by BaseViewRenderer
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/ui/components/reading/split_view_renderer.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require_relative 'base_view_renderer'
+require_relative '../render_style'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    module Reading
+      # Renderer for split-view (two-column) reading mode
+      # Supports both dynamic and absolute page numbering modes
+      class SplitViewRenderer < BaseViewRenderer
+        LEFT_MARGIN = Shoko::Core::Services::LayoutService::SPLIT_LEFT_MARGIN
+        RIGHT_MARGIN = Shoko::Core::Services::LayoutService::SPLIT_RIGHT_MARGIN
+        COLUMN_GAP = Shoko::Core::Services::LayoutService::SPLIT_COLUMN_GAP
+        COLUMN_START_ROW = 3
+
+        # Layout metrics for split-view rendering.
+        SplitLayout = Struct.new(
+          :col_width,
+          :content_height,
+          :spacing,
+          :displayable,
+          :left_start,
+          :right_start,
+          :divider_col,
+          keyword_init: true
+        )
+
+        # Encapsulates per-render state shared across helpers.
+        RenderFrame = Struct.new(:surface, :bounds, :context, :layout, keyword_init: true)
+
+        private_constant :SplitLayout, :RenderFrame
+
+        def render_with_context(surface, bounds, context)
+          mode = context.page_numbering_mode || :dynamic
+          if mode == :dynamic
+            render_dynamic_mode_with_context(surface, bounds, context)
+          else
+            render_absolute_mode_with_context(surface, bounds, context)
+          end
+        end
+
+        private
+
+        # Divider provided by BaseViewRenderer#draw_divider
+
+        def render_column_lines(frame, lines, params)
+          draw_lines(frame.surface, frame.bounds, lines, params)
+        end
+
+        # Context-based rendering methods
+        def render_dynamic_mode_with_context(surface, bounds, context)
+          layout = split_layout(bounds, context.config)
+          frame = RenderFrame.new(surface: surface, bounds: bounds, context: context, layout: layout)
+          render_chapter_header(frame)
+
+          left_pd = context.page_calculator&.get_page(context.current_page_index)
+          if left_pd
+            render_dynamic_from_page_data(frame, left_pd)
+          else
+            render_dynamic_fallback(frame)
+          end
+        end
+
+        def render_absolute_mode_with_context(surface, bounds, context)
+          chapter = context.current_chapter
+          return unless chapter
+
+          st = context&.state
+          return unless st
+
+          layout = split_layout(bounds, context.config)
+          frame = RenderFrame.new(surface: surface, bounds: bounds, context: context, layout: layout)
+          render_chapter_header(frame)
+
+          display_height = layout.displayable
+          left_offset = st.get(%i[reader left_page]) || 0
+          right_offset = st.get(%i[reader right_page]) || display_height
+          render_absolute_columns(frame, left_offset, right_offset)
+        end
+
+        def render_chapter_header(frame)
+          chapter = frame.context.current_chapter
+          return unless chapter
+
+          header_col = LEFT_MARGIN + 1
+          frame.surface.write(frame.bounds, 1, header_col, chapter_header_line(frame, chapter, header_col))
+        end
+
+        def chapter_header_line(frame, chapter, header_col)
+          bounds = frame.bounds
+          idx = frame.context.state.get(%i[reader current_chapter]) + 1
+          info = "[#{idx}] #{chapter.title || 'Unknown'}"
+          available = bounds.width - LEFT_MARGIN - RIGHT_MARGIN
+          start_column = bounds.x + header_col - 2
+          clipped = Shoko::Adapters::Output::Terminal::TextMetrics.truncate_to(info, available, start_column: start_column)
+          heading_color = Shoko::Adapters::Output::Ui::Components::RenderStyle.color(:heading)
+          heading_color + clipped + Terminal::ANSI::RESET
+        end
+
+        def render_dynamic_from_page_data(frame, left_page_data)
+          layout = frame.layout
+          context = frame.context
+          page_id = context.current_page_index
+          right_page_id = page_id ? page_id + 1 : nil
+
+          render_page_data_column(frame, left_page_data,
+                                  { start_col: layout.left_start, column_id: 0, page_id: page_id })
+          draw_divider(frame.surface, frame.bounds, layout.divider_col)
+
+          right_page_data = page_id ? context.page_calculator&.get_page(page_id + 1) : nil
+          return unless right_page_data
+
+          render_page_data_column(frame, right_page_data,
+                                  { start_col: layout.right_start, column_id: 1, page_id: right_page_id })
+        end
+
+        def render_dynamic_fallback(frame)
+          layout = frame.layout
+          page_id = frame.context.current_page_index
+          right_page_id = page_id ? page_id + 1 : nil
+
+          displayable = layout.displayable
+          base_offset = (page_id || 0) * [displayable, 1].max
+
+          render_offset_column(frame, base_offset,
+                               { start_col: layout.left_start, column_id: 0, page_id: page_id })
+          draw_divider(frame.surface, frame.bounds, layout.divider_col)
+
+          render_offset_column(frame, base_offset + displayable,
+                               { start_col: layout.right_start, column_id: 1, page_id: right_page_id })
+        end
+
+        def render_offset_column(frame, offset, column_spec)
+          displayable = frame.layout.displayable
+          lines, line_offset = fetch_wrapped_lines_window(frame, offset, displayable)
+          render_column_lines(frame, lines, column_params(frame, column_spec, line_offset))
+          line_offset
+        end
+
+        def render_absolute_columns(frame, left_offset, right_offset)
+          layout = frame.layout
+          page_id = frame.context.current_page_index
+
+          left_render_offset = render_offset_column(
+            frame,
+            left_offset,
+            { start_col: layout.left_start, column_id: 0, page_id: page_id }
+          )
+          draw_divider(frame.surface, frame.bounds, layout.divider_col)
+
+          display_height = layout.displayable
+          paired = right_offset.to_i == left_offset.to_i + display_height
+          right_input = paired ? left_render_offset + display_height : right_offset
+          render_offset_column(frame, right_input,
+                               { start_col: layout.right_start, column_id: 1, page_id: page_id })
+        end
+
+        def fetch_wrapped_lines_window(frame, offset, length)
+          st = frame.context.state
+          chapter_index = st.get(%i[reader current_chapter]) || 0
+          fetch_wrapped_lines_with_offset(
+            document: frame.context.document,
+            chapter_index: chapter_index,
+            col_width: frame.layout.col_width,
+            offset: offset,
+            length: length
+          )
+        end
+
+        def column_lines_from_page_data(frame, page_data)
+          line_offset = page_data[:start_line].to_i
+          lines = page_data[:lines]
+          end_line = page_data[:end_line].to_i
+          span_length = [end_line - line_offset + 1, 1].max
+
+          return fetch_wrapped_lines_window(frame, line_offset, span_length) if lines.nil? || lines.empty?
+
+          snapped = snap_offset_to_image_start(lines, line_offset)
+          return [lines, line_offset] if snapped == line_offset
+
+          fetch_wrapped_lines_window(frame, snapped, span_length)
+        end
+
+        def render_page_data_column(frame, page_data, column_spec)
+          lines, line_offset = column_lines_from_page_data(frame, page_data)
+          render_column_lines(frame, lines, column_params(frame, column_spec, line_offset))
+        end
+
+        def column_params(frame, column_spec, line_offset)
+          Adapters::Output::Rendering::Models::RenderParams.new(
+            start_row: COLUMN_START_ROW,
+            col_start: column_spec.fetch(:start_col),
+            col_width: frame.layout.col_width,
+            context: frame.context,
+            column_id: column_spec.fetch(:column_id),
+            line_offset: line_offset,
+            page_id: column_spec[:page_id]
+          )
+        end
+
+        def split_layout(bounds, config)
+          col_width, content_height, spacing, displayable = compute_layout(bounds, :split, config)
+          left_start = LEFT_MARGIN + 1
+          right_start = left_start + col_width + COLUMN_GAP
+          divider_col = left_start + col_width + 1
+
+          SplitLayout.new(
+            col_width: col_width,
+            content_height: content_height,
+            spacing: spacing,
+            displayable: displayable,
+            left_start: left_start,
+            right_start: right_start,
+            divider_col: divider_col
+          )
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/ui/components/reading/view_renderer_factory.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    module Reading
+      # Factory for creating appropriate view renderers based on configuration
+      class ViewRendererFactory
+        def self.create(state, dependencies)
+          case Application::Selectors::ConfigSelectors.view_mode(state)
+          when :split
+            SplitViewRenderer.new(dependencies)
+          else
+            mode = Application::Selectors::ConfigSelectors.page_numbering_mode(state)
+            SingleViewRenderer.new(dependencies, page_numbering_mode: mode)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/ui/components/reading/wrapped_lines_fetcher.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    module Reading
+      # Fetches wrapped lines from the document using the formatting and wrapping services.
+      #
+      # Also applies the "image block offset snap" behavior so paging doesn't land in the
+      # middle of a Kitty image placeholder block (which can cause disappearing images).
+      class WrappedLinesFetcher
+        def initialize(dependencies)
+          @dependencies = dependencies
+        end
+
+        def fetch(document:, chapter_index:, col_width:, offset:, length:)
+          chapter = document&.get_chapter(chapter_index)
+          return [] unless chapter
+
+          lines = fetch_via_formatting_service(document: document, chapter_index: chapter_index, col_width: col_width,
+                                               offset: offset, length: length)
+          return lines unless lines.empty?
+
+          lines = fetch_via_wrapping_service(chapter: chapter, chapter_index: chapter_index, col_width: col_width,
+                                             offset: offset, length: length)
+          return lines unless lines.empty?
+
+          fallback_lines(chapter, offset, length)
+        end
+
+        def fetch_with_offset(document:, chapter_index:, col_width:, offset:, length:)
+          offset_i = offset.to_i
+          lines = fetch(document: document, chapter_index: chapter_index, col_width: col_width, offset: offset_i,
+                        length: length)
+          snapped = snap_offset_to_image_start(lines, offset_i)
+          return [lines, offset_i] if snapped == offset_i
+
+          [fetch(document: document, chapter_index: chapter_index, col_width: col_width, offset: snapped,
+                 length: length), snapped]
+        end
+
+        def snap_offset_to_image_start(lines, offset)
+          offset_i = offset.to_i
+          return offset_i if offset_i <= 0
+
+          meta = image_block_metadata(lines)
+          return offset_i unless meta
+
+          idx = image_line_index(meta)
+          return offset_i unless idx
+
+          snapped_offset(offset_i, idx)
+        rescue StandardError
+          offset.to_i
+        end
+
+        private
+
+        def fetch_via_formatting_service(document:, chapter_index:, col_width:, offset:, length:)
+          return [] unless @dependencies&.registered?(:formatting_service)
+
+          config = @dependencies.registered?(:global_state) ? @dependencies.resolve(:global_state) : nil
+
+          Array(
+            @dependencies.resolve(:formatting_service).wrap_window(
+              document,
+              chapter_index,
+              col_width,
+              offset: offset,
+              length: length,
+              config: config,
+              lines_per_page: length
+            )
+          )
+        rescue StandardError
+          []
+        end
+
+        def fetch_via_wrapping_service(chapter:, chapter_index:, col_width:, offset:, length:)
+          return [] unless @dependencies&.registered?(:wrapping_service)
+
+          wrapping = @dependencies.resolve(:wrapping_service)
+          wrapping.wrap_window(chapter.lines || [], chapter_index, col_width, offset, length) || []
+        rescue StandardError
+          []
+        end
+
+        def fallback_lines(chapter, offset, length)
+          (chapter.lines || [])[offset, length] || []
+        rescue StandardError
+          []
+        end
+
+        def first_line_metadata(lines)
+          first = Array(lines).first
+          return nil unless first.respond_to?(:metadata)
+
+          meta = first.metadata
+          meta.is_a?(Hash) ? meta : nil
+        end
+
+        def image_render_hash?(meta)
+          return false unless meta.is_a?(Hash)
+
+          render = meta[:image_render] || meta['image_render']
+          render.is_a?(Hash)
+        end
+
+        def image_block_metadata(lines)
+          meta = first_line_metadata(lines)
+          return nil unless image_render_hash?(meta)
+          return nil if image_render_line?(meta)
+
+          meta
+        end
+
+        def image_render_line?(meta)
+          value = meta.key?(:image_render_line) ? meta[:image_render_line] : meta['image_render_line']
+          value == true
+        rescue StandardError
+          false
+        end
+
+        def image_line_index(meta)
+          value = meta.key?(:image_line_index) ? meta[:image_line_index] : meta['image_line_index']
+          value&.to_i
+        rescue StandardError
+          nil
+        end
+
+        def snapped_offset(offset, index)
+          snapped = offset.to_i - index.to_i
+          snapped.negative? ? 0 : snapped
+        rescue StandardError
+          offset.to_i
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters::Output::Ui::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

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    # Small helper for composing styled strings and common UI elements.
+    module RenderStyle
+      DEFAULT_PALETTE = Shoko::Adapters::Output::Ui::Constants::Themes::DEFAULT_PALETTE
+
+      @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 + Terminal::ANSI::RESET
+        end
+
+        def accent(text)
+          color(:accent) + text.to_s + Terminal::ANSI::RESET
+        end
+
+        def dim(text)
+          color(:dim) + text.to_s + Terminal::ANSI::RESET
+        end
+
+        def selection_pointer
+          Shoko::Adapters::Output::Ui::Constants::UI::SELECTION_POINTER
+        end
+
+        def selection_pointer_colored
+          color(:accent) + selection_pointer + Terminal::ANSI::RESET
+        end
+
+        def styled_segment(text, styles = {}, metadata: {})
+          content = text.to_s
+          return content if content.empty?
+
+          codes = []
+          block_type = metadata && metadata[:block_type]
+          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 << Terminal::ANSI::BOLD if styles[:bold] || block_type == :heading
+          codes << Terminal::ANSI::ITALIC if styles[:italic] || styles[:quote] || block_type == :quote
+          codes << Terminal::ANSI::DIM if styles[:prefix] || styles[:dim]
+
+          codes.join + content + Terminal::ANSI::RESET
+        end
+
+        private
+
+        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

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'base_component'
+
+module Shoko
+  module Adapters::Output::Ui::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