Clean up raw commit

Author: MadLittleMods

Diff for: src/client.ts

@@ -5135,7 +5135,6 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @return {module:http-api.MatrixError} Rejects: with an error response.
      */
     public scrollback(room: Room, limit = 30, callback?: Callback): Promise<Room> {
-        console.log('client: scrollback');
         if (utils.isFunction(limit)) {
             callback = limit as any as Callback; // legacy
             limit = undefined;
@@ -5151,13 +5150,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         }
 
         if (room.oldState.paginationToken === null) {
-            console.log('client: scrollabck already at the start.', room.oldState);
             return Promise.resolve(room); // already at the start.
         }
         // attempt to grab more events from the store first
         const numAdded = this.store.scrollback(room, limit).length;
         if (numAdded === limit) {
-            console.log(`client: scrollback store contained everything we needed numAdded=${numAdded} limit=${limit}`);
             // store contained everything we needed.
             return Promise.resolve(room);
         }
@@ -5184,7 +5181,6 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
                 const [timelineEvents, threadedEvents] = room.partitionThreadedEvents(matrixEvents);
 
                 this.processBeaconEvents(room, matrixEvents);
-                console.log('client: scrollback addEventsToTimeline', timelineEvents.length, room.getLiveTimeline());
                 room.addEventsToTimeline(timelineEvents, true, room.getLiveTimeline());
                 await this.processThreadEvents(room, threadedEvents, true);
 
@@ -5311,9 +5307,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         }
 
         // Here we handle non-thread timelines only, but still process any thread events to populate thread summaries.
-        console.log('getEventTimeline: timeline count1', timelineSet.getTimelines().length);
         let timeline = timelineSet.getTimelineForEvent(events[0].getId());
-        console.log('getEventTimeline: timeline count2', timelineSet.getTimelines().length);
         if (timeline) {
             timeline.getState(EventTimeline.BACKWARDS).setUnknownStateEvents(res.state.map(mapper));
         } else {
@@ -5322,11 +5316,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             timeline.getState(EventTimeline.FORWARDS).paginationToken = res.end;
         }
 
-        console.log('getEventTimeline: timeline before', timelineSet.getTimelines().length, timeline.getEvents().length);
-
         const [timelineEvents, threadedEvents] = timelineSet.room.partitionThreadedEvents(events);
         timelineSet.addEventsToTimeline(timelineEvents, true, timeline, res.start);
-        console.log('getEventTimeline: timeline after', timelineSet.getTimelines().length, timeline.getEvents().length);
         // The target event is not in a thread but process the contextual events, so we can show any threads around it.
         await this.processThreadEvents(timelineSet.room, threadedEvents, true);
         this.processBeaconEvents(timelineSet.room, events);

Diff for: src/models/event-timeline-set.ts

@@ -217,7 +217,7 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
     }
 
     /**
-     * Get the live timeline for this room.
+     * Set the live timeline for this room.
      *
      * @return {module:models/event-timeline~EventTimeline} live timeline
      */

Diff for: src/models/room.ts

@@ -929,12 +929,25 @@ export class Room extends TypedEventEmitter<EmittedEvents, RoomEventHandlerMap>
         });
     }
 
-    // TODO
+    /**
+     * Empty out the current live timeline and re-request it. This is used when
+     * historical messages are imported into the room via MSC2716 `/batch_send
+     * because the client may already have that section of the timeline loaded.
+     * We need to force the client to throw away their current timeline so that
+     * when they back paginate over the area again with the historical messages
+     * in between, it grabs the newly imported messages. We can listen for
+     * `EventType.Marker`, in order to tell when historical messages are ready
+     * to be discovered in the room and the timeline needs a refresh. The SDK
+     * emits a `RoomEvent.historyImportedWithinTimeline` event when we detect a
+     * valid marker and can check the needs refresh status via
+     * `room.getTimelineNeedsRefresh()`.
+     */
     public async refreshLiveTimeline(): Promise<void> {
         const liveTimelineBefore = this.getLiveTimeline();
         const forwardPaginationToken = liveTimelineBefore.getPaginationToken(EventTimeline.FORWARDS);
         const eventsBefore = liveTimelineBefore.getEvents();
         const mostRecentEventInTimeline = eventsBefore[eventsBefore.length - 1];
+        logger.log(`[refreshLiveTimeline] for room ${this.roomId} at mostRecentEventInTimeline=${mostRecentEventInTimeline.getId()} forwardPaginationToken+${forwardPaginationToken}`)
 
         // Empty out all of `this.timelineSets` but still keeps the same
         // `timelineSet` references around so the React code updates properly
@@ -944,81 +957,37 @@ export class Room extends TypedEventEmitter<EmittedEvents, RoomEventHandlerMap>
         // call `/context` and create a new timeline instead of returning the
         // same one.
         this.resetLiveTimeline(null, null);
-        //this.resetLiveTimeline(forwardPaginationToken, forwardPaginationToken);
 
         // Get a reference to the emptied out `timelineSet`
         //
-        // TODO: Do we want to use `this.getLiveTimeline().getTimelineSet()` instead?
-        // I think it's the same thing but what's more right?
+        // TODO: Do we want to use `this.getLiveTimeline().getTimelineSet()`
+        // instead? I think it's the same thing but what's more right?
         const timelineSet = this.getUnfilteredTimelineSet();
-        
-        console.log(`refreshLiveTimeline: after resetLiveTimeline timelineSets=${this.getTimelineSets().length} getUnfilteredTimelineSet=`, timelineSet.getTimelines().length, timelineSet.getTimelines().map((timeline) => {
-            return timeline.getEvents().length;
-        }));
 
         // Use `client.getEventTimeline(...)` to construct a new timeline from a
         // `/context` response state and events for the most recent event before
-        // we reset everything. The `timelineSet` needs to be empty in order for
-        // this function to call `/context`
+        // we reset everything. The `timelineSet` we pass in needs to be empty
+        // in order for this function to call `/context` and generate a new
+        // timeline.
         const newTimeline = await this.client.getEventTimeline(timelineSet, mostRecentEventInTimeline.getId());
-        console.log('refreshLiveTimeline: after getEventTimeline', timelineSet.getTimelines().length, timelineSet.getTimelines().map((timeline) => {
-            return timeline.getEvents().length;
-        }));
         // Set the pagination token back to the live sync token instead of using
-        // the /context historical token so that it matches the next response from `/sync`
-        // and we can properly continue the timeline.
+        // the `/context` historical token so that it matches the next response
+        // from `/sync` and we can properly continue the timeline.
         newTimeline.setPaginationToken(forwardPaginationToken, EventTimeline.FORWARDS);
 
+        // Set our new fresh timeline as the live timeline to continue syncing
+        // forwards and back paginating from.
         timelineSet.setLiveTimeline(newTimeline);
-        //timelineSet.getLiveTimeline().setNeighbouringTimeline(newTimeline, EventTimeline.FORWARDS);
-        // Fixup `this.oldstate` so that `scrollback` has the pagination tokens available 
+        // Fixup `this.oldstate` so that `scrollback` has the pagination tokens
+        // available 
         this.fixUpLegacyTimelineFields();
 
-        // TODO: Set timelineNeedsRefresh = false
-
-        // const liveTimeline = this.getLiveTimeline();
-        // liveTimeline.setPaginationToken(forwardPaginationToken, EventTimeline.BACKWARDS);
-        // liveTimeline.setPaginationToken(forwardPaginationToken, EventTimeline.FORWARDS);
-        // await new Promise((resolve) => {
-        //     setTimeout(async () => {
-        //         await this.client.scrollback(this, 30);
-        //         resolve(null);
-        //     }, 2000);
-        // });
-        //await this.client.scrollback(this, 30);
-        this.emit(RoomEvent.TimelineRefresh, this, timelineSet);
-
-        // const timelineSet = new EventTimelineSet(this, this.opts);
-
-        // const liveTimeline = this.getLiveTimeline();
-        // const events = liveTimeline.getEvents();
-        // const mostRecentEventInTimeline = events[events.length - 1];
-
-        // // This will create a timeline with the given event and add it to the timelineSet
-        // const newTimeline = await this.client.getEventTimeline(timelineSet, mostRecentEventInTimeline.getId());
+        // The timeline has now been refreshed ✅
+        this.setTimelineNeedsRefresh(false);
 
-        // console.log('refreshTimeline: timelineSet',
-        //     timelineSet,
-        //     timelineSet.getTimelines().map((timeline) => {
-        //         return timeline.getEvents().length;
-        //     }),
-        // );
-
-        // // Since timelineSets is a readonly property, clear it out this way
-        // this.timelineSets.length = 0;
-        // // Keep track of the new timelineSet
-        // this.timelineSets.push(timelineSet);
-        // // Set our new timeline as the liveTimeline
-        // timelineSet.setLiveTimeline(newTimeline);
-        // // Fixup `this.oldstate` so that `scrollback` has the pagination tokens available 
-        // this.fixUpLegacyTimelineFields();
-        
-
-        // //this.emit(RoomEvent.Timeline, event, this.room, Boolean(toStartOfTimeline), false, data);
-        // // setTimeout(() => {
-        // //     this.emit(RoomEvent.TimelineReset, this, timelineSet, true);
-        // // }, 1000);
-        // this.emit(RoomEvent.TimelineRefresh, this, timelineSet);
+        // Emit an event which clients can react to and re-load the timeline
+        // from the SDK
+        this.emit(RoomEvent.TimelineRefresh, this, timelineSet);
     }
 
     /**
@@ -1048,11 +1017,6 @@ export class Room extends TypedEventEmitter<EmittedEvents, RoomEventHandlerMap>
      * @private
      */
     private fixUpLegacyTimelineFields(): void {
-        console.log(
-            'fixUpLegacyTimelineFields',
-            this.getLiveTimeline().getState(EventTimeline.BACKWARDS),
-            this.getLiveTimeline().getState(EventTimeline.FORWARDS)
-        );
         // maintain this.timeline as a reference to the live timeline,
         // and this.oldState and this.currentState as references to the
         // state at the start and end of that timeline. These are more