shoko 0.1.0

data/lib/shoko/application/reader_startup_orchestrator.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Application
+    # Orchestrates reader startup steps: terminal prep, progress restore,
+    # pagination preload, and background data loads.
+    class ReaderStartupOrchestrator
+      def initialize(dependencies)
+        @dependencies = dependencies
+        @terminal_service = @dependencies.resolve(:terminal_service)
+      end
+
+      # Execute startup sequence using the controller as context
+      # @param controller [Shoko::ReaderController]
+      def start(controller)
+        instrumentation = instrumentation_service
+        wrap_with_instrumentation(instrumentation, 'startup.reader') do
+          state = controller.state
+          page_calculator = controller.page_calculator
+          doc = controller.doc
+
+          # Query terminal size (FrameCoordinator will update state during rendering)
+          height, width = begin
+            @terminal_service.size
+          rescue StandardError
+            [nil, nil]
+          end
+
+          # Load progress after terminal is ready
+          sc = safe_resolve_state_controller
+          sc&.load_progress
+
+          if doc.respond_to?(:cached?) && doc.cached?
+            preloader = resolve_pagination_preloader(state, page_calculator)
+            result = preloader&.preload(doc, width:, height:)
+            controller.clear_defer_page_map! if result && result.status == :hit
+          end
+
+          # Perform initial calculations if needed
+          controller.perform_initial_calculations_if_needed if controller.pending_initial_calculation?
+
+          # Schedule background page-map build for instant-open path
+          controller.schedule_background_page_map_build if controller.defer_page_map?
+
+          # Background load bookmarks and annotations
+          submit_background_job(sc) do
+            svc = sc || safe_resolve_state_controller
+            if svc
+              svc.load_bookmarks
+              svc.refresh_annotations
+            end
+          end
+        end
+      end
+
+      private
+
+      def wrap_with_instrumentation(instrumentation, metric, &)
+        if instrumentation
+          instrumentation.time(metric, &)
+        else
+          yield
+        end
+      end
+
+      def instrumentation_service
+        @instrumentation_service ||= begin
+          @dependencies.resolve(:instrumentation_service)
+        rescue StandardError
+          nil
+        end
+      end
+
+      def safe_resolve_state_controller
+        @dependencies.resolve(:state_controller)
+      rescue StandardError
+        nil
+      end
+
+      def submit_background_job(_initial_state_controller, &)
+        worker = resolve_background_worker
+        if worker
+          worker.submit(&)
+        else
+          Thread.new do
+            yield
+          rescue StandardError
+            # ignore background failures
+          end
+        end
+      rescue StandardError
+        # ignore background failures
+        nil
+      end
+
+      def resolve_background_worker
+        return nil unless @dependencies.respond_to?(:resolve)
+
+        @dependencies.resolve(:background_worker)
+      rescue StandardError
+        nil
+      end
+
+      def resolve_pagination_preloader(_state, _page_calculator)
+        return nil unless @dependencies.respond_to?(:resolve)
+
+        @dependencies.resolve(:pagination_cache_preloader)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/shoko/application/selectors/config_selectors.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Application
+    module Selectors
+      # Selectors for configuration state
+      module ConfigSelectors
+        def self.view_mode(state)
+          state.get(%i[config view_mode])
+        end
+
+        def self.line_spacing(state)
+          state.get(%i[config line_spacing])
+        end
+
+        def self.page_numbering_mode(state)
+          state.get(%i[config page_numbering_mode])
+        end
+
+        def self.theme(state)
+          state.get(%i[config theme])
+        end
+
+        def self.show_page_numbers(state)
+          state.get(%i[config show_page_numbers])
+        end
+
+        def self.show_page_numbers?(state)
+          show_page_numbers(state)
+        end
+
+        def self.highlight_quotes(state)
+          state.get(%i[config highlight_quotes])
+        end
+
+        def self.highlight_quotes?(state)
+          highlight_quotes(state)
+        end
+
+        def self.highlight_keywords(state)
+          state.get(%i[config highlight_keywords])
+        end
+
+        def self.highlight_keywords?(state)
+          highlight_keywords(state)
+        end
+
+        def self.kitty_images(state)
+          state.get(%i[config kitty_images])
+        end
+
+        def self.kitty_images?(state)
+          !!kitty_images(state)
+        end
+
+        def self.config_hash(state)
+          state.get([:config])
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/selectors/menu_selectors.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Application
+    module Selectors
+      # Selectors for menu state - provides read-only access to state
+      module MenuSelectors
+        def self.selected(state)
+          state.get(%i[menu selected])
+        end
+
+        def self.selected_item(state)
+          selected(state)
+        end
+
+        def self.mode(state)
+          state.get(%i[menu mode])
+        end
+
+        def self.browse_selected(state)
+          state.get(%i[menu browse_selected])
+        end
+
+        def self.search_query(state)
+          state.get(%i[menu search_query]) || ''
+        end
+
+        def self.search_cursor(state)
+          state.get(%i[menu search_cursor])
+        end
+
+        def self.search_active(state)
+          state.get(%i[menu search_active])
+        end
+
+        def self.search_active?(state)
+          search_active(state)
+        end
+
+        def self.download_query(state)
+          state.get(%i[menu download_query]) || ''
+        end
+
+        def self.download_cursor(state)
+          state.get(%i[menu download_cursor])
+        end
+
+        def self.download_selected(state)
+          state.get(%i[menu download_selected])
+        end
+
+        def self.download_status(state)
+          state.get(%i[menu download_status])
+        end
+
+        def self.download_progress(state)
+          state.get(%i[menu download_progress])
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/selectors/reader_selectors.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require_relative '../../adapters/output/render_registry.rb'
+
+module Shoko
+  module Application
+    module Selectors
+      # Selectors for reader state - provides read-only access to state
+      # Replaces direct state access and convenience methods
+      module ReaderSelectors
+        # Chapter and page selectors
+        def self.current_chapter(state)
+          state.get(%i[reader current_chapter])
+        end
+
+        def self.current_page_index(state)
+          state.get(%i[reader current_page_index])
+        end
+
+        def self.current_page(state)
+          current_page_index(state) + 1
+        end
+
+        def self.left_page(state)
+          state.get(%i[reader left_page])
+        end
+
+        def self.right_page(state)
+          state.get(%i[reader right_page])
+        end
+
+        def self.single_page(state)
+          state.get(%i[reader single_page])
+        end
+
+        # Mode and UI state selectors
+        def self.mode(state)
+          state.get(%i[reader mode])
+        end
+
+        def self.selection(state)
+          state.get(%i[reader selection])
+        end
+
+        def self.message(state)
+          state.get(%i[reader message])
+        end
+
+        def self.running(state)
+          state.get(%i[reader running])
+        end
+
+        def self.running?(state)
+          running(state)
+        end
+
+        # List selectors
+        def self.bookmarks(state)
+          state.get(%i[reader bookmarks]) || []
+        end
+
+        def self.annotations(state)
+          state.get(%i[reader annotations]) || []
+        end
+
+        # Pagination selectors
+        def self.page_map(state)
+          state.get(%i[reader page_map]) || []
+        end
+
+        def self.total_pages(state)
+          state.get(%i[reader total_pages])
+        end
+
+        def self.pages_per_chapter(state)
+          state.get(%i[reader pages_per_chapter]) || []
+        end
+
+        # Dynamic pagination selectors
+        def self.dynamic_page_map(state)
+          state.get(%i[reader dynamic_page_map])
+        end
+
+        def self.dynamic_total_pages(state)
+          state.get(%i[reader dynamic_total_pages])
+        end
+
+        def self.dynamic_chapter_starts(state)
+          state.get(%i[reader dynamic_chapter_starts]) || []
+        end
+
+        # Terminal sizing selectors
+        def self.last_width(state)
+          state.get(%i[reader last_width])
+        end
+
+        def self.last_height(state)
+          state.get(%i[reader last_height])
+        end
+
+        def self.last_dynamic_width(state)
+          state.get(%i[reader last_dynamic_width])
+        end
+
+        def self.last_dynamic_height(state)
+          state.get(%i[reader last_dynamic_height])
+        end
+
+        def self.terminal_size_changed?(state, width, height)
+          width != last_width(state) || height != last_height(state)
+        end
+
+        # UI state selectors
+        def self.rendered_lines(state)
+          registry = begin
+            state.resolve(:render_registry)
+          rescue StandardError
+            nil
+          end
+          registry ||= begin
+            Shoko::Adapters::Output::RenderRegistry.current
+          rescue StandardError
+            nil
+          end
+          lines = registry&.lines
+          return lines if lines && !lines.empty?
+
+          state.get(%i[reader rendered_lines]) || {}
+        end
+
+        def self.popup_menu(state)
+          state.get(%i[reader popup_menu])
+        end
+
+        def self.annotations_overlay(state)
+          state.get(%i[reader annotations_overlay])
+        end
+
+        def self.annotation_editor_overlay(state)
+          state.get(%i[reader annotation_editor_overlay])
+        end
+
+        # Sidebar selectors
+        def self.sidebar_visible(state)
+          state.get(%i[reader sidebar_visible])
+        end
+
+        def self.sidebar_visible?(state)
+          sidebar_visible(state)
+        end
+
+        def self.sidebar_active_tab(state)
+          state.get(%i[reader sidebar_active_tab])
+        end
+
+        def self.sidebar_toc_selected(state)
+          state.get(%i[reader sidebar_toc_selected])
+        end
+
+        def self.sidebar_toc_collapsed(state)
+          state.get(%i[reader sidebar_toc_collapsed])
+        end
+
+        def self.sidebar_annotations_selected(state)
+          state.get(%i[reader sidebar_annotations_selected])
+        end
+
+        def self.sidebar_bookmarks_selected(state)
+          state.get(%i[reader sidebar_bookmarks_selected])
+        end
+
+        def self.sidebar_toc_filter(state)
+          state.get(%i[reader sidebar_toc_filter])
+        end
+
+        def self.sidebar_toc_filter_active(state)
+          state.get(%i[reader sidebar_toc_filter_active])
+        end
+
+        def self.sidebar_toc_filter_active?(state)
+          sidebar_toc_filter_active(state)
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/state/actions/base_action.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Application
+    module Actions
+      # Base action for immutable-like state updates via StateStore#dispatch
+      class BaseAction
+        def initialize(payload = {})
+          @payload = payload
+        end
+
+        # Apply the action to the given StateStore instance
+        # Implement in subclasses
+        def apply(_state)
+          raise NotImplementedError, 'Action subclasses must implement #apply(state)'
+        end
+
+        protected
+
+        attr_reader :payload
+      end
+    end
+  end
+end

data/lib/shoko/application/state/actions/quit_to_menu_action.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'base_action'
+
+module Shoko
+  module Application
+    module Actions
+      # Stop the reader loop (used to return to menu)
+      class QuitToMenuAction < BaseAction
+        def apply(state)
+          state.update({ %i[reader running] => false })
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/state/actions/switch_reader_mode_action.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'base_action'
+
+module Shoko
+  module Application
+    module Actions
+      # Switch reader mode: :read, :help
+      class SwitchReaderModeAction < BaseAction
+        VALID = %i[read help].freeze
+
+        def apply(state)
+          mode = (payload[:mode] || :read).to_sym
+          return state.get(%i[reader mode]) unless VALID.include?(mode)
+
+          state.update({ %i[reader mode] => mode })
+          mode
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/state/actions/toggle_view_mode_action.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'base_action'
+
+module Shoko
+  module Application
+    module Actions
+      # Toggle reader view between :split and :single
+      class ToggleViewModeAction < BaseAction
+        def apply(state)
+          current = state.get(%i[config view_mode]) || :split
+          new_mode = current == :split ? :single : :split
+
+          # Update all state changes atomically
+          state.update({
+                         %i[config view_mode] => new_mode,
+                         %i[reader last_width] => 0,
+                         %i[reader last_height] => 0,
+                         %i[reader dynamic_page_map] => nil,
+                         %i[reader dynamic_total_pages] => 0,
+                         %i[reader last_dynamic_width] => 0,
+                         %i[reader last_dynamic_height] => 0,
+                       })
+          state.save_config if state.respond_to?(:save_config)
+
+          new_mode
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/state/actions/update_annotation_editor_overlay_action.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'base_action'
+
+module Shoko
+  module Application
+    module Actions
+      # Stores the annotation editor overlay component in state.
+      class UpdateAnnotationEditorOverlayAction < BaseAction
+        def initialize(overlay)
+          super(overlay: overlay)
+        end
+
+        def apply(state)
+          state.update({ %i[reader annotation_editor_overlay] => payload[:overlay] })
+        end
+      end
+
+      # Clears any active annotation editor overlay from state.
+      class ClearAnnotationEditorOverlayAction < UpdateAnnotationEditorOverlayAction
+        def initialize
+          super(nil)
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/state/actions/update_annotations_action.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'base_action'
+
+module Shoko
+  module Application
+    module Actions
+      # Action for updating annotations list
+      class UpdateAnnotationsAction < BaseAction
+        def initialize(annotations)
+          super(annotations: annotations)
+        end
+
+        def apply(state)
+          state.update({ %i[reader annotations] => payload[:annotations] })
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/state/actions/update_annotations_overlay_action.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'base_action'
+
+module Shoko
+  module Application
+    module Actions
+      # Updates the reader annotations overlay component stored in state.
+      class UpdateAnnotationsOverlayAction < BaseAction
+        def initialize(overlay)
+          super(overlay: overlay)
+        end
+
+        def apply(state)
+          state.update({ %i[reader annotations_overlay] => payload[:overlay] })
+        end
+      end
+
+      # Clears any active annotations overlay.
+      class ClearAnnotationsOverlayAction < UpdateAnnotationsOverlayAction
+        def initialize
+          super(nil)
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/state/actions/update_bookmarks_action.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'base_action'
+
+module Shoko
+  module Application
+    module Actions
+      # Action for updating the bookmarks list
+      class UpdateBookmarksAction < BaseAction
+        def initialize(bookmarks)
+          super(bookmarks: bookmarks)
+        end
+
+        def apply(state)
+          state.update({ %i[reader bookmarks] => payload[:bookmarks] })
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/state/actions/update_chapter_action.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'base_action'
+
+module Shoko
+  module Application
+    module Actions
+      # Action for updating the current chapter
+      class UpdateChapterAction < BaseAction
+        def initialize(chapter_index)
+          super(chapter_index: chapter_index)
+        end
+
+        def apply(state)
+          idx = payload[:chapter_index]
+          updates = {
+            %i[reader current_chapter] => idx,
+          }
+          state.update(updates)
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/state/actions/update_config_action.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'base_action'
+
+module Shoko
+  module Application
+    module Actions
+      # Action for updating configuration values
+      class UpdateConfigAction < BaseAction
+        def apply(state)
+          # Build update hash for atomic state update
+          updates = {}
+          payload.each do |config_field, value|
+            updates[[:config, config_field]] = value
+          end
+          state.update(updates)
+          state.save_config if state.respond_to?(:save_config)
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/state/actions/update_field_helpers.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'base_action'
+
+module Shoko
+  module Application
+    module Actions
+      # Shared helpers for applying whitelisted state update fields.
+      module UpdateFieldHelpers
+        module_function
+
+        # Apply only allowed fields under a namespaced state path
+        # e.g., namespace = :reader results in updates to [:reader, field]
+        def apply_allowed(state, payload, allowed, namespace: :reader)
+          updates = {}
+          payload.each do |field, value|
+            next unless allowed.include?(field)
+
+            updates[[namespace, field]] = value
+          end
+          state.update(updates) unless updates.empty?
+        end
+      end
+    end
+  end
+end