chats 0.4.2 → 0.5.0

data/app/controllers/chats/conversations_controller.rb

@@ -2,8 +2,12 @@
 
 module Chats
   # The inbox (index), the thread (show), starting conversations from host
-  # pages (create), and the per-member actions (read/typing/leave/mute).
+  # pages (create), the messaging dock's recent list (dock), and the
+  # per-member actions (read/typing/leave/mute).
   class ConversationsController < ApplicationController
+    # The most rows the dock's recent list shows, whatever `recent:` asks.
+    DOCK_RECENT_LIMIT = 50
+
     before_action :set_conversation, only: %i[show read typing leave mute unmute refresh]
     helper_method :chats_counterpart
 
@@ -13,6 +17,11 @@ module Chats
     # Rows are Conversation | InboxGroup: stacking, search and the `?with=`
     # filter all live in Chats::Inbox, so this action stays three lines.
     def index
+      # The dock's search form posts here, so that without JavaScript it
+      # lands on the full inbox's results; from the dock's frame, the answer
+      # is the dock's own list.
+      return dock if turbo_frame_request_id == "chats_dock_list"
+
       @inbox = Chats::Inbox.for(chats_current_messager, query: params[:q], with: inbox_filter)
       @rows = @inbox.rows
       @unread_counts = @inbox.unread_counts
@@ -23,9 +32,25 @@ module Chats
       @conversations = @inbox.conversations
     end
 
+    # The messaging dock's recent list (`chats_dock`): the first rows of the
+    # viewer's inbox — the same rows, stacks and search, through the same
+    # Chats::Inbox — rendered into the dock's `chats_dock_list` frame. The
+    # frame asks for `?recent=` rows (the helper's `recent:` option).
+    def dock
+      @inbox = Chats::Inbox.for(chats_current_messager, query: params[:q], limit: dock_recent)
+      @rows = @inbox.rows
+      @unread_counts = @inbox.unread_counts
+
+      render :dock, layout: false
+    end
+
     # The thread. Renders the LATEST page of messages; older pages stream in
     # through a lazy Turbo Frame chain (keyset-paginated — see
     # Message.before_message and _messages_page.html.erb).
+    #
+    # `?window=1` from a Turbo frame is the same thread as a floating dock
+    # window: the window template (its compact header around the same
+    # thread body), no layout.
     def show
       @participant = @conversation.participant_for(chats_current_messager)
 
@@ -55,9 +80,17 @@ module Chats
                              @messages.first&.id
         end
 
-        # Opening the thread reads it. (Live appends while the thread stays
-        # open are read via the thread controller's POST to #read.)
-        @participant&.read!
+        if dock_window?
+          # A window does NOT read on render: it may be restored minimized
+          # after a reload, and a header nobody has looked at must not
+          # swallow the unread badge. The thread controller posts #read once
+          # the window is actually on screen (`read-pending`).
+          render :window, layout: false
+        elsif !prefetch?
+          # Opening the thread reads it. (Live appends while the thread
+          # stays open are read via the thread controller's POST to #read.)
+          @participant&.read!
+        end
       end
     end
 
@@ -106,6 +139,12 @@ module Chats
     # `chat_button_to` helper — unforgeable and purpose-scoped, so raw
     # polymorphic params never reach `GlobalID::Locator`. Policy and block
     # checks still run inside `chat_with` (defense in depth).
+    #
+    # `dock=1` (`chat_button_to …, dock: true`) answers a Turbo Stream that
+    # appends the conversation's floating window to the dock instead of
+    # navigating. Same id, so a window already open is replaced, not
+    # doubled; on a page without the dock the stream has no target and does
+    # nothing. Without Turbo it is the plain redirect.
     def create
       recipient = locate_signed!(params.require(:recipient_sgid), purpose: :chats_recipient)
       raise ActiveRecord::RecordNotFound unless Chats.messager_class?(recipient.class)
@@ -114,7 +153,16 @@ module Chats
                 locate_signed!(params[:subject_sgid], purpose: :chats_subject)
 
       conversation = chats_current_messager.chat_with(recipient, about: subject)
-      redirect_to conversation_path(conversation)
+
+      if params[:dock].present? && request.format.turbo_stream?
+        render turbo_stream: turbo_stream.append(
+          "chats_dock_windows",
+          partial: "chats/dock/window",
+          locals: { conversation: conversation, focus: true }
+        )
+      else
+        redirect_to conversation_path(conversation)
+      end
     rescue Chats::BlockedError
       # Fallback is the INBOX (engine root) — inside the engine, `root_path`
       # already resolves there, never to the host root.
@@ -165,6 +213,24 @@ module Chats
       @conversation = find_conversation
     end
 
+    # A dock window asks for its thread from inside its own turbo frame. A
+    # plain visit to the same URL (no frame) still gets the page.
+    def dock_window?
+      params[:window].present? && turbo_frame_request?
+    end
+
+    # Turbo 8 prefetches a link when the pointer rests on it, and a pointer
+    # resting on an inbox row is not somebody reading the thread. The visit
+    # itself, if it happens, reads.
+    # https://turbo.hotwired.dev/handbook/drive#prefetching-links-on-hover
+    def prefetch?
+      request.headers["X-Sec-Purpose"] == "prefetch" || request.headers["Sec-Purpose"]&.include?("prefetch")
+    end
+
+    def dock_recent
+      Integer(params[:recent], exception: false)&.clamp(1, DOCK_RECENT_LIMIT) || 10
+    end
+
     def locate_signed!(sgid, purpose:)
       GlobalID::Locator.locate_signed(sgid, for: purpose) || raise(ActiveRecord::RecordNotFound)
     end

data/app/helpers/chats/engine_helper.rb

@@ -15,6 +15,7 @@ module Chats
       composer_actions
       locked_composer
       message_meta
+      dock_panel_footer
     ].freeze
 
     # The "message this person" affordance for host pages — a listing, a
@@ -24,18 +25,24 @@ module Chats
     #
     #   <%= chat_button_to @driver, about: @ride, label: "Chat with driver" %>
     #
+    # `dock: true` opens the conversation in a floating window of the
+    # messaging dock (`chats_dock`) instead of navigating to it. It belongs
+    # with `chats_dock` on the same page: without the dock the button's Turbo
+    # Stream has nowhere to land and nothing happens.
+    #
     # The recipient/subject travel as SIGNED GlobalIDs (purpose-scoped,
     # minted here, verified in Chats::ConversationsController#create), so the
     # endpoint never trusts raw polymorphic params. `expires_in: nil` because
     # these buttons sit on long-lived pages — the default 1-month sgid expiry
     # would quietly break stale tabs.
-    def chat_button_to(other, about: nil, label: nil, **html_options)
+    def chat_button_to(other, about: nil, label: nil, dock: false, **html_options)
       viewer = chats_viewer
       return if viewer.nil? || other.nil? || viewer == other
       return unless Chats.can_message?(viewer, other)
 
       params = { recipient_sgid: other.to_sgid(expires_in: nil, for: :chats_recipient).to_s }
       params[:subject_sgid] = about.to_sgid(expires_in: nil, for: :chats_subject).to_s if about
+      params[:dock] = 1 if dock
 
       button_to(
         label || I18n.t("chats.buttons.chat"),
@@ -59,6 +66,67 @@ module Chats
                 ])
     end
 
+    # The messaging dock, LinkedIn / Steam style: a bar in the bottom-right
+    # corner with the unread badge, a panel of recent conversations, and
+    # floating conversation windows. One line in the host's layout:
+    #
+    #   <%= chats_dock %>
+    #
+    # Renders nothing for a signed-out visitor, and nothing on the engine's
+    # own pages (the inbox, a thread): those already ARE the messaging UI,
+    # and a window there would duplicate the thread's DOM ids the live
+    # streams address. The dock is permanent across Turbo visits, so the
+    # server can't take it away on the next page: it also hides ITSELF on
+    # any page carrying `data-chats-dock-hide` (the engine's pages do; put
+    # it on your own messaging pages). `everywhere: true` renders it on the
+    # engine's pages and ignores data-chats-dock-hide (it still never opens
+    # a window for a conversation the page itself shows).
+    #
+    #   windows:   how many windows may be open at once (3, and never more
+    #              than fit beside the panel: 2 at 1280px, 1 at 768px)
+    #   recent:    how many conversations the panel lists (10)
+    #   launcher:  false drops the phone's floating button, for a host that
+    #              opens the sheet from its own nav (see chats_dock_toggle)
+    def chats_dock(windows: 3, recent: 10, launcher: true, everywhere: false)
+      viewer = chats_viewer
+      return if viewer.nil?
+      return if chats_engine_page? && !everywhere
+
+      render(partial: "chats/dock/dock",
+             locals: { viewer: viewer, windows: windows, recent: recent, launcher: launcher, everywhere: everywhere })
+    end
+
+    # The data that makes ANY link to a conversation — a recent-list row, a
+    # host's own link — open that conversation's dock window instead of
+    # navigating, when a dock is on the page. The link stays a real link: a
+    # modified click, a page without the dock, or no JavaScript navigates.
+    #
+    #   <%= link_to "Chat", chats.conversation_path(c), data: chats_dock_opener(c) %>
+    def chats_dock_opener(conversation)
+      { chats_dock_conversation_id: conversation.id }
+    end
+
+    # The data that makes a host's own Messages link open the dock's panel
+    # (the full-screen sheet on a phone) instead of navigating, when a dock
+    # is on the page. Pair it with `chats_dock(launcher: false)` to replace
+    # the phone's floating button with your nav's. Without the dock, or
+    # without JavaScript, the link goes where its href says.
+    #
+    #   <%= link_to "Messages", chats.conversations_path, data: chats_dock_toggle %>
+    def chats_dock_toggle
+      { chats_dock_toggle: true }
+    end
+
+    # Whether +viewer+ muted +conversation+, read from the preloaded seats
+    # (the inbox loads them), so a row costs no query for it.
+    def chats_muted?(conversation, viewer)
+      return false if viewer.nil?
+
+      conversation.participants.any? do |seat|
+        seat.muted? && seat.messager_type == viewer.class.polymorphic_name && seat.messager_id == viewer.id
+      end
+    end
+
     # An avatar for any messager: whatever `config.messager_avatar` returns
     # (URL / ActiveStorage attachment / variant) or an initials placeholder.
     def chats_messager_avatar(messager, css_class: "chats-avatar", loading: "eager")
@@ -148,7 +216,7 @@ module Chats
     #   app/views/chats/slots/_inbox_top.html.erb
     #
     # The slots: inbox_top, inbox_empty, conversation_header_actions,
-    # composer_actions, locked_composer, message_meta.
+    # composer_actions, locked_composer, message_meta, dock_panel_footer.
     def chats_slot(name, **locals)
       return unless chats_slot?(name)
 
@@ -275,6 +343,11 @@ module Chats
       respond_to?(method_name) ? send(method_name) : nil
     end
 
+    # Whether this view is one of the engine's own screens.
+    def chats_engine_page?
+      respond_to?(:controller) && controller.is_a?(Chats::ApplicationController)
+    end
+
     # Active Storage routes are drawn on the host app, not on this isolated
     # engine. A bare `image_tag variant` is fine in normal host views, but
     # inside engine views it asks the engine route set to polymorphically

data/app/javascript/chats/composer_controller.js

@@ -76,8 +76,11 @@ export default class extends Controller {
   // are disabled while editing (edits are body-only by design).
 
   beginEdit(event) {
-    const { id, body } = event.detail || {}
+    const { id, body, thread } = event.detail || {}
     if (!id || !this.hasInputTarget) return
+    // Several threads can share a page (the dock's windows): only the
+    // composer of the thread the message lives in edits it.
+    if (thread && !thread.contains(this.element)) return
 
     this.createAction ||= this.element.action
     this.element.action = `${this.createAction}/${id}`
@@ -112,6 +115,16 @@ export default class extends Controller {
     this.inputTarget.setSelectionRange(this.inputTarget.value.length, this.inputTarget.value.length)
   }
 
+  // Escape while editing cancels the edit, and only that: the dock (if the
+  // composer is in one of its windows) sees the event handled and leaves
+  // the window alone.
+  escape(event) {
+    if (!this.editing) return
+
+    event.preventDefault()
+    this.cancelEdit()
+  }
+
   cancelEdit(event) {
     event?.preventDefault()
     this.exitEdit()