Pass matrixClient to Unread

matrix-org · May 26, 2023 · 0dfd20d · 0dfd20d
1 parent 14bedf3
commit 0dfd20d
Show file tree

Hide file tree

Showing 3 changed files with 18 additions and 14 deletions.
diff --git a/src/Unread.ts b/src/Unread.ts
@@ -20,8 +20,8 @@ import { MatrixEvent } from "matrix-js-sdk/src/models/event";
 import { EventType } from "matrix-js-sdk/src/@types/event";
 import { M_BEACON } from "matrix-js-sdk/src/@types/beacon";
 import { logger } from "matrix-js-sdk/src/logger";
+import { MatrixClient } from "matrix-js-sdk/src/matrix";
 
-import { MatrixClientPeg } from "./MatrixClientPeg";
 import shouldHideEvent from "./shouldHideEvent";
 import { haveRendererForEvent } from "./events/EventTileFactory";
 import SettingsStore from "./settings/SettingsStore";
@@ -30,11 +30,12 @@ import SettingsStore from "./settings/SettingsStore";
  * Returns true if this event arriving in a room should affect the room's
  * count of unread messages
  *
+ * @param client The Matrix Client instance of the logged-in user
  * @param {Object} ev The event
  * @returns {boolean} True if the given event should affect the unread message count
  */
-export function eventTriggersUnreadCount(ev: MatrixEvent): boolean {
-    if (ev.getSender() === MatrixClientPeg.get().credentials.userId) {
+export function eventTriggersUnreadCount(client: MatrixClient, ev: MatrixEvent): boolean {
+    if (ev.getSender() === client.getSafeUserId()) {
         return false;
     }
 
@@ -83,7 +84,7 @@ export function doesRoomOrThreadHaveUnreadMessages(roomOrThread: Room | Thread):
         return false;
     }
 
-    const myUserId = MatrixClientPeg.get().getUserId()!;
+    const myUserId = roomOrThread.client.getSafeUserId();
 
     // as we don't send RRs for our own messages, make sure we special case that
     // if *we* sent the last message into the room, we consider it not unread!
@@ -107,7 +108,7 @@ export function doesRoomOrThreadHaveUnreadMessages(roomOrThread: Room | Thread):
             // that counts and we can stop looking because the user's read
             // this and everything before.
             return false;
-        } else if (isImportantEvent(ev)) {
+        } else if (isImportantEvent(roomOrThread.client, ev)) {
             // We've found a message that counts before we hit
             // the user's read receipt, so this room is definitely unread.
             return true;
@@ -129,8 +130,8 @@ export function doesRoomOrThreadHaveUnreadMessages(roomOrThread: Room | Thread):
  * Given this event does not have a receipt, is it important enough to make
  * this room unread?
  */
-function isImportantEvent(event: MatrixEvent): boolean {
-    return !shouldHideEvent(event) && eventTriggersUnreadCount(event);
+function isImportantEvent(client: MatrixClient, event: MatrixEvent): boolean {
+    return !shouldHideEvent(event) && eventTriggersUnreadCount(client, event);
 }
 
 /**

diff --git a/src/stores/room-list/algorithms/tag-sorting/RecentAlgorithm.ts b/src/stores/room-list/algorithms/tag-sorting/RecentAlgorithm.ts
@@ -95,7 +95,10 @@ const getLastTs = (r: Room, userId: string): number => {
             const ev = r.timeline[i];
             if (!ev.getTs()) continue; // skip events that don't have timestamps (tests only?)
 
-            if ((ev.getSender() === userId && shouldCauseReorder(ev)) || Unread.eventTriggersUnreadCount(ev)) {
+            if (
+                (ev.getSender() === userId && shouldCauseReorder(ev)) ||
+                Unread.eventTriggersUnreadCount(r.client, ev)
+            ) {
                 return ev.getTs();
             }
         }

diff --git a/test/Unread-test.ts b/test/Unread-test.ts
@@ -67,32 +67,32 @@ describe("Unread", () => {
         });
 
         it("returns false when the event was sent by the current user", () => {
-            expect(eventTriggersUnreadCount(ourMessage)).toBe(false);
+            expect(eventTriggersUnreadCount(client, ourMessage)).toBe(false);
             // returned early before checking renderer
             expect(haveRendererForEvent).not.toHaveBeenCalled();
         });
 
         it("returns false for a redacted event", () => {
-            expect(eventTriggersUnreadCount(redactedEvent)).toBe(false);
+            expect(eventTriggersUnreadCount(client, redactedEvent)).toBe(false);
             // returned early before checking renderer
             expect(haveRendererForEvent).not.toHaveBeenCalled();
         });
 
         it("returns false for an event without a renderer", () => {
             mocked(haveRendererForEvent).mockReturnValue(false);
-            expect(eventTriggersUnreadCount(alicesMessage)).toBe(false);
+            expect(eventTriggersUnreadCount(client, alicesMessage)).toBe(false);
             expect(haveRendererForEvent).toHaveBeenCalledWith(alicesMessage, false);
         });
 
         it("returns true for an event with a renderer", () => {
             mocked(haveRendererForEvent).mockReturnValue(true);
-            expect(eventTriggersUnreadCount(alicesMessage)).toBe(true);
+            expect(eventTriggersUnreadCount(client, alicesMessage)).toBe(true);
             expect(haveRendererForEvent).toHaveBeenCalledWith(alicesMessage, false);
         });
 
         it("returns false for beacon locations", () => {
             const beaconLocationEvent = makeBeaconEvent(aliceId);
-            expect(eventTriggersUnreadCount(beaconLocationEvent)).toBe(false);
+            expect(eventTriggersUnreadCount(client, beaconLocationEvent)).toBe(false);
             expect(haveRendererForEvent).not.toHaveBeenCalled();
         });
 
@@ -112,7 +112,7 @@ describe("Unread", () => {
                     type: eventType,
                     sender: aliceId,
                 });
-                expect(eventTriggersUnreadCount(event)).toBe(false);
+                expect(eventTriggersUnreadCount(client, event)).toBe(false);
                 expect(haveRendererForEvent).not.toHaveBeenCalled();
             },
         );