gloomberb 0.17.2 → 0.17.4

package/src/plugins/builtin/chat/content/whole-message-copy.ts

@@ -0,0 +1,70 @@
+import { useEffect, useRef } from "react";
+import type { ChatMessage } from "../../../../api-client";
+
+const BODY_SELECTOR = "[data-gloom-role=chat-message-body]";
+const MESSAGE_ID_ATTRIBUTE = "data-gloom-chat-message-id";
+
+/** Whether the selection takes in every character the body draws, first to last. */
+function coversBody(range: Range, body: Element): boolean {
+  const walker = body.ownerDocument.createTreeWalker(body, 4 /* NodeFilter.SHOW_TEXT */);
+  let first: [Node, number] | null = null;
+  let last: [Node, number] | null = null;
+  for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+    const text = node.textContent ?? "";
+    const start = text.search(/\S/);
+    if (start < 0) continue;
+    first ??= [node, start];
+    last = [node, text.trimEnd().length];
+  }
+  if (!first || !last) return false;
+  try {
+    return range.comparePoint(first[0], first[1]) === 0 && range.comparePoint(last[0], last[1]) === 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * What a copy of the selection puts on the clipboard when it takes in whole
+ * messages of this list: each as it was written, marks and all, one per line.
+ * Null when it takes in part of a message, which copies as drawn, or anything
+ * outside this list's messages.
+ */
+function wholeMessagesText(doc: Document, messages: readonly ChatMessage[]): string | null {
+  const selection = doc.getSelection();
+  if (!selection || selection.rangeCount === 0 || selection.isCollapsed) return null;
+  const range = selection.getRangeAt(0);
+  const bodies = Array.from(doc.querySelectorAll(BODY_SELECTOR)).filter((body) => range.intersectsNode(body));
+  if (bodies.length === 0) return null;
+  const parts: string[] = [];
+  for (const body of bodies) {
+    const id = body.closest(`[${MESSAGE_ID_ATTRIBUTE}]`)?.getAttribute(MESSAGE_ID_ATTRIBUTE);
+    const message = id ? messages.find((candidate) => candidate.id === id) : undefined;
+    if (!message || !coversBody(range, body)) return null;
+    parts.push(message.content);
+  }
+  return parts.join("\n");
+}
+
+/**
+ * Desktop and web: copying whole messages copies what their authors wrote,
+ * markdown and share links included, not the text as drawn. Copying part of a
+ * message copies what it shows.
+ */
+export function useWholeMessageCopy(enabled: boolean, messages: readonly ChatMessage[]): void {
+  const messagesRef = useRef(messages);
+  messagesRef.current = messages;
+  useEffect(() => {
+    const doc = (globalThis as { document?: Document }).document;
+    if (!enabled || !doc) return;
+    const onCopy = (event: ClipboardEvent) => {
+      if (event.defaultPrevented || !event.clipboardData) return;
+      const text = wholeMessagesText(doc, messagesRef.current);
+      if (text === null) return;
+      event.clipboardData.setData("text/plain", text);
+      event.preventDefault();
+    };
+    doc.addEventListener("copy", onCopy);
+    return () => doc.removeEventListener("copy", onCopy);
+  }, [enabled]);
+}

package/src/plugins/builtin/chat/controller/connections.ts

@@ -21,6 +21,21 @@ export function getSafetyRefreshChannelIds(channelStates: Iterable<[string, Chan
   return active.length > 0 ? active : [DEFAULT_CHAT_CHANNEL_ID];
 }
 
+/**
+ * The channels read live, each marked to read its latest page in full on its
+ * next refresh: after the socket was down, what changed on messages already
+ * held (reactions, edits, removals) does not come with newer messages.
+ */
+export function markConnectedChannelsForBackfill(channelStates: Iterable<[string, ChannelRuntimeState]>): string[] {
+  const channelIds: string[] = [];
+  for (const [channelId, channel] of channelStates) {
+    if (!channel.wsConnected) continue;
+    channel.backfilled = false;
+    channelIds.push(channelId);
+  }
+  return channelIds;
+}
+
 export function getOpenConnectionChannelIds(channelStates: Iterable<[string, ChannelRuntimeState]>): Set<string> {
   const channelIds = new Set<string>([DEFAULT_CHAT_CHANNEL_ID]);
   for (const [channelId, channel] of channelStates) {
@@ -76,6 +91,9 @@ export function ensureChatChannelConnection({
   if (channel.wsConnected) return;
   channel.wsConnected = true;
 
+  // Reactions, edits and removals on messages already held while the channel
+  // was not read live come only with a full page, not with newer messages.
+  channel.backfilled = false;
   void refreshMessages().catch(() => {});
 
   channel.wsConnection = connectChannel(

package/src/plugins/builtin/chat/controller/fetch.ts

@@ -35,8 +35,11 @@ export async function fetchLatestChannelMessages(
       limit: MESSAGE_PAGE_SIZE,
       after: backfillGaps ? undefined : channel.lastCursor ?? undefined,
     });
-    channel.backfilled = true;
-    if (backfillGaps) channel.backfilledAs = readerId;
+    // A full page asked for while this read was out still happens next time.
+    if (backfillGaps) {
+      channel.backfilled = true;
+      channel.backfilledAs = readerId;
+    }
     if ((!hasIncrementalCursor || backfillGaps) && messages.length < MESSAGE_PAGE_SIZE) {
       channel.reachedOldestMessage = true;
     }

package/src/plugins/builtin/chat/controller/index.ts

@@ -11,6 +11,7 @@ import {
   type ChatChannel,
   type ChatChannelState,
   type ChatMessage,
+  type ChatNotification,
   type ChatReaction,
   type ChatReactionsUpdate,
   type PersistedAuthUser,
@@ -56,10 +57,9 @@ import {
   ensureChatChannelConnection,
   getOpenConnectionChannelIds,
   getSafetyRefreshChannelIds as getChannelIdsForSafetyRefresh,
+  markConnectedChannelsForBackfill,
 } from "./connections";
-import {
-  handleChatNotification as handleChatNotificationEvent,
-} from "./notifications";
+import { ChatNotificationAlerts } from "./notifications";
 import {
   CHAT_MESSAGE_EDIT_WINDOW_LABEL,
   DISCORD_MESSAGE_EDIT_NOTICE,
@@ -116,7 +116,14 @@ export class ChatController {
   );
   private notifyFn: (notification: AppNotificationRequest) => AppNotificationDelivery | void = () => {};
   private openMessageFn: ((channelId: string, messageId: string) => void) | undefined;
-  private notifiedMessageIds = new Set<string>();
+  private readonly alerts = new ChatNotificationAlerts({
+    getAppActive: () => this.appActive,
+    ensureChannelState: (channelId) => this.ensureChannelState(channelId),
+    mergeMessages: (channelId, messages, options) => this.mergeMessages(channelId, messages, options),
+    getChannel: (channelId) => this.channelCatalog.getChannels().find((channel) => channel.id === channelId),
+    getNotify: () => this.notifyFn,
+    getOpenMessage: () => this.openMessageFn,
+  });
 
   private readonly storage = new ChatControllerStorage({
     emit: (channelId) => this.emit(channelId),
@@ -156,6 +163,11 @@ export class ChatController {
     getUser: () => this.session.user,
     refreshSession: () => this.refreshSession(),
     handleNotification: (notification) => this.handleChatNotification(notification),
+    handleChannelState: (state) => {
+      this.applyChannelState(state);
+      this.emit(state.channelId);
+      this.emit();
+    },
     handleReactions: (update) => this.applyReactionsUpdate(update),
     setOnlineCount: (onlineCount) => {
       this.channelCatalog.setOnlineCount(onlineCount);
@@ -163,6 +175,7 @@ export class ChatController {
     emit: () => this.emit(),
     getSafetyRefreshChannelIds: () => getChannelIdsForSafetyRefresh(this.storage.channelStates),
     runSafetyRefresh: (channelId) => this.messageLoading.runMessagesRefresh(channelId, { showLoading: false }),
+    resyncChannels: () => this.resyncConnectedChannels(),
   });
 
   attachPersistence(persistence: PluginPersistence, resume?: PluginResumeState): void {
@@ -170,6 +183,14 @@ export class ChatController {
     this.hydrate();
   }
 
+  /**
+   * A popped-out window has its own chat state but leaves background banners
+   * to the main window, so one message raises one banner per app.
+   */
+  setRaisesBackgroundAlerts(raises: boolean): void {
+    this.alerts.raisesBackgroundAlerts = raises;
+  }
+
   setNotifier(
     notify: (notification: AppNotificationRequest) => AppNotificationDelivery | void,
     openMessage?: (channelId: string, messageId: string) => void,
@@ -466,7 +487,7 @@ export class ChatController {
       },
       closeAllConnections: () => this.closeAllConnections(),
       emit: () => this.emit(),
-      stopRealtime: () => this.realtime.stopAll(),
+      stopRealtime: () => this.stopRealtime(),
     });
   }
 
@@ -502,7 +523,7 @@ export class ChatController {
       persistChannelState: (channelId) => this.storage.persistChannelState(channelId),
       persistSession: () => this.storage.persistSession(this.session.sessionToken, this.session.user),
       shouldClearSession: clearSession,
-      stopRealtime: () => this.realtime.stopAll(),
+      stopRealtime: () => this.stopRealtime(),
     });
   }
 
@@ -514,7 +535,7 @@ export class ChatController {
     });
     disposeChatControllerRuntime({
       channelStates: this.storage.channelStates,
-      clearNotifications: () => this.notifiedMessageIds.clear(),
+      clearNotifications: () => this.alerts.clear(),
       clearView: () => this.view.clear(),
       closeAllConnections: () => this.closeAllConnections(),
       flushDraftSync: (channelId) => this.storage.flushDraftSync(channelId),
@@ -522,7 +543,7 @@ export class ChatController {
         this.notifyFn = () => {};
         this.openMessageFn = undefined;
       },
-      stopRealtime: () => this.realtime.stopAll(),
+      stopRealtime: () => this.stopRealtime(),
     });
   }
 
@@ -778,6 +799,12 @@ export class ChatController {
     closeAllChannelConnections(this.storage.channelStates.values());
   }
 
+  /** Live updates stop, and so do alerts still waiting to go up: nobody signed in reads them. */
+  private stopRealtime(): void {
+    this.realtime.stopAll();
+    this.alerts.clear();
+  }
+
   private applySignedOutSession(): void {
     applySignedOutChatControllerSession({
       channelStates: this.storage.channelStates.values(),
@@ -785,10 +812,21 @@ export class ChatController {
       emit: () => this.emit(),
       persistSession: (sessionToken, user) => this.storage.persistSession(sessionToken, user),
       session: this.session,
-      stopRealtime: () => this.realtime.stopAll(),
+      stopRealtime: () => this.stopRealtime(),
     });
   }
 
+  /** Each channel read live reads its latest page in full, after any read already out. */
+  private resyncConnectedChannels(): void {
+    for (const channelId of markConnectedChannelsForBackfill(this.storage.channelStates)) {
+      const inFlight = this.ensureChannelState(channelId).refreshMessagesPromise ?? Promise.resolve();
+      void inFlight
+        .catch(() => {})
+        .then(() => this.messageLoading.runMessagesRefresh(channelId, { showLoading: false }))
+        .catch(() => {});
+    }
+  }
+
   private ensureOpenChannelConnections(): void {
     const channelIds = getOpenConnectionChannelIds(this.storage.channelStates);
     closeInactiveChannelConnections(this.storage.channelStates, channelIds);
@@ -823,20 +861,10 @@ export class ChatController {
   }
 
   private handleChatNotification(
-    notification: Parameters<typeof handleChatNotificationEvent>[0]["notification"],
+    notification: ChatNotification,
     options: { countUnread?: boolean } = {},
   ): void {
-    handleChatNotificationEvent({
-      notification,
-      options,
-      appActive: this.appActive,
-      ensureChannelState: (channelId) => this.ensureChannelState(channelId),
-      mergeMessages: (channelId, messages, mergeOptions) => this.mergeMessages(channelId, messages, mergeOptions),
-      getChannel: (channelId) => this.channelCatalog.getChannels().find((channel) => channel.id === channelId),
-      notifiedMessageIds: this.notifiedMessageIds,
-      notify: this.notifyFn,
-      openMessage: this.openMessageFn,
-    });
+    this.alerts.handle(notification, options);
   }
 
   private getUnreadMentionCount(channelId: string): number {

package/src/plugins/builtin/chat/controller/notifications.ts

@@ -11,83 +11,143 @@ import {
   formatReplyToast,
 } from "./utils";
 
-function wasNotificationDelivered(delivery: AppNotificationDelivery | void): boolean {
-  return !!delivery && (delivery.toastVisible || delivery.desktopRequested);
-}
+/**
+ * How long an app in the background holds a chat banner. The reader may be
+ * reading the message at that moment on another device or in a popped-out
+ * window, which tells the server within a second; the banner goes up only if
+ * the server still has the message unseen.
+ */
+const BACKGROUND_ALERT_DELAY_MS = 2_000;
 
-function notifyChatServerMessage({
-  notification,
-  channel,
-  notifiedMessageIds,
-  notify,
-  openMessage,
-}: {
-  notification: ChatNotification;
-  channel: ChatChannel | undefined;
-  notifiedMessageIds: Set<string>;
-  notify: (notification: AppNotificationRequest) => AppNotificationDelivery | void;
-  openMessage?: (channelId: string, messageId: string) => void;
-}): boolean {
-  if (notifiedMessageIds.has(notification.messageId)) return true;
-  const channelTitle = formatChatPaneTitle(channel, notification.channelId);
-  const body = notification.type === "reply"
-    ? formatReplyToast(notification.message)
-    : notification.type === "mention"
-      ? formatMentionToast(notification.message)
-      : formatChannelToast(notification.message, channel?.kind === "direct");
-  const delivered = wasNotificationDelivered(notify({
-    title: channelTitle,
-    body,
-    type: "info",
-    desktop: "when-inactive",
-    ...(openMessage ? {
-      action: {
-        label: "Open",
-        onClick: () => openMessage(notification.channelId, notification.messageId),
-      },
-    } : {}),
-  }));
-  if (delivered) {
-    notifiedMessageIds.add(notification.messageId);
-  }
-  return delivered;
-}
+type Notify = (notification: AppNotificationRequest) => AppNotificationDelivery | void;
 
-export function handleChatNotification({
-  notification,
-  options = {},
-  ensureChannelState,
-  mergeMessages,
-  appActive,
-  getChannel,
-  notifiedMessageIds,
-  notify,
-  openMessage,
-}: {
-  notification: ChatNotification;
-  options?: { countUnread?: boolean };
+interface ChatNotificationAlertsOptions {
+  getAppActive: () => boolean;
   ensureChannelState: (channelId: string) => ChannelRuntimeState;
   mergeMessages: (channelId: string, messages: ChatMessage[], options?: MergeMessagesOptions) => void;
-  appActive: boolean;
   getChannel: (channelId: string) => ChatChannel | undefined;
-  notifiedMessageIds: Set<string>;
-  notify: (notification: AppNotificationRequest) => AppNotificationDelivery | void;
-  openMessage?: (channelId: string, messageId: string) => void;
-}): void {
-  mergeMessages(notification.channelId, [notification.message], { countUnread: options.countUnread });
-  const channel = ensureChannelState(notification.channelId);
-  const activelyViewed = appActive && channel.focusedViewCount > 0;
-  const delivered = activelyViewed || notifyChatServerMessage({
-    notification,
-    channel: getChannel(notification.channelId),
-    notifiedMessageIds,
-    notify,
-    openMessage,
-  });
-  if (activelyViewed) {
-    notifiedMessageIds.add(notification.messageId);
+  getNotify: () => Notify;
+  getOpenMessage: () => ((channelId: string, messageId: string) => void) | undefined;
+}
+
+/** Whether this window holds the message as read: its read marker is at or after it. */
+function isReadHere(channel: ChannelRuntimeState, messageId: string): boolean {
+  const viewedId = channel.lastViewedMessageId;
+  if (!viewedId) return false;
+  if (viewedId === messageId) return true;
+  const viewedIndex = channel.messages.findIndex((message) => message.id === viewedId);
+  if (viewedIndex < 0) return false;
+  const messageIndex = channel.messages.findIndex((message) => message.id === messageId);
+  return messageIndex >= 0 && messageIndex <= viewedIndex;
+}
+
+/**
+ * Tells the server how a notification reached the reader. `seen`: where they
+ * were looking (the open channel, a toast in the foreground), which also
+ * stops the phone push waiting on it. Without it, only a banner on a
+ * computer nobody may be at, which still stops the email and the reminder on
+ * the next reconnect.
+ */
+function acknowledge(notification: ChatNotification, seen: boolean): void {
+  void apiClient.markChatNotificationsDelivered([notification.id], { seen }).catch(() => {});
+}
+
+/**
+ * Decides, once per message, whether a chat notification becomes a toast or
+ * a desktop banner. A message already read here or on another device stays
+ * quiet, whether it arrives live or again on reconnect.
+ */
+export class ChatNotificationAlerts {
+  private readonly notifiedMessageIds = new Set<string>();
+  private readonly waiting = new Map<string, ReturnType<typeof setTimeout>>();
+  private generation = 0;
+  /** False in a popped-out window: the main window raises the background banners. */
+  raisesBackgroundAlerts = true;
+  backgroundDelayMs = BACKGROUND_ALERT_DELAY_MS;
+
+  constructor(private readonly options: ChatNotificationAlertsOptions) {}
+
+  handle(notification: ChatNotification, options: { countUnread?: boolean } = {}): void {
+    this.options.mergeMessages(notification.channelId, [notification.message], { countUnread: options.countUnread });
+    if (this.notifiedMessageIds.has(notification.messageId)) {
+      // Shown here already; this copy came back on a reconnect.
+      acknowledge(notification, false);
+      return;
+    }
+    if (this.waiting.has(notification.id) || this.settledHere(notification)) return;
+
+    if (this.options.getAppActive()) {
+      this.present(notification);
+      return;
+    }
+    if (!this.raisesBackgroundAlerts) return;
+    const generation = this.generation;
+    this.waiting.set(notification.id, setTimeout(() => {
+      this.waiting.delete(notification.id);
+      void this.presentIfUnseen(notification, generation);
+    }, this.backgroundDelayMs));
   }
-  if (delivered) {
-    void apiClient.markChatNotificationsDelivered([notification.id]).catch(() => {});
+
+  /** Drops what is waiting and what was shown, as on sign-out. */
+  clear(): void {
+    this.generation += 1;
+    for (const timer of this.waiting.values()) clearTimeout(timer);
+    this.waiting.clear();
+    this.notifiedMessageIds.clear();
+  }
+
+  /** Read here, or open in front of the reader: nothing to raise, and the server hears it was seen. */
+  private settledHere(notification: ChatNotification): boolean {
+    const channel = this.options.ensureChannelState(notification.channelId);
+    const viewing = this.options.getAppActive() && channel.focusedViewCount > 0;
+    if (!viewing && !isReadHere(channel, notification.messageId)) return false;
+    this.notifiedMessageIds.add(notification.messageId);
+    acknowledge(notification, true);
+    return true;
+  }
+
+  private async presentIfUnseen(notification: ChatNotification, generation: number): Promise<void> {
+    let unseen = true;
+    try {
+      const ids = await apiClient.getUnseenChatNotificationIds([notification.id]);
+      unseen = ids.includes(notification.id);
+    } catch {
+      // A server that cannot say (an older one, a dropped request) gets the banner, as before.
+    }
+    if (generation !== this.generation || this.notifiedMessageIds.has(notification.messageId)) return;
+    if (!unseen) {
+      // Read, or shown in front of the reader, on another device or window.
+      this.notifiedMessageIds.add(notification.messageId);
+      return;
+    }
+    if (this.settledHere(notification)) return;
+    this.present(notification);
+  }
+
+  private present(notification: ChatNotification): void {
+    const channel = this.options.getChannel(notification.channelId);
+    const body = notification.type === "reply"
+      ? formatReplyToast(notification.message)
+      : notification.type === "mention"
+        ? formatMentionToast(notification.message)
+        : formatChannelToast(notification.message, channel?.kind === "direct");
+    const openMessage = this.options.getOpenMessage();
+    const delivery = this.options.getNotify()({
+      title: formatChatPaneTitle(channel, notification.channelId),
+      body,
+      type: "info",
+      desktop: "when-inactive",
+      ...(openMessage ? {
+        action: {
+          label: "Open",
+          onClick: () => openMessage(notification.channelId, notification.messageId),
+        },
+      } : {}),
+    });
+    const toastVisible = !!delivery && delivery.toastVisible;
+    // Nothing reached the reader: it stays pending for the email and the next reconnect.
+    if (!toastVisible && !(delivery && delivery.desktopRequested)) return;
+    this.notifiedMessageIds.add(notification.messageId);
+    acknowledge(notification, toastVisible);
   }
 }

package/src/plugins/builtin/chat/controller/realtime.ts

@@ -1,4 +1,9 @@
-import { apiClient, type ChatNotification, type ChatReactionsUpdate } from "../../../../api-client";
+import {
+  apiClient,
+  type ChatChannelState,
+  type ChatNotification,
+  type ChatReactionsUpdate,
+} from "../../../../api-client";
 import {
   SAFETY_REFRESH_MS,
   SESSION_RETRY_MS,
@@ -11,20 +16,25 @@ interface ChatControllerRealtimeOptions {
   getUser: () => { emailVerified?: boolean } | null;
   refreshSession: () => Promise<void>;
   handleNotification: (notification: ChatNotification) => void;
+  handleChannelState: (state: ChatChannelState) => void;
   handleReactions: (update: ChatReactionsUpdate) => void;
   setOnlineCount: (onlineCount: number) => void;
   emit: () => void;
   getSafetyRefreshChannelIds: () => string[];
   runSafetyRefresh: (channelId: string) => Promise<void>;
+  /** The socket came back after a drop: the channels read live read their latest page in full. */
+  resyncChannels: () => void;
 }
 
 export class ChatControllerRealtime {
   private verificationPollTimer: ReturnType<typeof setInterval> | null = null;
   private sessionRetryTimer: ReturnType<typeof setTimeout> | null = null;
   private safetyRefreshTimer: ReturnType<typeof setInterval> | null = null;
+  private socketConnectionUnsubscribe: (() => void) | null = null;
   private chatNotificationUnsubscribe: (() => void) | null = null;
   private chatPresenceUnsubscribe: (() => void) | null = null;
   private chatReactionsUnsubscribe: (() => void) | null = null;
+  private channelStateUnsubscribe: (() => void) | null = null;
 
   constructor(private readonly options: ChatControllerRealtimeOptions) {}
 
@@ -72,21 +82,47 @@ export class ChatControllerRealtime {
         this.options.handleReactions(update);
       });
     }
+    if (!this.channelStateUnsubscribe) {
+      // Read or muted on another device or window: the unread count, the
+      // Dock badge and alerts still waiting follow without a refocus.
+      this.channelStateUnsubscribe = apiClient.subscribeChatChannelState((state) => {
+        this.options.handleChannelState(state);
+      });
+    }
     if (!this.chatPresenceUnsubscribe) {
       this.chatPresenceUnsubscribe = apiClient.subscribeChatPresence((onlineCount) => {
         this.options.setOnlineCount(onlineCount);
         this.options.emit();
       });
     }
+    if (!this.socketConnectionUnsubscribe) {
+      // Frames sent while the socket was down are gone, and the catch-up
+      // only reads newer messages, so a reaction, edit or removal made
+      // meanwhile is read with a full page once it is back.
+      let dropped = false;
+      this.socketConnectionUnsubscribe = apiClient.subscribeSocketConnection((event) => {
+        if (event === "closed") {
+          dropped = true;
+          return;
+        }
+        if (!dropped) return;
+        dropped = false;
+        this.options.resyncChannels();
+      });
+    }
   }
 
   stopRealtimeSubscriptions(): void {
+    this.socketConnectionUnsubscribe?.();
+    this.socketConnectionUnsubscribe = null;
     this.chatNotificationUnsubscribe?.();
     this.chatNotificationUnsubscribe = null;
     this.chatPresenceUnsubscribe?.();
     this.chatPresenceUnsubscribe = null;
     this.chatReactionsUnsubscribe?.();
     this.chatReactionsUnsubscribe = null;
+    this.channelStateUnsubscribe?.();
+    this.channelStateUnsubscribe = null;
   }
 
   stopVerificationPolling(): void {