Avoid unnecessary work when processing threads

spec/unit/room.spec.ts

@@ -2559,7 +2559,7 @@
             let prom = emitPromise(room, ThreadEvent.New);
             await room.addLiveEvents([randomMessage, threadRoot, threadResponse]);
             const thread: Thread = await prom;
-            await emitPromise(room, ThreadEvent.Update);
+            await Promise.all([emitPromise(room, RoomEvent.TimelineReset), emitPromise(room, ThreadEvent.Update)]);
 
             expect(thread.initialEventsFetched).toBeTruthy();
             expect(thread.replyToEvent!.event).toEqual(threadResponse.event);
@@ -2586,7 +2586,7 @@
             prom = emitPromise(room, ThreadEvent.Update);
             await room.addLiveEvents([threadResponseEdit]);
             await prom;
             expect(thread.replyToEvent!.getContent().body).toBe(threadResponseEdit.getContent()["m.new_content"].body);
         });
 
         it("Redactions to thread responses decrement the length", async () => {
@@ -2619,7 +2619,7 @@
             const thread = await prom;
             await emitPromise(room, ThreadEvent.Update);
 
             expect(thread).toHaveLength(2);
             expect(thread.replyToEvent.getId()).toBe(threadResponse2.getId());
 
             thread.timelineSet.addEventToTimeline(threadResponse1, thread.liveTimeline, {
@@ -2687,7 +2687,7 @@
             const thread = await prom;
             await emitPromise(room, ThreadEvent.Update);
 
             expect(thread).toHaveLength(2);
             expect(thread.replyToEvent.getId()).toBe(threadResponse2.getId());
 
             const threadResponse2ReactionRedaction = mkRedaction(threadResponse2Reaction);
@@ -2727,7 +2727,7 @@
             const thread = await prom;
             await emitPromise(room, ThreadEvent.Update);
 
             expect(thread).toHaveLength(2);
             expect(thread.replyToEvent.getId()).toBe(threadResponse2.getId());
 
             prom = emitPromise(room, ThreadEvent.Update);
@@ -2791,7 +2791,7 @@
 
             expect(thread.initialEventsFetched).toBeTruthy();
             await room.addLiveEvents([threadResponse2]);
             expect(thread).toHaveLength(2);
             expect(thread.replyToEvent!.getId()).toBe(threadResponse2.getId());
 
             room.client.fetchRoomEvent = (eventId: string) =>
@@ -2969,7 +2969,7 @@
             expect(rootRelations![0][1].has(rootReaction)).toBeTruthy();
 
             const responseRelations = thread.timelineSet.relations
                 .getChildEventsForEvent(threadResponse.getId()!, RelationType.Annotation, EventType.Reaction)!
                 .getSortedAnnotationsByKey();
             expect(responseRelations).toHaveLength(1);
             expect(responseRelations![0][0]).toEqual(threadReaction.getRelation()!.key);

src/models/room.ts

@@ -2256,6 +2256,13 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
             client: this.client,
             pendingEventOrdering: this.opts.pendingEventOrdering,
             receipts: this.cachedThreadReadReceipts.get(threadId) ?? [],
+
+            // This is necessary to be able to jump to events in threads:
+            // If we jump to an event in a thread where neither the event, nor
+            // the root, nor any thread event are loaded yet, we'll load the
+            // event as well as the thread root, create the thread, and pass
+            // the event through this.
+            events,
         });
 
         // All read receipts should now come down from sync, we do not need to keep
@@ -2267,12 +2274,6 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         // eventtimeline sometimes looks up thread information via the room.
         this.threads.set(thread.id, thread);
 
-        // This is necessary to be able to jump to events in threads:
-        // If we jump to an event in a thread where neither the event, nor the root,
-        // nor any thread event are loaded yet, we'll load the event as well as the thread root, create the thread,
-        // and pass the event through this.
-        thread.addEvents(events, false);
-
         this.reEmitter.reEmit(thread, [
             ThreadEvent.Delete,
             ThreadEvent.Update,

src/models/thread.ts

@@ -58,6 +58,7 @@ interface IThreadOpts {
     client: MatrixClient;
     pendingEventOrdering?: PendingEventOrdering;
     receipts?: CachedReceiptStructure[];
+    events?: MatrixEvent[];
 }
 
 export enum FeatureSupport {
@@ -139,6 +140,8 @@ export class Thread extends ReadReceipt<ThreadEmittedEvents, ThreadEventHandlerM
 
         this.processReceipts(opts.receipts);
 
+        this.replayEvents = opts.events ?? [];
+
         // even if this thread is thought to be originating from this client, we initialise it as we may be in a
         // gappy sync and a thread around this event may already exist.
         this.updateThreadMetadata();
@@ -310,6 +313,11 @@ export class Thread extends ReadReceipt<ThreadEmittedEvents, ThreadEventHandlerM
         const lastReply = this.lastReply();
         const isNewestReply = !lastReply || event.localTimestamp >= lastReply!.localTimestamp;
 
+        if (isNewestReply) {
+            const mapper = this.client.getEventMapper();
+            this.lastEvent = mapper(event.getEffectiveEvent());
+        }
+
         // Add all incoming events to the thread's timeline set when there's  no server support
         if (!Thread.hasServerSideSupport) {
             // all the relevant membership info to hydrate events with a sender
@@ -321,6 +329,7 @@ export class Thread extends ReadReceipt<ThreadEmittedEvents, ThreadEventHandlerM
             this.client.decryptEventIfNeeded(event, {});
         } else if (!toStartOfTimeline && this.initialEventsFetched && isNewestReply) {
             this.addEventToTimeline(event, false);
+            // TODO: This is another async call without awaiting
             this.fetchEditsWhereNeeded(event);
         } else if (event.isRelation(RelationType.Annotation) || event.isRelation(RelationType.Replace)) {
             if (!this.initialEventsFetched) {