shoko 0.1.0

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'base_action'
+
+module Shoko
+  module Application
+    module Actions
+      # Action for updating menu-related state under [:menu, *]
+      class UpdateMenuAction < BaseAction
+        # Payload is a hash of menu_field => value
+        def apply(state)
+          updates = {}
+          payload.each do |field, value|
+            updates[[:menu, field]] = value
+          end
+          state.update(updates)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'base_action'
+require_relative '../../../adapters/output/terminal/terminal_sanitizer.rb'
+
+module Shoko
+  module Application
+    module Actions
+      # Action for updating the status message
+      class UpdateMessageAction < BaseAction
+        def initialize(message)
+          super(message: message)
+        end
+
+        def apply(state)
+          msg = payload[:message]
+          safe = if msg.nil?
+                   nil
+                 else
+                   Shoko::Adapters::Output::Terminal::TerminalSanitizer.sanitize(msg.to_s, preserve_newlines: false,
+                                                                              preserve_tabs: false)
+                 end
+          state.update({ %i[reader message] => safe })
+        end
+      end
+
+      # Convenience action for clearing message
+      class ClearMessageAction < UpdateMessageAction
+        def initialize
+          super(nil)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'base_action'
+
+module Shoko
+  module Application
+    module Actions
+      # Action for updating page positions (current_page_index, left_page, right_page, single_page)
+      class UpdatePageAction < BaseAction
+        def apply(state)
+          # Build update hash for atomic state update
+          updates = {}
+          payload.each do |page_field, value|
+            updates[[:reader, page_field]] = value
+          end
+          state.update(updates)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'base_action'
+
+require_relative 'update_field_helpers'
+
+module Shoko
+  module Application
+    module Actions
+      # Action to update pagination-related reader state in a single, consistent way.
+      # Allowed fields: :page_map, :total_pages, :last_width, :last_height, :total_chapters
+      class UpdatePaginationStateAction < BaseAction
+        ALLOWED = %i[page_map total_pages last_width last_height total_chapters].freeze
+
+        def apply(state)
+          UpdateFieldHelpers.apply_allowed(state, payload, ALLOWED, namespace: :reader)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'base_action'
+
+module Shoko
+  module Application
+    module Actions
+      # Action for updating popup menu state
+      class UpdatePopupMenuAction < BaseAction
+        def initialize(popup_menu)
+          super(popup_menu: popup_menu)
+        end
+
+        def apply(state)
+          state.update({ %i[reader popup_menu] => payload[:popup_menu] })
+        end
+      end
+
+      # Convenience action for clearing popup menu
+      class ClearPopupMenuAction < UpdatePopupMenuAction
+        def initialize
+          super(nil)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'base_action'
+
+require_relative 'update_field_helpers'
+
+module Shoko
+  module Application
+    module Actions
+      # Action to update reader meta fields that are not pagination specific
+      # Allowed fields: :book_path, :running
+      class UpdateReaderMetaAction < BaseAction
+        ALLOWED = %i[book_path running].freeze
+
+        def apply(state)
+          UpdateFieldHelpers.apply_allowed(state, payload, ALLOWED, namespace: :reader)
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'base_action'
+require_relative '../../../adapters/output/render_registry.rb'
+
+module Shoko
+  module Application
+    module Actions
+      # Action for updating rendered lines cache
+      class UpdateRenderedLinesAction < BaseAction
+        def initialize(rendered_lines)
+          super(rendered_lines: rendered_lines)
+        end
+
+        def apply(state)
+          registry = begin
+            state.resolve(:render_registry) if state.respond_to?(:resolve)
+          rescue StandardError
+            nil
+          end
+          registry ||= begin
+            Shoko::Adapters::Output::RenderRegistry.current
+          rescue StandardError
+            nil
+          end
+          registry&.write(payload[:rendered_lines])
+          # Keep state entry lightweight for observers; avoid storing the large hash
+          state.update({ %i[reader rendered_lines] => :render_registry })
+        end
+      end
+
+      # Convenience action for clearing rendered lines
+      class ClearRenderedLinesAction < UpdateRenderedLinesAction
+        def initialize
+          super({})
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'base_action'
+
+module Shoko
+  module Application
+    module Actions
+      # Action for updating text selection state
+      class UpdateSelectionAction < BaseAction
+        def initialize(selection)
+          super(selection: selection)
+        end
+
+        def apply(state)
+          state.update({ %i[reader selection] => payload[:selection] })
+        end
+      end
+
+      # Convenience action for clearing selection
+      class ClearSelectionAction < UpdateSelectionAction
+        def initialize
+          super(nil)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'base_action'
+
+module Shoko
+  module Application
+    module Actions
+      # Action for updating various selection states
+      class UpdateSelectionsAction < BaseAction
+        def apply(state)
+          # Build update hash for atomic state update
+          updates = {}
+          payload.each do |field, value|
+            updates[[:reader, field]] = value
+          end
+          state.update(updates)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'base_action'
+
+module Shoko
+  module Application
+    module Actions
+      # Action for updating sidebar state
+      class UpdateSidebarAction < BaseAction
+        def apply(state)
+          # Build update hash for atomic state update
+          updates = {}
+          payload.each do |field, value|
+            case field
+            when :visible
+              updates[%i[reader sidebar_visible]] = value
+            when :active_tab
+              updates[%i[reader sidebar_active_tab]] = value
+            when :toc_selected
+              updates[%i[reader sidebar_toc_selected]] = value
+            when :toc_collapsed
+              updates[%i[reader sidebar_toc_collapsed]] = value
+            when :annotations_selected
+              updates[%i[reader sidebar_annotations_selected]] = value
+            when :bookmarks_selected
+              updates[%i[reader sidebar_bookmarks_selected]] = value
+            end
+          end
+          state.update(updates)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'base_action'
+
+module Shoko
+  module Application
+    module Actions
+      # Action for updating UI loading indicators
+      # Accepts any of: :loading_active, :loading_message, :loading_progress
+      class UpdateUILoadingAction < BaseAction
+        def apply(state)
+          updates = {}
+          payload.each do |field, value|
+            next unless %i[loading_active loading_message loading_progress].include?(field)
+
+            updates[[:ui, field]] = value
+          end
+          state.update(updates) unless updates.empty?
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/ui/reader_view_model_builder.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Application
+    module UI
+      # Builds ReaderViewModel from state and document, keeping controller lean.
+      class ReaderViewModelBuilder
+      def initialize(state, doc)
+        @state = state
+        @doc = doc
+      end
+
+        def build(page_info)
+          ViewModels::ReaderViewModel.new(**attributes(page_info))
+        end
+
+      private
+
+      def attributes(page_info)
+        base_attributes.merge(page_info: page_info)
+      end
+
+      def base_attributes
+        {
+          current_chapter: current_chapter_index,
+          total_chapters: total_chapter_count,
+          current_page: state_value(%i[reader current_page]),
+          total_pages: state_value(%i[reader total_pages]),
+          chapter_title: chapter_title(current_chapter_index),
+          document_title: @doc&.title || '',
+          view_mode: state_value(%i[config view_mode], :split),
+          sidebar_visible: state_value(%i[reader sidebar_visible]),
+          mode: state_value(%i[reader mode]),
+          message: state_value(%i[reader message]),
+          bookmarks: state_value(%i[reader bookmarks], []),
+          toc_entries: doc_toc_entries,
+          show_page_numbers: state_value(%i[config show_page_numbers], true),
+          page_numbering_mode: state_value(%i[config page_numbering_mode], :dynamic),
+          line_spacing: state_value(%i[config line_spacing], Shoko::Core::Models::ReaderSettings::DEFAULT_LINE_SPACING),
+          language: @doc&.language || 'en',
+        }
+      end
+
+      def current_chapter_index
+        state_value(%i[reader current_chapter])
+      end
+
+      def total_chapter_count
+        Array(@doc&.chapters).length
+      end
+
+      def chapter_title(index)
+        chapter = @doc&.get_chapter(index)
+        chapter&.title || ''
+      rescue StandardError
+        ''
+      end
+
+      def doc_toc_entries
+        return [] unless @doc.respond_to?(:toc_entries)
+
+        Array(@doc.toc_entries)
+      rescue StandardError
+        []
+      end
+
+        def state_value(path, default = nil)
+          value = @state.get(path)
+          value.nil? ? default : value
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/ui/view_models/reader_view_model.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Application::UI
+    module ViewModels
+      # Pure data structure for reader view rendering.
+      # Eliminates component coupling to controllers and services.
+      class ReaderViewModel
+        attr_reader :current_chapter, :total_chapters, :current_page, :total_pages,
+                    :chapter_title, :document_title, :view_mode, :sidebar_visible, :mode, :message,
+                    :bookmarks, :toc_entries, :content_lines, :page_info, :show_page_numbers,
+                    :page_numbering_mode, :line_spacing, :language
+
+        def initialize(
+          current_chapter: 0,
+          total_chapters: 0,
+          current_page: 0,
+          total_pages: 0,
+          chapter_title: '',
+          document_title: '',
+          view_mode: :split,
+          sidebar_visible: false,
+          mode: :read,
+          message: nil,
+          bookmarks: [],
+          toc_entries: [],
+          content_lines: [],
+          page_info: {},
+          show_page_numbers: true,
+          page_numbering_mode: :dynamic,
+          line_spacing: :compact,
+          language: 'en'
+        )
+          @current_chapter = current_chapter
+          @total_chapters = total_chapters
+          @current_page = current_page
+          @total_pages = total_pages
+          @chapter_title = chapter_title
+          @document_title = document_title
+          @view_mode = view_mode
+          @sidebar_visible = sidebar_visible
+          @mode = mode
+          @message = message
+          @bookmarks = bookmarks
+          @toc_entries = toc_entries
+          @content_lines = content_lines
+          @page_info = page_info
+          @show_page_numbers = show_page_numbers
+          @page_numbering_mode = page_numbering_mode
+          @line_spacing = line_spacing
+          @language = language
+          freeze
+        end
+
+        # Derived properties
+        def progress_percentage
+          return 0 if total_pages.zero?
+
+          ((current_page.to_f / total_pages) * 100).round(1)
+        end
+
+        def chapter_progress
+          return '0/0' if total_chapters.zero?
+
+          "#{current_chapter + 1}/#{total_chapters}"
+        end
+
+        def page_progress
+          return '0/0' if total_pages.zero?
+
+          "#{current_page + 1}/#{total_pages}"
+        end
+
+        def split_mode?
+          view_mode == :split
+        end
+
+        def single_mode?
+          view_mode == :single
+        end
+
+        def message?
+          !message.nil? && !message.empty?
+        end
+
+        def bookmarks?
+          !bookmarks.empty?
+        end
+
+        def toc?
+          !toc_entries.empty?
+        end
+
+        # Create new instance with updates
+        def with(**changes)
+          current_attributes = {
+            current_chapter: current_chapter,
+            total_chapters: total_chapters,
+            current_page: current_page,
+            total_pages: total_pages,
+            chapter_title: chapter_title,
+            document_title: document_title,
+            view_mode: view_mode,
+            sidebar_visible: sidebar_visible,
+            mode: mode,
+            message: message,
+            bookmarks: bookmarks,
+            toc_entries: toc_entries,
+            content_lines: content_lines,
+            page_info: page_info,
+            show_page_numbers: show_page_numbers,
+            page_numbering_mode: page_numbering_mode,
+            line_spacing: line_spacing,
+            language: language,
+          }
+
+          self.class.new(**current_attributes, **changes)
+        end
+      end
+
+      # View model for menu screens (main/browse/settings/annotations).
+      class MenuViewModel
+        attr_reader :mode, :selected_index, :items, :search_query, :search_active,
+                    :message, :title
+
+        def initialize(
+          mode: :main,
+          selected_index: 0,
+          items: [],
+          search_query: '',
+          search_active: false,
+          message: nil,
+          title: 'Shoko'
+        )
+          @mode = mode
+          @selected_index = selected_index
+          @items = items
+          @search_query = search_query
+          @search_active = search_active
+          @message = message
+          @title = title
+          freeze
+        end
+
+        def selected_item
+          items[selected_index]
+        end
+
+        def items?
+          !items.empty?
+        end
+
+        def message?
+          !message.nil? && !message.empty?
+        end
+
+        def searching?
+          search_active
+        end
+
+        def with(**changes)
+          current_attributes = {
+            mode: mode,
+            selected_index: selected_index,
+            items: items,
+            search_query: search_query,
+            search_active: search_active,
+            message: message,
+            title: title,
+          }
+
+          self.class.new(**current_attributes, **changes)
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/unified_application.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Application
+    # Unified application entry point that handles both file and menu scenarios
+    class UnifiedApplication
+      def initialize(epub_path = nil)
+        @epub_path = epub_path
+        @dependencies = Shoko::Application::ContainerFactory.create_default_container
+        @instrumentation = begin
+          @dependencies.resolve(:instrumentation_service)
+        rescue StandardError
+          nil
+        end
+      end
+
+      def run
+        if @epub_path
+          reader_mode
+        else
+          menu_mode
+        end
+      end
+
+      private
+
+      def reader_mode
+        # Ensure alternate screen is entered before any heavy work for instant-open UX
+        term = @dependencies.resolve(:terminal_service)
+        term.setup
+        @instrumentation&.start_trace(@epub_path)
+        begin
+          # Pass dependencies to MouseableReader
+          Controllers::MouseableReader.new(@epub_path, nil, @dependencies).run
+        ensure
+          # Balance setup to avoid lingering session depth
+          term.cleanup
+          @instrumentation&.cancel_trace
+        end
+      end
+
+      def menu_mode
+        # Pass dependencies to MenuController
+        Controllers::MenuController.new(@dependencies).run
+      end
+    end
+  end
+end