use timeline set instead of an array of events

src/models/room.ts

@@ -146,7 +146,7 @@ export class Room extends EventEmitter {
     public oldState: RoomState;
     public currentState: RoomState;
 
-    private threads = new Set<Thread>();
+    public threads = new Set<Thread>();
 
     /**
      * Construct a new Room.
@@ -1052,12 +1052,6 @@ export class Room extends EventEmitter {
         );
     }
 
-    public findThreadByTailEvent(eventId: string): Thread {
-        return Array.from(this.threads.values()).find(thread => {
-            return thread.tail.has(eventId);
-        });
-    }
-
     public addThread(thread: Thread): Set<Thread> {
         this.threads.add(thread);
         if (!thread.ready) {
@@ -1068,6 +1062,12 @@ export class Room extends EventEmitter {
         return this.threads;
     }
 
+    public getThread(eventId: string): Thread {
+        return this.getThreads().find(thread => {
+            return thread.id === eventId;
+        });
+    }
+
     public getThreads(): Thread[] {
         return Array.from(this.threads.values());
     }

src/models/thread.ts

@@ -17,18 +17,27 @@ limitations under the License.
 import { EventEmitter } from "events";
 import { MatrixClient } from "../matrix";
 import { MatrixEvent } from "./event";
+import { EventTimelineSet } from './event-timeline-set';
+import { Room } from './room';
 
 export class Thread extends EventEmitter {
     private root: string;
     public tail = new Set<string>();
     private events = new Map<string, MatrixEvent>();
+    private _timelineSet: EventTimelineSet;
+
     private decrypted = false;
 
     constructor(
         events: MatrixEvent[] = [],
+        public readonly room: Room,
         public readonly client: MatrixClient,
     ) {
         super();
+        this._timelineSet = new EventTimelineSet(room, {
+            unstableClientRelationAggregation: true,
+            timelineSupport: true,
+        });
         events.forEach(event => this.addEvent(event));
     }
 
@@ -38,7 +47,7 @@ export class Thread extends EventEmitter {
      * @param event The event to add
      */
     public addEvent(event: MatrixEvent): void {
-        if (this.events.has(event.getId())) {
+        if (this.events.has(event.getId()) || event.status !== null) {
             return;
         }
 
@@ -51,8 +60,14 @@ export class Thread extends EventEmitter {
             this.root = event.getId();
         }
 
-        this.events.set(event.getId(), event);
         event.setThread(this);
+        this.events.set(event.getId(), event);
+        this._timelineSet.addEventToTimeline(
+            event,
+            this._timelineSet.getLiveTimeline(),
+            false,
+            false,
+        );
 
         if (this.ready) {
             this.client.decryptEventIfNeeded(event, {});
@@ -99,14 +114,6 @@ export class Thread extends EventEmitter {
         return this.rootEvent.replyEventId === undefined && this.decrypted;
     }
 
-    /**
-     * A sorted list of events to display
-     */
-    public get eventTimeline(): MatrixEvent[] {
-        return Array.from(this.events.values())
-            .sort((a, b) => a.getTs() - b.getTs());
-    }
-
     /**
      * The thread ID, which is the same as the root event ID
      */
@@ -122,7 +129,7 @@ export class Thread extends EventEmitter {
      * The number of messages in the thread
      */
     public get length(): number {
-        return this.eventTimeline.length;
+        return this._timelineSet.getLiveTimeline().getEvents().length;
     }
 
     /**
@@ -135,4 +142,13 @@ export class Thread extends EventEmitter {
         });
         return participants;
     }
+
+    public get timelineSet(): EventTimelineSet {
+        return this._timelineSet;
+    }
+
+    public get replyToEvent(): MatrixEvent {
+        const events = this._timelineSet.getLiveTimeline().getEvents();
+        return events[events.length -1];
+    }
 }

src/sync.ts

@@ -1700,11 +1700,11 @@ export class SyncApi {
 
     private processThreadEvents(room: Room, threadedEvents: MatrixEvent[]): void {
         threadedEvents.forEach(event => {
-            let thread = room.findThreadByTailEvent(event.replyEventId);
+            let thread = room.findEventById(event.replyEventId).getThread();
             if (thread) {
                 thread.addEvent(event);
             } else {
-                thread = new Thread([event], this.client);
+                thread = new Thread([event], room, this.client);
                 room.addThread(thread);
             }
         });