shoko 0.1.0

data/lib/shoko/core/services/navigation/absolute_strategy.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require_relative 'nav_context'
+
+module Shoko
+  module Core
+    module Services
+      module Navigation
+        # Computes absolute-mode navigation offsets for single and split view.
+        # Returns hashes describing desired state field updates; facade applies.
+        module AbsoluteStrategy
+          module_function
+
+          def next_page(context)
+            if context.view_mode == :split
+              next_page_split(context)
+            else
+              next_page_single(context)
+            end
+          end
+
+          def prev_page(context)
+            if context.view_mode == :split
+              prev_page_split(context)
+            else
+              prev_page_single(context)
+            end
+          end
+
+          def scroll(context, direction, lines)
+            lines = lines.to_i
+            return {} if lines <= 0
+
+            if context.view_mode == :split
+              scroll_split(context, direction, lines)
+            else
+              scroll_single(context, direction, lines)
+            end
+          end
+
+          def go_to_start(context)
+            if context.view_mode == :split
+              stride = split_stride(context)
+              { current_chapter: 0, current_page: 0, single_page: 0, left_page: 0, right_page: stride }
+            else
+              { current_chapter: 0, current_page: 0, single_page: 0, left_page: 0, right_page: split_stride(context) }
+            end
+          end
+
+          def go_to_end(context)
+            # Facade will compute last_page for last chapter; provide intent only.
+            last_chapter = [context.total_chapters - 1, 0].max
+            { current_chapter: last_chapter, align_to_last: true }
+          end
+
+          def jump_to_chapter(context, index)
+            if context.view_mode == :split
+              stride = split_stride(context)
+              { current_chapter: index, current_page: 0, single_page: 0, left_page: 0, right_page: stride }
+            else
+              { current_chapter: index, current_page: 0, single_page: 0, left_page: 0,
+                right_page: split_stride(context) }
+            end
+          end
+
+          # --- helpers ---
+          def next_page_single(context)
+            stride = single_stride(context)
+            cur = context.single_page.to_i
+            max_offset = max_offset(context)
+
+            if cur < max_offset
+              new_offset = [cur + stride, max_offset].min
+              { single_page: new_offset, current_page: new_offset }
+            elsif context.current_chapter < context.total_chapters - 1
+              { advance_chapter: :next }
+            else
+              {}
+            end
+          end
+
+          def prev_page_single(context)
+            stride = single_stride(context)
+            cur = context.single_page.to_i
+            if cur.positive?
+              new_offset = [cur - stride, 0].max
+              { single_page: new_offset, current_page: new_offset }
+            elsif context.current_chapter.positive?
+              { advance_chapter: :prev, stride: stride }
+            else
+              {}
+            end
+          end
+
+          def next_page_split(context)
+            stride = split_stride(context)
+            left = context.left_page.to_i
+            max_offset = max_offset(context)
+
+            if left < max_offset
+              new_left = [left + stride, max_offset].min
+              { left_page: new_left, right_page: new_left + stride, current_page: new_left }
+            elsif context.current_chapter < context.total_chapters - 1
+              { advance_chapter: :next }
+            else
+              {}
+            end
+          end
+
+          def prev_page_split(context)
+            stride = split_stride(context)
+            left = context.left_page.to_i
+            if left.positive?
+              new_left = [left - stride, 0].max
+              { left_page: new_left, right_page: new_left + stride, current_page: new_left }
+            elsif context.current_chapter.positive?
+              { advance_chapter: :prev, stride: stride }
+            else
+              {}
+            end
+          end
+
+          def scroll_single(context, direction, lines)
+            cur = context.single_page.to_i
+            max_offset = max_offset(context)
+            new_offset = case direction
+                         when :up
+                           [cur - lines, 0].max
+                         when :down
+                           [cur + lines, max_offset].min
+                         else
+                           raise ArgumentError, "Invalid scroll direction: #{direction}"
+                         end
+
+            return {} if new_offset == cur
+
+            { single_page: new_offset, current_page: new_offset }
+          end
+
+          def scroll_split(context, direction, lines)
+            cur = context.left_page.to_i
+            stride = split_stride(context)
+            max_offset = max_offset(context)
+            new_offset = case direction
+                         when :up
+                           [cur - lines, 0].max
+                         when :down
+                           [cur + lines, max_offset].min
+                         else
+                           raise ArgumentError, "Invalid scroll direction: #{direction}"
+                         end
+
+            return {} if new_offset == cur
+
+            { left_page: new_offset, right_page: new_offset + stride, current_page: new_offset }
+          end
+
+          def single_stride(context)
+            stride = context.lines_per_page.to_i
+            stride = context.column_lines_per_page.to_i if stride <= 0
+            stride = 1 if stride <= 0
+            stride
+          end
+
+          def split_stride(context)
+            stride = context.column_lines_per_page.to_i
+            stride = context.lines_per_page.to_i if stride <= 0
+            stride = 1 if stride <= 0
+            stride
+          end
+
+          def max_offset(context)
+            context.max_offset_in_chapter.to_i
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/core/services/navigation/context_builder.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative 'nav_context'
+require_relative 'context_helpers'
+
+module Shoko
+  module Core
+    module Services
+      module Navigation
+        # Builds navigation context snapshots from the current state.
+        class ContextBuilder
+          def initialize(state_store, page_calculator)
+            @state_store = state_store
+            @page_calculator = page_calculator
+          end
+
+          def build
+            snapshot = ContextHelpers.safe_snapshot(@state_store)
+
+            NavContext.new(
+              mode: ContextHelpers.dynamic_mode?(snapshot) ? :dynamic : :absolute,
+              view_mode: ContextHelpers.current_view_mode(snapshot),
+              current_chapter: ContextHelpers.current_chapter(snapshot),
+              total_chapters: ContextHelpers.total_chapters(snapshot),
+              current_page_index: ContextHelpers.current_page_index(snapshot),
+              dynamic_total_pages: dynamic_total_pages,
+              single_page: ContextHelpers.single_page(snapshot),
+              left_page: ContextHelpers.left_page(snapshot),
+              right_page: ContextHelpers.right_page(snapshot),
+              max_page_in_chapter: 0,
+              lines_per_page: 0,
+              column_lines_per_page: 0,
+              max_offset_in_chapter: 0
+            )
+          end
+
+          private
+
+          attr_reader :page_calculator
+
+          def dynamic_total_pages
+            return 0 unless page_calculator.respond_to?(:total_pages)
+
+            page_calculator.total_pages.to_i
+          rescue StandardError
+            0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/core/services/navigation/context_helpers.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Core
+    module Services
+      module Navigation
+        # Helpers for extracting navigation-relevant values from a state snapshot.
+        module ContextHelpers
+          module_function
+
+          def safe_snapshot(state_store)
+            return {} unless state_store.respond_to?(:current_state)
+
+            state_store.current_state || {}
+          rescue StandardError
+            {}
+          end
+
+          def dynamic_mode?(snapshot)
+            mode = snapshot.dig(:config, :page_numbering_mode)
+            mode == :dynamic
+          end
+
+          def current_view_mode(snapshot)
+            snapshot.dig(:config, :view_mode) || :split
+          end
+
+          def current_chapter(snapshot)
+            snapshot.dig(:reader, :current_chapter) || 0
+          end
+
+          def total_chapters(snapshot)
+            snapshot.dig(:reader, :total_chapters) || 0
+          end
+
+          def current_page_index(snapshot)
+            snapshot.dig(:reader, :current_page_index) || 0
+          end
+
+          def current_page(snapshot)
+            snapshot.dig(:reader, :current_page) || 0
+          end
+
+          def single_page(snapshot)
+            snapshot.dig(:reader, :single_page) || current_page(snapshot)
+          end
+
+          def left_page(snapshot)
+            snapshot.dig(:reader, :left_page) || current_page(snapshot)
+          end
+
+          def right_page(snapshot)
+            snapshot.dig(:reader, :right_page) || 0
+          end
+
+          def page_map(snapshot)
+            snapshot.dig(:reader, :page_map) || []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/core/services/navigation/dynamic_change_applier.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Core
+    module Services
+      module Navigation
+        # Applies dynamic-mode changes to the state store.
+        class DynamicChangeApplier
+          def initialize(state_store:, page_calculator:, state_updater:)
+            @state_store = state_store
+            @page_calculator = page_calculator
+            @state_updater = state_updater
+          end
+
+          def apply(changes)
+            return if changes.nil? || changes.empty?
+
+            update_page_index(changes[:current_page_index]) if changes.key?(:current_page_index)
+
+            return unless changes.key?(:current_chapter)
+
+            @state_updater.apply(%i[reader current_chapter] => changes[:current_chapter])
+          end
+
+          private
+
+          def update_page_index(new_index)
+            updates = { %i[reader current_page_index] => new_index }
+            page = @page_calculator&.get_page(new_index)
+            if page
+              current_chapter = page[:chapter_index]
+              current_chapter ||= current_chapter_from_state || 0
+              updates[%i[reader current_chapter]] = current_chapter
+            end
+
+            @state_updater.apply(updates)
+          end
+
+          def current_chapter_from_state
+            return nil unless @state_store.respond_to?(:current_state)
+
+            @state_store.current_state.dig(:reader, :current_chapter)
+          rescue StandardError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/core/services/navigation/dynamic_strategy.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative 'nav_context'
+
+module Shoko
+  module Core
+    module Services
+      module Navigation
+        # Computes dynamic-mode navigation targets from an immutable context.
+        # Returns simple hashes describing state changes; facade applies them.
+        module DynamicStrategy
+          module_function
+
+          def next_page(context)
+            inc = context.view_mode == :split ? 2 : 1
+            total = context.dynamic_total_pages.to_i
+            return {} if total <= 0
+
+            new_index = (context.current_page_index + inc).clamp(0, total - 1)
+            { current_page_index: new_index }
+          end
+
+          def prev_page(context)
+            dec = context.view_mode == :split ? 2 : 1
+            total = context.dynamic_total_pages.to_i
+            return {} if total <= 0
+
+            new_index = (context.current_page_index - dec).clamp(0, total - 1)
+            { current_page_index: new_index }
+          end
+
+          def go_to_start(_context)
+            { current_chapter: 0, current_page_index: 0 }
+          end
+
+          def go_to_end(context)
+            total = context.dynamic_total_pages.to_i
+            return {} if total <= 0
+
+            { current_page_index: total - 1 }
+          end
+
+          def jump_to_chapter(_context, index)
+            # Facade will map chapter -> page index precisely; here provide chapter intent.
+            { current_chapter: index, current_page_index: 0 }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/core/services/navigation/image_offset_snapper.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require_relative 'context_helpers'
+require_relative 'absolute_layout'
+require_relative '../../../adapters/output/kitty/kitty_graphics.rb'
+
+module Shoko
+  module Core
+    module Services
+      module Navigation
+        # Snaps absolute offsets so image blocks render from their first line.
+        class ImageOffsetSnapper
+          def initialize(state_store:, layout_service:, formatting_service:, document:)
+            @state_store = state_store
+            @layout_service = layout_service
+            @formatting_service = formatting_service
+            @document = document
+            @layout = AbsoluteLayout.new(state_store: state_store, layout_service: layout_service)
+          end
+
+          def snap(updates, layout_state)
+            return updates unless enabled?
+            return updates if updates.nil? || updates.empty?
+
+            snapshot = layout_state.snapshot
+            view_mode = layout_state.view_mode
+            stride = layout_state.stride
+            chapter_index = updates[%i[reader current_chapter]] || ContextHelpers.current_chapter(snapshot)
+            col_width = @layout.column_width(snapshot, view_mode)
+
+            if view_mode == :split
+              snap_split(updates, chapter_index, col_width, stride, snapshot)
+            else
+              snap_single(updates, chapter_index, col_width, stride, snapshot)
+            end
+          rescue StandardError
+            updates
+          end
+
+          private
+
+          def enabled?
+            return false unless @layout_service && @formatting_service && @document
+
+            Shoko::Adapters::Output::Kitty::KittyGraphics.enabled_for?(@state_store)
+          end
+
+          def snap_split(updates, chapter_index, col_width, stride, snapshot)
+            left = (updates[%i[reader left_page]] || snapshot.dig(:reader, :left_page) || 0).to_i
+            snapped = snap_offset(chapter_index, col_width, left, stride)
+            return updates if snapped == left
+
+            updates[%i[reader left_page]] = snapped
+            updates[%i[reader current_page]] = snapped
+            updates[%i[reader right_page]] = snapped + stride
+            updates
+          end
+
+          def snap_single(updates, chapter_index, col_width, stride, snapshot)
+            offset = (updates[%i[reader single_page]] || snapshot.dig(:reader, :single_page) || 0).to_i
+            snapped = snap_offset(chapter_index, col_width, offset, stride)
+            return updates if snapped == offset
+
+            updates[%i[reader single_page]] = snapped
+            updates[%i[reader current_page]] = snapped
+            updates
+          end
+
+          def snap_offset(chapter_index, col_width, offset, lines_per_page)
+            offset_i = offset.to_i
+            return offset_i if offset_i <= 0
+
+            lines = wrapped_lines(chapter_index, col_width, lines_per_page)
+            return offset_i unless lines && lines[offset_i]
+
+            image_start_for(lines, offset_i) || offset_i
+          rescue StandardError
+            offset_i
+          end
+
+          def wrapped_lines(chapter_index, col_width, lines_per_page)
+            @formatting_service.wrap_all(
+              @document,
+              chapter_index,
+              col_width,
+              config: @state_store,
+              lines_per_page: lines_per_page
+            )
+          end
+
+          def image_start_for(lines, offset)
+            meta = line_metadata(lines[offset])
+            render = image_render(meta)
+            return nil unless render
+
+            src = image_src(meta)
+            return nil if src.to_s.empty?
+            return offset if render_line?(meta)
+
+            idx = offset
+            while idx.positive?
+              cur_meta = line_metadata(lines[idx])
+              break unless same_image?(cur_meta, src)
+              return idx if render_line?(cur_meta)
+
+              idx -= 1
+            end
+
+            0
+          end
+
+          def same_image?(meta, src)
+            return false unless image_render(meta)
+
+            image_src(meta).to_s == src.to_s
+          end
+
+          def render_line?(meta)
+            return false unless meta
+
+            meta.key?(:image_render_line) ? meta[:image_render_line] == true : meta['image_render_line'] == true
+          end
+
+          def image_render(meta)
+            return nil unless meta
+
+            render = meta[:image_render] || meta['image_render']
+            render.is_a?(Hash) ? render : nil
+          end
+
+          def line_metadata(line)
+            return nil unless line.respond_to?(:metadata)
+
+            meta = line.metadata
+            meta.is_a?(Hash) ? meta : nil
+          rescue StandardError
+            nil
+          end
+
+          def image_src(meta)
+            image = meta[:image] || meta['image'] || {}
+            image[:src] || image['src']
+          rescue StandardError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/core/services/navigation/nav_context.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Core
+    module Services
+      module Navigation
+        # Immutable snapshot of navigation-relevant state.
+        NavContext = Struct.new(
+          :mode,                 # :dynamic or :absolute
+          :view_mode,            # :single or :split
+          :current_chapter,      # Integer
+          :total_chapters,       # Integer
+          :current_page_index,   # Integer (dynamic)
+          :dynamic_total_pages,  # Integer (dynamic total pages)
+          :single_page,          # Integer (absolute single)
+          :left_page,            # Integer (absolute split left)
+          :right_page,           # Integer (absolute split right)
+          :max_page_in_chapter,  # Integer (absolute page count)
+          :lines_per_page,       # Integer (absolute single stride)
+          :column_lines_per_page, # Integer (absolute split stride)
+          :max_offset_in_chapter, # Integer (absolute last offset)
+          keyword_init: true
+        )
+      end
+    end
+  end
+end

data/lib/shoko/core/services/navigation/state_updater.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Core
+    module Services
+      module Navigation
+        # Applies state updates using the most appropriate state_store API.
+        class StateUpdater
+          def initialize(state_store)
+            @state_store = state_store
+          end
+
+          def apply(updates)
+            return if updates.nil? || updates.empty?
+
+            can_update = @state_store.respond_to?(:update)
+            can_set = @state_store.respond_to?(:set)
+
+            if can_update && (!can_set || updates.length > 1)
+              @state_store.update(updates)
+            elsif can_set
+              updates.each { |path, value| @state_store.set(path, value) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/core/services/navigation/strategy_factory.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'nav_context'
+
+module Shoko
+  module Core
+    module Services
+      module Navigation
+        # Chooses the appropriate navigation strategy for the current mode.
+        module StrategyFactory
+          module_function
+
+          def select(context)
+            context.mode == :dynamic ? DynamicStrategy : AbsoluteStrategy
+          end
+        end
+      end
+    end
+  end
+end