shoko 0.1.3 → 0.1.5

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

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../../terminal/text_metrics.rb'
-require_relative '../../../rendering/models/line_geometry.rb'
-
-module Shoko
-  module Adapters::Output::Ui::Components
-    module Reading
-      # Builds `Shoko::Adapters::Output::Rendering::Models::LineGeometry` objects for selection/highlighting.
-      class LineGeometryBuilder
-        def build(page_id:, column_id:, row:, col:, line_offset:, plain_text:, styled_text:)
-          cell_data = Shoko::Adapters::Output::Terminal::TextMetrics.cell_data_for(plain_text.to_s)
-          cells = cell_data.map { |cell| build_cell(cell) }
-
-          Shoko::Adapters::Output::Rendering::Models::LineGeometry.new(
-            page_id: page_id,
-            column_id: column_id,
-            row: row,
-            column_origin: col,
-            line_offset: line_offset,
-            plain_text: plain_text,
-            styled_text: styled_text,
-            cells: cells
-          )
-        end
-
-        private
-
-        def build_cell(cell)
-          Shoko::Adapters::Output::Rendering::Models::LineCell.new(
-            cluster: cell[:cluster],
-            char_start: cell[:char_start],
-            char_end: cell[:char_end],
-            display_width: cell[:display_width],
-            screen_x: cell[:screen_x]
-          )
-        end
-      end
-    end
-  end
-end

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

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module Shoko
-  module Adapters::Output::Ui::Components
-    module Reading
-      # Records per-line geometry into the state buffer so selection/overlays can
-      # use the exact rendered layout.
-      class RenderedLinesRecorder
-        def initialize(buffer:, dependencies:)
-          @buffer = buffer
-          @dependencies = dependencies
-        end
-
-        def record(geometry)
-          return unless @buffer.is_a?(Hash)
-          return if skip_geometry?(geometry)
-
-          width = geometry.visible_width
-          @buffer[geometry.key] = entry_for(geometry, width)
-
-          dump_geometry(geometry) if geometry_debug_enabled?
-        end
-
-        private
-
-        def skip_geometry?(geometry)
-          width = geometry.visible_width
-          width <= 0 && geometry.plain_text.to_s.empty?
-        end
-
-        def entry_for(geometry, width)
-          end_col = geometry.column_origin + width - 1
-          {
-            row: geometry.row,
-            col: geometry.column_origin,
-            col_end: end_col,
-            text: geometry.plain_text,
-            width: width,
-            geometry: geometry,
-          }
-        end
-
-        def geometry_debug_enabled?
-          primary = ENV.fetch('SHOKO_DEBUG_GEOMETRY', '').to_s.strip
-          primary == '1'
-        end
-
-        def dump_geometry(geometry)
-          payload = geometry.to_h
-          logger = resolve_logger
-          return logger.debug('geometry.line', payload) if logger
-
-          warn("[geometry] #{payload}")
-        end
-
-        def resolve_logger
-          @dependencies.resolve(:logger)
-        rescue StandardError
-          nil
-        end
-      end
-    end
-  end
-end

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

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

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

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

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

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