shoko 0.1.0

data/lib/shoko/core/models/reader_settings.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Core
+    module Models
+      # Shared reader layout/formatting defaults used across application and UI layers.
+      module ReaderSettings
+      DEFAULT_LINE_SPACING = :compact
+      LINE_SPACING_VALUES = %i[compact normal relaxed].freeze
+      LINE_SPACING_MULTIPLIERS = {
+        compact: 1.0,
+        normal: 0.75,
+        relaxed: 0.5,
+      }.freeze
+
+      SINGLE_VIEW_WIDTH_PERCENT = 0.9
+      end
+    end
+  end
+end

data/lib/shoko/core/models/selection_anchor.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Core
+    module Models
+      # Lightweight value object describing an anchor within rendered geometry.
+      class SelectionAnchor
+      ATTRIBUTES = %i[page_id column_id geometry_key line_offset cell_index row column_origin].freeze
+
+      attr_reader(*ATTRIBUTES)
+
+      def initialize(page_id:, column_id:, geometry_key:, line_offset:, cell_index:, row:, column_origin:)
+        @page_id = page_id
+        @column_id = column_id
+        @geometry_key = geometry_key
+        @line_offset = line_offset
+        @cell_index = cell_index
+        @row = row
+        @column_origin = column_origin
+      end
+
+      def self.from(anchor)
+        return anchor if anchor.is_a?(SelectionAnchor)
+        return nil unless anchor.respond_to?(:[]) || anchor.is_a?(Hash)
+
+        new(
+          page_id: anchor[:page_id] || anchor['page_id'],
+          column_id: anchor[:column_id] || anchor['column_id'],
+          geometry_key: anchor[:geometry_key] || anchor['geometry_key'],
+          line_offset: anchor[:line_offset] || anchor['line_offset'] || 0,
+          cell_index: anchor[:cell_index] || anchor['cell_index'] || 0,
+          row: anchor[:row] || anchor['row'] || 0,
+          column_origin: anchor[:column_origin] || anchor['column_origin'] || 0
+        )
+      end
+
+      def to_h
+        {
+          page_id: page_id,
+          column_id: column_id,
+          geometry_key: geometry_key,
+          line_offset: line_offset,
+          cell_index: cell_index,
+          row: row,
+          column_origin: column_origin,
+        }
+      end
+
+      def <=>(other)
+        return nil unless other.is_a?(SelectionAnchor)
+
+        compare_tuple <=> other.compare_tuple
+      end
+
+      def compare_tuple
+        [page_id || 0, line_offset, column_id || 0, row || 0, cell_index]
+      end
+
+      def with_cell_index(new_index)
+        self.class.new(
+          page_id: page_id,
+          column_id: column_id,
+          geometry_key: geometry_key,
+          line_offset: line_offset,
+          cell_index: new_index,
+          row: row,
+          column_origin: column_origin
+        )
+      end
+      end
+    end
+  end
+end

data/lib/shoko/core/models/toc_entry.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Core
+    module Models
+      # Represents a Table-of-Contents entry.
+      TOCEntry = Struct.new(:title, :href, :level, :chapter_index, :navigable, keyword_init: true) do
+        def initialize(title:, href:, level:, chapter_index: nil, navigable: true)
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative 'base_service'
+require_relative '../events/annotation_events.rb'
+
+module Shoko
+  module Core
+    module Services
+      # Domain-level service for annotation persistence and state updates.
+      # Uses AnnotationRepository for clean separation from infrastructure.
+      class AnnotationService < BaseService
+        def list_for_book(path)
+          return [] unless path && !path.to_s.empty?
+
+          @annotation_repository.find_by_book_path(path)
+        end
+
+        def list_all
+          @annotation_repository.find_all
+        end
+
+        def add(path, text, note, range, chapter_index, page_meta = nil)
+          annotation = @annotation_repository.add_for_book(
+            path,
+            text: text,
+            note: note,
+            range: range,
+            chapter_index: chapter_index,
+            page_meta: page_meta
+          )
+
+          @domain_event_bus.publish(Events::AnnotationAdded.new(
+                                      book_path: path,
+                                      annotation: annotation
+                                    ))
+
+          notify_updated(path)
+          annotation
+        end
+
+        def update(path, id, note)
+          old_note = ''
+          if @annotation_repository.respond_to?(:find_by_id)
+            old_annotation = @annotation_repository.find_by_id(path, id)
+            old_note = old_annotation ? old_annotation['note'] : ''
+          end
+
+          result = @annotation_repository.update_note(path, id, note)
+
+          @domain_event_bus.publish(Events::AnnotationUpdated.new(
+                                      book_path: path,
+                                      annotation_id: id,
+                                      old_note: old_note,
+                                      new_note: note
+                                    ))
+
+          notify_updated(path)
+          result
+        end
+
+        def delete(path, id)
+          annotation = @annotation_repository.find_by_id(path, id) if @annotation_repository.respond_to?(:find_by_id)
+
+          result = @annotation_repository.delete_by_id(path, id)
+
+          @domain_event_bus.publish(Events::AnnotationRemoved.new(
+                                      book_path: path,
+                                      annotation_id: id,
+                                      annotation: annotation
+                                    ))
+
+          notify_updated(path)
+          result
+        end
+
+        protected
+
+        def required_dependencies
+          %i[state_store annotation_repository domain_event_bus]
+        end
+
+        def setup_service_dependencies
+          @state_store = resolve(:state_store)
+          @annotation_repository = resolve(:annotation_repository)
+          @domain_event_bus = resolve(:domain_event_bus)
+        end
+
+        private
+
+        def notify_updated(path)
+          return unless @state_store && path
+
+          annotations = list_for_book(path)
+          @state_store.dispatch(Shoko::Application::Actions::UpdateAnnotationsAction.new(annotations))
+        rescue StandardError
+          # Best-effort state refresh; persistence already succeeded
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Core
+    module Services
+      # Base class for all domain services with dependency injection support.
+      # Provides standardized initialization and dependency management.
+      class BaseService
+        attr_reader :dependencies
+
+        def initialize(dependencies)
+          @dependencies = dependencies
+          validate_dependencies
+          setup_service_dependencies
+        end
+
+        protected
+
+        # Override in subclasses to specify required dependencies
+        def required_dependencies
+          []
+        end
+
+        # Override in subclasses to setup specific service dependencies
+        def setup_service_dependencies
+          # Default implementation does nothing
+        end
+
+        # Resolve a dependency from the container
+        def resolve(dependency_name)
+          return unless @dependencies.respond_to?(:resolve)
+
+          @dependencies.resolve(dependency_name)
+        end
+
+        # Check if a dependency is registered
+        def registered?(dependency_name)
+          return false unless @dependencies.respond_to?(:registered?)
+
+          @dependencies.registered?(dependency_name)
+        end
+
+        private
+
+        def validate_dependencies
+          return unless respond_to?(:required_dependencies)
+
+          missing = required_dependencies.reject { |dep| registered?(dep) }
+          return if missing.empty?
+
+          raise ArgumentError, "Missing required dependencies: #{missing.join(', ')}"
+        end
+      end
+    end
+  end
+end
+
+module Shoko
+  BaseService = Core::Services::BaseService
+end

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

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+require_relative 'base_service'
+require_relative '../events/bookmark_events.rb'
+
+module Shoko
+  module Core
+    module Services
+      # Pure business logic for bookmark management.
+      # Replaces the tightly coupled BookmarkService with clean domain logic.
+      class BookmarkService < BaseService
+        # Add bookmark at current position
+        #
+        # @param text_snippet [String] Optional text snippet for the bookmark
+        # @return [Bookmark] Created bookmark
+        def add_bookmark(text_snippet = nil)
+          book_path = current_book_path
+          return nil unless book_path
+
+          current_state = safe_snapshot
+          chapter_index = current_state.dig(:reader, :current_chapter) || 0
+          line_offset = get_current_line_offset(current_state)
+
+          bookmark = @bookmark_repository.add_for_book(
+            book_path,
+            chapter_index: chapter_index,
+            line_offset: line_offset,
+            text_snippet: text_snippet || generate_text_snippet(current_state)
+          )
+
+          refresh_bookmarks(book_path)
+
+          @domain_event_bus.publish(Events::BookmarkAdded.new(
+                                      book_path: book_path,
+                                      bookmark: bookmark
+                                    ))
+          @event_bus.emit_event(:bookmark_added, { bookmark: bookmark })
+          bookmark
+        end
+
+        # Remove bookmark
+        #
+        # @param bookmark [Bookmark] Bookmark to remove
+        def remove_bookmark(bookmark)
+          book_path = current_book_path
+          return unless book_path
+
+          @bookmark_repository.delete_for_book(book_path, bookmark)
+          refresh_bookmarks(book_path)
+
+          @domain_event_bus.publish(Events::BookmarkRemoved.new(
+                                      book_path: book_path,
+                                      bookmark: bookmark
+                                    ))
+          @event_bus.emit_event(:bookmark_removed, { bookmark: bookmark })
+        end
+
+        # Get all bookmarks for current book
+        #
+        # @return [Array<Bookmark>] Array of bookmarks
+        def bookmarks
+          book_path = current_book_path
+          return [] unless book_path
+
+          @bookmark_repository.find_by_book_path(book_path)
+        end
+
+        # Navigate to bookmark
+        #
+        # @param bookmark [Bookmark] Bookmark to navigate to
+        def jump_to_bookmark(bookmark)
+          snapshot = safe_snapshot
+          line_offset = bookmark.line_offset.to_i
+          updates = {
+            %i[reader current_chapter] => bookmark.chapter_index,
+            %i[reader current_page] => line_offset,
+          }
+
+          view_mode = snapshot.dig(:config, :view_mode) || :split
+          if view_mode == :split
+            stride = split_stride_for(snapshot)
+            updates[%i[reader left_page]] = line_offset
+            updates[%i[reader right_page]] = line_offset + stride
+          else
+            updates[%i[reader single_page]] = line_offset
+          end
+
+          if dynamic_mode?(snapshot)
+            page_index = page_index_for(bookmark.chapter_index, line_offset)
+            updates[%i[reader current_page_index]] = page_index if page_index
+          end
+
+          apply_state_updates(updates)
+
+          # Publish domain event
+          @domain_event_bus.publish(Events::BookmarkNavigated.new(
+                                      book_path: current_book_path,
+                                      bookmark: bookmark
+                                    ))
+
+          # Legacy event bus for backward compatibility
+          @event_bus.emit_event(:navigated_to_bookmark, { bookmark: bookmark })
+        end
+
+        # Check if current position has bookmark
+        #
+        # @return [Boolean]
+        def current_position_bookmarked?
+          book_path = current_book_path
+          return false unless book_path
+
+          current_state = safe_snapshot
+          current_chapter = current_state.dig(:reader, :current_chapter) || 0
+          line_offset = get_current_line_offset(current_state)
+          @bookmark_repository.exists_at_position?(book_path, current_chapter, line_offset)
+        end
+
+        # Get bookmark at current position (if any)
+        #
+        # @return [Bookmark, nil]
+        def bookmark_at_current_position
+          book_path = current_book_path
+          return nil unless book_path
+
+          current_state = safe_snapshot
+          current_chapter = current_state.dig(:reader, :current_chapter) || 0
+          line_offset = get_current_line_offset(current_state)
+          @bookmark_repository.find_at_position(book_path, current_chapter, line_offset)
+        end
+
+        # Toggle bookmark at current position
+        #
+        # @param text_snippet [String] Text snippet if adding
+        # @return [Symbol] :added or :removed
+        def toggle_bookmark(text_snippet = nil)
+          existing_bookmark = bookmark_at_current_position
+
+          if existing_bookmark
+            remove_bookmark(existing_bookmark)
+            :removed
+          else
+            add_bookmark(text_snippet)
+            :added
+          end
+        end
+
+        protected
+
+        def required_dependencies
+          %i[state_store event_bus bookmark_repository domain_event_bus]
+        end
+
+        def setup_service_dependencies
+          @state_store = resolve(:state_store)
+          @event_bus = resolve(:event_bus)
+          @bookmark_repository = resolve(:bookmark_repository)
+          @domain_event_bus = resolve(:domain_event_bus)
+          @page_calculator = resolve(:page_calculator) if registered?(:page_calculator)
+          @layout_service = resolve(:layout_service) if registered?(:layout_service)
+          @terminal_service = resolve(:terminal_service) if registered?(:terminal_service)
+        end
+
+        private
+
+        def get_current_line_offset(state)
+          if dynamic_mode?(state)
+            offset = line_offset_for_dynamic_state(state)
+            return offset if offset
+          end
+
+          # Get the current line position depending on view mode
+          view_mode = state.dig(:config, :view_mode) || :split
+          if view_mode == :split
+            state.dig(:reader, :left_page) || 0
+          else
+            state.dig(:reader, :single_page) || 0
+          end
+        end
+
+        def dynamic_mode?(state)
+          (state.dig(:config, :page_numbering_mode) || :dynamic) == :dynamic
+        end
+
+        def page_index_for(chapter_index, line_offset)
+          return nil unless @page_calculator
+
+          idx = @page_calculator.find_page_index(chapter_index, line_offset)
+          idx && idx >= 0 ? idx : nil
+        rescue StandardError
+          nil
+        end
+
+        def line_offset_for_dynamic_state(state)
+          return nil unless @page_calculator
+
+          page_index = state.dig(:reader, :current_page_index) || 0
+          page = @page_calculator.get_page(page_index)
+          offset = page && (page[:start_line] || page['start_line'])
+          offset&.to_i
+        rescue StandardError
+          nil
+        end
+
+        def split_stride_for(state)
+          return 1 unless @layout_service
+
+          width = state.dig(:ui, :terminal_width)
+          height = state.dig(:ui, :terminal_height)
+          height, width = @terminal_service.size if (!width || !height) && @terminal_service
+          width = width.to_i
+          height = height.to_i
+          width = 80 if width <= 0
+          height = 24 if height <= 0
+
+          _, content_height = @layout_service.calculate_metrics(width, height, :split)
+          spacing = state.dig(:config, :line_spacing) || Shoko::Core::Models::ReaderSettings::DEFAULT_LINE_SPACING
+          stride = @layout_service.adjust_for_line_spacing(content_height, spacing)
+          stride = 1 if stride.to_i <= 0
+          stride
+        rescue StandardError
+          1
+        end
+
+        def generate_text_snippet(state)
+          # This would be implemented based on the current document content
+          # For now, return a placeholder
+          chapter_index = state.dig(:reader, :current_chapter) || 0
+          line_offset = get_current_line_offset(state)
+          "Chapter #{chapter_index + 1}, Line #{line_offset + 1}"
+        end
+
+        def current_book_path
+          if @state_store.respond_to?(:get)
+            @state_store.get(%i[reader book_path])
+          elsif @state_store.respond_to?(:current_state)
+            (@state_store.current_state || {}).dig(:reader, :book_path)
+          end
+        end
+
+        def refresh_bookmarks(book_path = current_book_path)
+          return unless book_path
+
+          bookmarks = @bookmark_repository.find_by_book_path(book_path)
+          apply_state_updates({ %i[reader bookmarks] => bookmarks })
+        end
+
+        def apply_state_updates(updates)
+          return if updates.nil? || updates.empty?
+
+          if @state_store.respond_to?(:update)
+            @state_store.update(updates)
+          elsif @state_store.respond_to?(:set)
+            updates.each { |path, value| @state_store.set(path, value) }
+          end
+        end
+
+        def safe_snapshot
+          return {} unless @state_store.respond_to?(:current_state)
+
+          @state_store.current_state || {}
+        rescue StandardError
+          {}
+        end
+      end
+    end
+  end
+end