Add room.getLastLiveEvent and remove room.lastThread

Author: weeman1337

spec/unit/room.spec.ts

@@ -54,6 +54,7 @@ import { Crypto } from "../../src/crypto";
 import { mkThread } from "../test-utils/thread";
 import { getMockClientWithEventEmitter, mockClientMethodsUser } from "../test-utils/client";
 import { logger } from "../../src/logger";
+import { IMessageOpts } from "../test-utils/test-utils";
 
 describe("Room", function () {
     const roomId = "!foo:bar";
@@ -63,9 +64,10 @@ describe("Room", function () {
     const userD = "@dorothy:bar";
     let room: Room;
 
-    const mkMessage = () =>
+    const mkMessage = (opts?: Partial<IMessageOpts>) =>
         utils.mkMessage(
             {
+                ...opts,
                 event: true,
                 user: userA,
                 room: roomId,
@@ -113,9 +115,10 @@ describe("Room", function () {
             room.client,
         );
 
-    const mkThreadResponse = (root: MatrixEvent) =>
+    const mkThreadResponse = (root: MatrixEvent, opts?: Partial<IMessageOpts>) =>
         utils.mkEvent(
             {
+                ...opts,
                 event: true,
                 type: EventType.RoomMessage,
                 user: userA,
@@ -165,6 +168,32 @@ describe("Room", function () {
             room.client,
         );
 
+    const addRoomMainAndThreadMessages = (
+        room: Room,
+        tsMain?: number,
+        tsThread?: number,
+    ): { mainEvent?: MatrixEvent; threadEvent?: MatrixEvent } => {
+        const result: { mainEvent?: MatrixEvent; threadEvent?: MatrixEvent } = {};
+
+        if (tsMain) {
+            result.mainEvent = mkMessage({ ts: tsMain });
+            room.addLiveEvents([result.mainEvent]);
+        }
+
+        if (tsThread) {
+            const { rootEvent, thread } = mkThread({
+                room,
+                client: new TestClient().client,
+                authorId: "@bob:example.org",
+                participantUserIds: ["@bob:example.org"],
+            });
+            result.threadEvent = mkThreadResponse(rootEvent, { ts: tsThread });
+            thread.liveTimeline.addEvent(result.threadEvent, true);
+        }
+
+        return result;
+    };
+
     beforeEach(function () {
         room = new Room(roomId, new TestClient(userA, "device").client, userA);
         // mock RoomStates
@@ -3475,4 +3504,56 @@ describe("Room", function () {
             expect(room.findPredecessor()).toBeNull();
         });
     });
+
+    describe("getLastLiveEvent", () => {
+        let lastEventInMainTimeline: MatrixEvent;
+        let lastEventInThread: MatrixEvent;
+
+        it("when there are no events, it should return undefined", () => {
+            expect(room.getLastLiveEvent()).toBeUndefined();
+        });
+
+        describe("when there is only an event in the main timeline and there are no threads", () => {
+            beforeEach(() => {
+                lastEventInMainTimeline = addRoomMainAndThreadMessages(room, 23).mainEvent!;
+                room.addLiveEvents([lastEventInMainTimeline]);
+            });
+
+            it("should return the last event from the main timeline", () => {
+                expect(room.getLastLiveEvent()).toBe(lastEventInMainTimeline);
+            });
+        });
+
+        describe("when there is no event in the room live timeline, but in a thread", () => {
+            beforeEach(() => {
+                lastEventInThread = addRoomMainAndThreadMessages(room, undefined, 42).threadEvent!;
+            });
+
+            it("should return the last event from the thread", () => {
+                expect(room.getLastLiveEvent()).toBe(lastEventInThread);
+            });
+        });
+
+        describe("when there are events in both, the main timeline and threads", () => {
+            describe("and the last event is in a thread", () => {
+                beforeEach(() => {
+                    lastEventInThread = addRoomMainAndThreadMessages(room, 23, 42).threadEvent!;
+                });
+
+                it("should return the last event from the thread", () => {
+                    expect(room.getLastLiveEvent()).toBe(lastEventInThread);
+                });
+            });
+
+            describe("and the last event is in the main timeline", () => {
+                beforeEach(() => {
+                    lastEventInMainTimeline = addRoomMainAndThreadMessages(room, 42, 23).mainEvent!;
+                });
+
+                it("should return the last event from the main timeline", () => {
+                    expect(room.getLastLiveEvent()).toBe(lastEventInMainTimeline);
+                });
+            });
+        });
+    });
 });

src/models/room.ts

@@ -396,7 +396,6 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      * This is not a comprehensive list of the threads that exist in this room
      */
     private threads = new Map<string, Thread>();
-    public lastThread?: Thread;
 
     /**
      * A mapping of eventId to all visibility changes to apply
@@ -785,6 +784,32 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         }
     }
 
+    /**
+     * Returns the last live event of this room.
+     * "last" means latest timestamp.
+     * "live of this room" means from all live timelines: the room and the threads.
+     *
+     * @returns MatrixEvent if there is a last event; else undefined.
+     */
+    public getLastLiveEvent(): MatrixEvent | undefined {
+        const roomEvents = this.getLiveTimeline().getEvents();
+        const lastRoomEvent = roomEvents[roomEvents.length - 1] as MatrixEvent | undefined;
+
+        return this.getThreads().reduce<MatrixEvent | undefined>(
+            (lastEventSoFar: MatrixEvent | undefined, thread: Thread) => {
+                const lastThreadEvent = thread.events[thread.events.length - 1];
+
+                if (!lastEventSoFar || (lastThreadEvent?.getTs() ?? 0) > (lastEventSoFar?.getTs() ?? 0)) {
+                    // no last-event-so-far or last thread event is newer than the last-event-so-far
+                    return lastThreadEvent;
+                }
+
+                return lastEventSoFar;
+            },
+            lastRoomEvent,
+        );
+    }
+
     /**
      * @returns the membership type (join | leave | invite) for the logged in user
      */
@@ -2212,14 +2237,6 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
             RoomEvent.Timeline,
             RoomEvent.TimelineReset,
         ]);
-        const isNewer =
-            this.lastThread?.rootEvent &&
-            rootEvent?.localTimestamp &&
-            this.lastThread.rootEvent?.localTimestamp < rootEvent?.localTimestamp;
-
-        if (!this.lastThread || isNewer) {
-            this.lastThread = thread;
-        }
 
         if (this.threadsReady) {
             this.updateThreadRootEvents(thread, toStartOfTimeline, false);