shoko 0.1.0

data/lib/shoko/core/services/navigation_service.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require_relative 'base_service'
+require_relative 'navigation/context_builder'
+require_relative 'navigation/absolute_change_applier'
+require_relative 'navigation/absolute_layout'
+require_relative 'navigation/dynamic_change_applier'
+require_relative 'navigation/dynamic_strategy'
+require_relative 'navigation/image_offset_snapper'
+require_relative 'navigation/state_updater'
+require_relative 'navigation/absolute_strategy'
+
+module Shoko
+  module Core
+    module Services
+      # Pure business logic for book navigation.
+      # Replaces the coupled NavigationService with clean domain logic.
+      class NavigationService < BaseService
+        # Navigate to next page
+        def next_page
+          ctx = build_nav_context
+          dynamic_route_exec(ctx,
+                             -> { @dynamic_applier.apply(Navigation::DynamicStrategy.next_page(ctx)) },
+                             -> { @absolute_applier.apply(Navigation::AbsoluteStrategy.next_page(ctx)) })
+        end
+
+        # Navigate to previous page
+        def prev_page
+          ctx = build_nav_context
+          dynamic_route_exec(ctx,
+                             -> { @dynamic_applier.apply(Navigation::DynamicStrategy.prev_page(ctx)) },
+                             -> { @absolute_applier.apply(Navigation::AbsoluteStrategy.prev_page(ctx)) })
+        end
+
+        # Navigate to specific chapter
+        #
+        # @param chapter_index [Integer] Zero-based chapter index
+        def jump_to_chapter(chapter_index)
+          validate_chapter_index(chapter_index)
+          ctx = build_nav_context
+          dynamic_route_exec(ctx,
+                             lambda do
+                               page_index = @page_calculator.find_page_index(chapter_index, 0)
+                               page_index = 0 if page_index.nil? || page_index.negative?
+                               @state_updater.apply({ %i[reader current_chapter] => chapter_index,
+                                                      %i[reader current_page_index] => page_index })
+                             end,
+                             lambda {
+                               @absolute_applier.apply(Navigation::AbsoluteStrategy.jump_to_chapter(ctx, chapter_index))
+                             })
+        end
+
+        # Navigate to beginning of book
+        def go_to_start
+          ctx = build_nav_context
+          dynamic_route_exec(ctx,
+                             -> { @dynamic_applier.apply(Navigation::DynamicStrategy.go_to_start(ctx)) },
+                             -> { @absolute_applier.apply(Navigation::AbsoluteStrategy.go_to_start(ctx)) })
+        end
+
+        # Navigate to end of book
+        def go_to_end
+          ctx = build_nav_context
+          dynamic_route_exec(ctx,
+                             -> { @dynamic_applier.apply(Navigation::DynamicStrategy.go_to_end(ctx)) },
+                             -> { @absolute_applier.apply(Navigation::AbsoluteStrategy.go_to_end(ctx)) })
+        end
+
+        # Scroll within current page/view
+        #
+        # @param direction [Symbol] :up or :down
+        # @param lines [Integer] Number of lines to scroll
+        def scroll(direction, lines = 1)
+          ctx = build_nav_context
+          if ctx.mode == :dynamic
+            # No-op for dynamic; scrolling is page-based via next/prev
+            return
+          end
+
+          changes = Navigation::AbsoluteStrategy.scroll(ctx, direction, lines)
+          @absolute_applier.apply(changes)
+        end
+
+        protected
+
+        def required_dependencies
+          [:state_store]
+        end
+
+        def setup_service_dependencies
+          @state_store = resolve(:state_store)
+          @page_calculator = resolve(:page_calculator) if registered?(:page_calculator)
+          @layout_service = resolve(:layout_service) if registered?(:layout_service)
+
+          @state_updater = Navigation::StateUpdater.new(@state_store)
+          @context_builder = Navigation::ContextBuilder.new(@state_store, @page_calculator)
+          @absolute_layout = Navigation::AbsoluteLayout.new(state_store: @state_store, layout_service: @layout_service)
+
+          formatting_service = resolve(:formatting_service) if registered?(:formatting_service)
+          document = resolve(:document) if registered?(:document)
+          @image_snapper = Navigation::ImageOffsetSnapper.new(
+            state_store: @state_store,
+            layout_service: @layout_service,
+            formatting_service: formatting_service,
+            document: document
+          )
+
+          @dynamic_applier = Navigation::DynamicChangeApplier.new(
+            state_store: @state_store,
+            page_calculator: @page_calculator,
+            state_updater: @state_updater
+          )
+          @absolute_applier = Navigation::AbsoluteChangeApplier.new(
+            state_updater: @state_updater,
+            absolute_layout: @absolute_layout,
+            image_snapper: @image_snapper,
+            advance_callback: method(:jump_to_chapter)
+          )
+        end
+
+        private
+
+        def build_nav_context
+          ctx = @context_builder.build
+          @absolute_layout.populate_context(ctx)
+          ctx
+        end
+
+        def dynamic_route_exec(ctx, dyn_proc, abs_proc)
+          if ctx.mode == :dynamic && @page_calculator
+            dyn_proc.call
+          else
+            abs_proc.call
+          end
+        end
+
+        def validate_chapter_index(index)
+          raise ArgumentError, 'Chapter index must be non-negative' if index.negative?
+
+          current_state = @state_store.current_state
+          total_chapters = current_state.dig(:reader, :total_chapters) || 0
+
+          return unless index >= total_chapters
+
+          raise ArgumentError, "Chapter index #{index} exceeds total chapters #{total_chapters}"
+        end
+      end
+    end
+  end
+end

data/lib/shoko/core/services/page_calculator_service.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require_relative 'base_service'
+require_relative 'pagination/internal/absolute_page_map_builder'
+require_relative 'pagination/internal/dynamic_page_map_builder'
+require_relative 'pagination/internal/page_hydrator'
+require_relative 'pagination/internal/pagination_workflow'
+require_relative 'pagination/internal/layout_metrics_calculator'
+require_relative '../../adapters/output/terminal/text_metrics.rb'
+require_relative '../../adapters/output/kitty/kitty_graphics.rb'
+
+module Shoko
+  module Core
+    module Services
+      # Enhanced service for page calculations with full PageManager functionality.
+      # Migrated from legacy Services::PageManager with dependency injection.
+      class PageCalculatorService < BaseService
+        attr_reader :pages_data
+
+        def initialize(dependencies)
+          super
+          @text_wrapper = DefaultTextWrapper.new
+          @pages_data = []
+          @chapter_page_index = {}
+          @layout_service = begin
+            resolve(:layout_service)
+          rescue StandardError
+            nil
+          end
+          @metrics_calculator = Pagination::Internal::LayoutMetricsCalculator.new(@state_store,
+                                                                      layout_service: @layout_service)
+          @pagination_cache = begin
+            resolve(:pagination_cache)
+          rescue StandardError
+            nil
+          end
+          @instrumentation = begin
+            resolve(:instrumentation_service)
+          rescue StandardError
+            nil
+          end
+          @pagination_workflow = Pagination::Internal::PaginationWorkflow.new(
+            metrics_calculator: @metrics_calculator,
+            dependencies: @dependencies,
+            pagination_cache: @pagination_cache
+          )
+          @page_hydrator = Pagination::Internal::PageHydrator.new(
+            state_store: @state_store,
+            dependencies: @dependencies,
+            text_wrapper: @text_wrapper,
+            metrics_calculator: @metrics_calculator
+          )
+        end
+
+        # Build complete page map (PageManager compatibility)
+        def build_page_map(terminal_width, terminal_height, doc, config, &)
+          return unless Shoko::Application::Selectors::ConfigSelectors.page_numbering_mode(config) == :dynamic
+
+          result = @pagination_workflow.build_dynamic(doc: doc,
+                                                      width: terminal_width,
+                                                      height: terminal_height,
+                                                      config: config,
+                                                      &)
+          @doc_ref = doc
+          @pages_data = result.pages
+          rebuild_page_index!
+          @pages_data
+        end
+
+        # Get page data by index (PageManager compatibility)
+        def get_page(page_index)
+          return nil if @pages_data.empty?
+          return @pages_data.first if page_index.negative?
+          return @pages_data.last if page_index >= @pages_data.size
+
+          page = @pages_data[page_index]
+          return page if formatted_lines?(page[:lines])
+
+          hydrated = measure_with_instrumentation('page_map.hydrate') do
+            doc = resolve_document_reference
+            @page_hydrator.hydrate(page, doc, prefer_formatting: true)
+          rescue StandardError
+            page
+          end
+
+          @pages_data[page_index] = hydrated if hydrated
+          hydrated
+        end
+
+        # Find page index for chapter and line offset (PageManager compatibility)
+        def find_page_index(chapter_index, line_offset)
+          pages = @chapter_page_index[chapter_index]
+          return 0 unless pages && !pages.empty?
+
+          match = pages.bsearch { |page| line_offset <= page[:end_line].to_i }
+          return match[:global_index] if match && match[:global_index]
+
+          pages.last[:global_index] || 0
+        end
+
+        # Total pages built in map (PageManager compatibility)
+        def total_pages
+          @pages_data.size
+        end
+
+        # Build absolute mode page map (per-chapter pages) with progress callback.
+        # Returns an array of pages per chapter.
+        # @yield [done, total] optional progress callback
+        def build_absolute_page_map(terminal_width, terminal_height, doc, state)
+          # Compute layout metrics based on current config
+          col_width, content_height = @metrics_calculator.layout(terminal_width, terminal_height, state)
+          lines_per_page = @metrics_calculator.lines_per_page_for(content_height, state)
+          wrapper = begin
+            @dependencies&.resolve(:wrapping_service)
+          rescue StandardError
+            nil
+          end
+
+          Pagination::Internal::AbsolutePageMapBuilder.build(doc, col_width, lines_per_page, wrapper) do |done, total|
+            yield(done, total) if block_given?
+          end
+        end
+
+        # --- Unified orchestration helpers ---
+        # Build dynamic (lazy) page map and sync total to state. Accepts optional progress callback.
+        def build_dynamic_map!(width, height, doc, state, &)
+          build_page_map(width, height, doc, state, &)
+          rebuild_page_index!
+          state.dispatch(Shoko::Application::Actions::UpdatePaginationStateAction.new(
+                           total_pages: total_pages
+                         ))
+        end
+
+        # Build absolute page map and sync map/total/last dims to state. Accepts optional progress callback.
+        def build_absolute_map!(width, height, doc, state, &)
+          map = build_absolute_page_map(width, height, doc, state, &)
+          state.dispatch(Shoko::Application::Actions::UpdatePaginationStateAction.new(
+                           page_map: map,
+                           total_pages: map.sum,
+                           last_width: width,
+                           last_height: height
+                         ))
+          map
+        end
+
+        # Apply precise pending progress (dynamic mode) if present in state
+        def apply_pending_precise_restore!(state)
+          pending = state.get(%i[reader pending_progress])
+          return unless pending && pending[:line_offset]
+
+          ch = pending[:chapter_index] || state.get(%i[reader current_chapter])
+          idx = find_page_index(ch, pending[:line_offset].to_i)
+          state.dispatch(Shoko::Application::Actions::UpdatePageAction.new(current_page_index: idx)) if idx && idx >= 0
+          state.dispatch(Shoko::Application::Actions::UpdateSelectionsAction.new(pending_progress: nil))
+        rescue StandardError
+          # no-op on failure
+        end
+
+        def resolve_document_reference
+          return @doc_ref if @doc_ref
+
+          @dependencies&.resolve(:document)
+        rescue StandardError
+          nil
+        end
+
+        def formatted_lines?(lines)
+          first = Array(lines).find { |ln| !ln.nil? }
+          first.respond_to?(:segments) && first.respond_to?(:text)
+        end
+
+        def rebuild_page_index!
+          @chapter_page_index = Hash.new { |h, k| h[k] = [] }
+          @pages_data.each_with_index do |page, idx|
+            ch = page[:chapter_index] || 0
+            entry = page.merge(global_index: idx)
+            @chapter_page_index[ch] << entry
+          end
+          @chapter_page_index.each_value { |arr| arr.sort_by! { |p| p[:end_line].to_i } }
+        end
+
+        # Hydrate from cached pagination without recomputation
+        def hydrate_from_cache(pages, state: nil, width: nil, height: nil)
+          return nil unless pages.is_a?(Array)
+
+          @pages_data = pages
+          rebuild_page_index!
+          total = @pages_data.size
+          state&.dispatch(Shoko::Application::Actions::UpdatePaginationStateAction.new(
+            total_pages: total,
+            last_width: width,
+            last_height: height
+          ))
+          total
+        end
+
+        protected
+
+        def required_dependencies
+          [:state_store]
+        end
+
+        def setup_service_dependencies
+          @state_store = resolve(:state_store) if @dependencies
+        end
+
+        private
+
+        def measure_with_instrumentation(metric, &)
+          if @instrumentation
+            @instrumentation.time(metric, &)
+          else
+            yield
+          end
+        end
+      end
+
+      # Default text wrapping implementation
+      class DefaultTextWrapper
+        def wrap_chapter_lines(lines, column_width)
+          return [] if lines.empty? || column_width <= 0
+
+          wrapped = []
+          lines.each do |line|
+            next if line.nil?
+
+            if line.strip.empty?
+              wrapped << ''
+            else
+              segments = Shoko::Adapters::Output::Terminal::TextMetrics.wrap_plain_text(line, column_width)
+              wrapped.concat(segments)
+            end
+          end
+          wrapped
+        end
+      end
+    end
+  end
+end
+# NOTE: Former helper that prepopulated lines for cached pages has been
+# removed to avoid blocking first paint. Lines are populated lazily in
+# #get_page when needed.

data/lib/shoko/core/services/pagination/internal/absolute_page_map_builder.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative '../../pagination'
+module Shoko::Core::Services::Pagination::Internal
+        # Small helper to compute absolute page maps per chapter.
+        # Encapsulates the per-chapter wrapping + page counting loop.
+        class AbsolutePageMapBuilder
+          def self.build(doc, col_width, lines_per_page, wrapper = nil)
+            total = doc.chapter_count
+            page_map = []
+            total.times do |i|
+              chapter = doc.get_chapter(i)
+              lines = chapter&.lines || []
+
+              wrapped = if wrapper
+                          wrapper.wrap_lines(lines, i, col_width)
+                        else
+                          Shoko::Core::Services::DefaultTextWrapper.new.wrap_chapter_lines(lines, col_width)
+                        end
+
+              pages = (wrapped.size.to_f / [lines_per_page, 1].max).ceil
+              page_map << pages
+              yield(i + 1, total) if block_given?
+            end
+            page_map
+          end
+        end
+end

data/lib/shoko/core/services/pagination/internal/chapter_cache.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative '../../pagination'
+require_relative '../../../../adapters/output/terminal/text_metrics.rb'
+
+module Shoko::Core::Services::Pagination::Internal
+        # Caches wrapped lines for chapters to avoid recomputation
+        # Internal helper used by WrappingService; not DI-registered.
+        class ChapterCache
+          def initialize
+            @wrapped_cache = {}
+            @cache_key_memo = {}
+          end
+
+          # Get wrapped lines for chapter and width
+          # @param chapter_index [Integer]
+          # @param lines [Array<String>]
+          # @param width [Integer]
+          # @return [Array<String>]
+          def get_wrapped_lines(chapter_index, lines, width)
+            cache_key = generate_cache_key(chapter_index, width)
+            cached = @wrapped_cache[cache_key]
+            memo_id = @cache_key_memo[cache_key]
+            return cached if cached && memo_id == lines.object_id
+
+            wrapped = wrap_lines_internal(lines, width)
+            @wrapped_cache[cache_key] = wrapped
+            @cache_key_memo[cache_key] = lines.object_id
+            wrapped
+          end
+
+          # Clear cached entries for given width
+          def clear_cache_for_width(width)
+            @wrapped_cache.delete_if { |key, _| key.end_with?("_#{width}") }
+          end
+
+          private
+
+          def generate_cache_key(chapter_index, width)
+            "#{chapter_index}_#{width}"
+          end
+
+          def wrap_lines_internal(lines, width)
+            return [] if lines.nil? || width < 1
+
+            wrapped = []
+            lines.each do |line|
+              next if line.nil?
+
+              if line.strip.empty?
+                wrapped << ''
+              else
+                segments = Shoko::Adapters::Output::Terminal::TextMetrics.wrap_plain_text(line, width)
+                wrapped.concat(segments)
+              end
+            end
+            wrapped
+          end
+        end
+end

data/lib/shoko/core/services/pagination/internal/dynamic_page_map_builder.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require_relative '../../pagination'
+require_relative '../../../../adapters/output/terminal/text_metrics.rb'
+
+module Shoko::Core::Services::Pagination::Internal
+        # Builds dynamic pagination page data for all chapters.
+        # Produces the same page hashes used by PageCalculatorService.
+        # Not DI-registered; used internally by the facade service.
+        class DynamicPageMapBuilder
+          def self.build(doc, col_width, lines_per_page, wrapper: nil, formatter: nil, config: nil)
+            pages_data = []
+            total = doc.chapter_count
+
+            total.times do |chapter_idx|
+              chapter = doc.get_chapter(chapter_idx)
+              next unless chapter
+
+              wrapped = wrapped_lines(doc, chapter, chapter_idx, col_width, lines_per_page,
+                                      wrapper, formatter, config)
+
+              pages = paginate_lines(wrapped, lines_per_page)
+              page_count = [pages.length, 1].max
+              pages.each_with_index do |page, page_idx|
+                pages_data << {
+                  chapter_index: chapter_idx,
+                  page_in_chapter: page_idx,
+                  total_pages_in_chapter: page_count,
+                  start_line: page[:start_line],
+                  end_line: page[:end_line],
+                  lines: page[:lines],
+                }
+              end
+
+              yield(chapter_idx + 1, total) if block_given?
+            end
+
+            pages_data
+          end
+
+          class << self
+            private
+
+            def paginate_lines(lines, lines_per_page)
+              per_page = [lines_per_page.to_i, 1].max
+              list = Array(lines)
+              return [{ start_line: 0, end_line: -1, lines: [] }] if list.empty?
+
+              pages = []
+              index = 0
+
+              while index < list.length
+                start_line = index
+                page_lines = []
+
+                while page_lines.length < per_page && index < list.length
+                  group_len = image_group_length(list, index)
+                  remaining = per_page - page_lines.length
+
+                  break if group_len && group_len > remaining && !page_lines.empty?
+
+                  if group_len
+                    take = [group_len, remaining].min
+                    page_lines.concat(list[index, take])
+                    index += take
+                  else
+                    page_lines << list[index]
+                    index += 1
+                  end
+                end
+
+                pages << {
+                  start_line: start_line,
+                  end_line: start_line + page_lines.length - 1,
+                  lines: page_lines,
+                }
+              end
+
+              pages
+            rescue StandardError
+              [{ start_line: 0, end_line: [list.length - 1, -1].max, lines: list }]
+            end
+
+            def image_group_length(lines, start_index)
+              meta = metadata_for(lines[start_index])
+              return nil unless meta
+              return nil unless meta[:image_render].is_a?(Hash) || meta['image_render'].is_a?(Hash)
+
+              render_line = meta.key?(:image_render_line) ? meta[:image_render_line] : meta['image_render_line']
+              return nil unless render_line == true
+
+              image = meta[:image] || meta['image'] || {}
+              src = image[:src] || image['src']
+              return nil if src.to_s.empty?
+
+              index = start_index
+              while index < lines.length
+                cur = metadata_for(lines[index])
+                break unless cur
+
+                block_type = cur[:block_type] || cur['block_type']
+                break unless block_type == :image || block_type.to_s == 'image'
+
+                cur_image = cur[:image] || cur['image'] || {}
+                cur_src = cur_image[:src] || cur_image['src']
+                break unless cur_src.to_s == src.to_s
+
+                index += 1
+              end
+
+              index - start_index
+            rescue StandardError
+              nil
+            end
+
+            def metadata_for(line)
+              return nil unless line.respond_to?(:metadata)
+
+              meta = line.metadata
+              meta.is_a?(Hash) ? meta : nil
+            rescue StandardError
+              nil
+            end
+
+            def wrapped_lines(doc, chapter, chapter_idx, width, lines_per_page, wrapper, formatter, config)
+              return [] if width <= 0 || chapter.nil?
+
+              if formatter
+                lines = formatter.wrap_all(doc, chapter_idx, width, config: config, lines_per_page: lines_per_page)
+                return lines if lines && !lines.empty?
+              end
+
+              if wrapper
+                lines = wrapper.wrap_lines(chapter.lines || [], chapter_idx, width)
+                return lines if lines && !lines.empty?
+              end
+
+              wrap_plain_lines(chapter.lines || [], width)
+            end
+
+            def wrap_plain_lines(lines, width)
+              return [] if lines.empty? || width <= 0
+
+              lines.each_with_object([]) do |line, acc|
+                next if line.nil?
+
+                if line.strip.empty?
+                  acc << ''
+                else
+                  segments = Shoko::Adapters::Output::Terminal::TextMetrics.wrap_plain_text(line, width)
+                  acc.concat(segments)
+                end
+              end
+            end
+          end
+        end
+end