Fix `getLatestTimeline` not working when the latest event in the room is a threaded message #2521

MadLittleMods · 2022-07-13T00:08:29Z

Fix getLatestTimeline not working when the latest event in the room is a threaded message

Follow-up to Timeline needs to refresh when we see a MSC2716 marker event #2299
matrix-react-sdk PR: Ask to refresh timeline when historical messages are imported (MSC2716) matrix-react-sdk#8354

See matrix-org/matrix-react-sdk#8354 (comment)

We also have to keep in mind that we don't want to mix messages in the wrong timelines (main vs threaded timeline):

Dev notes

TimelineSet.addEventsToTimeline -> TimelineSet.addEventToTimeline -> Timeline.addEvent
TimelineSet.addEventToTimeline -> Timeline.addEvent
TimelineSet.addLiveEvent -> TimelineSet.addEventToTimeline -> Timeline.addEvent

Checklist

Tests written for new code (and old code if feasible)
Linter and other CI checks pass
~~Sign-off given on the changes (see CONTRIBUTING.md)~~

Here's what your changelog entry will look like:

🐛 Bug Fixes

Fix getLatestTimeline not working when the latest event in the room is a threaded message (#2521). Contributed by @MadLittleMods.

…s a threaded message See matrix-org/matrix-react-sdk#8354 (comment) Also have to keep in mind that we don't want to mix messages in the wrong timelines (main vs threaded timeline) - #2444 - #2454

MadLittleMods · 2022-07-13T01:16:25Z

spec/unit/event-timeline-set.spec.ts

+        it("should not add a threaded reply to the main room timeline", () => {
+            const liveTimeline = eventTimelineSet.getLiveTimeline();
+            expect(liveTimeline.getEvents().length).toStrictEqual(0);
+
+            const threadedReplyEvent = mkThreadResponse(messageEvent);
+
+            eventTimelineSet.addEventToTimeline(threadedReplyEvent, liveTimeline, {
+                toStartOfTimeline: true,
+            });
+            expect(liveTimeline.getEvents().length).toStrictEqual(0);
+        });
+
+        it("should not add a normal message to the timelineSet representing a thread", () => {
+            const eventTimelineSetForThread = new EventTimelineSet(room, {}, client, thread);
+            const liveTimeline = eventTimelineSetForThread.getLiveTimeline();
+            expect(liveTimeline.getEvents().length).toStrictEqual(0);
+
+            eventTimelineSetForThread.addEventToTimeline(messageEvent, liveTimeline, {
+                toStartOfTimeline: true,
+            });
+            expect(liveTimeline.getEvents().length).toStrictEqual(0);
+        });


This tests the two main mixing scenarios. We could add tests for the other mixing scenarios but we're using canContain which already has it's own set of tests,

matrix-js-sdk/spec/unit/event-timeline-set.spec.ts

Lines 227 to 293 in 5112340

describe("canContain", () => {

const mkThreadResponse = (root: MatrixEvent) => utils.mkEvent({

event: true,

type: EventType.RoomMessage,

user: userA,

room: roomId,

content: {

"body": "Thread response :: " + Math.random(),

"m.relates_to": {

"event_id": root.getId(),

"m.in_reply_to": {

"event_id": root.getId(),

},

"rel_type": "m.thread",

},

},

}, room.client);

let thread: Thread;

beforeEach(() => {

(client.supportsExperimentalThreads as jest.Mock).mockReturnValue(true);

thread = new Thread("!thread_id:server", messageEvent, { room, client });

});

it("should throw if timeline set has no room", () => {

const eventTimelineSet = new EventTimelineSet(undefined, {}, client);

expect(() => eventTimelineSet.canContain(messageEvent)).toThrowError();

});

it("should return false if timeline set is for thread but event is not threaded", () => {

const eventTimelineSet = new EventTimelineSet(room, {}, client, thread);

expect(eventTimelineSet.canContain(replyEvent)).toBeFalsy();

});

it("should return false if timeline set it for thread but event it for a different thread", () => {

const eventTimelineSet = new EventTimelineSet(room, {}, client, thread);

const event = mkThreadResponse(replyEvent);

expect(eventTimelineSet.canContain(event)).toBeFalsy();

});

it("should return false if timeline set is not for a thread but event is a thread response", () => {

const eventTimelineSet = new EventTimelineSet(room, {}, client);

const event = mkThreadResponse(replyEvent);

expect(eventTimelineSet.canContain(event)).toBeFalsy();

});

it("should return true if the timeline set is not for a thread and the event is a thread root", () => {

const eventTimelineSet = new EventTimelineSet(room, {}, client);

expect(eventTimelineSet.canContain(messageEvent)).toBeTruthy();

});

it("should return true if the timeline set is for a thread and the event is its thread root", () => {

const thread = new Thread(messageEvent.getId(), messageEvent, { room, client });

const eventTimelineSet = new EventTimelineSet(room, {}, client, thread);

messageEvent.setThread(thread);

expect(eventTimelineSet.canContain(messageEvent)).toBeTruthy();

});

it("should return true if the timeline set is for a thread and the event is a response to it", () => {

const thread = new Thread(messageEvent.getId(), messageEvent, { room, client });

const eventTimelineSet = new EventTimelineSet(room, {}, client, thread);

messageEvent.setThread(thread);

const event = mkThreadResponse(messageEvent);

expect(eventTimelineSet.canContain(event)).toBeTruthy();

});

});

MadLittleMods · 2022-07-13T01:20:51Z

src/client.ts

-            if (!timelineSet.canContain(event)) {
-                return undefined;
-            }


Instead of returning undefined, we now just ignore the event and don't add it to the given timelineSet.

Did returning undefined have some other special meaning? The getEventTimeline usage didn't stand out to me.

Did returning undefined have some other special meaning? The getEventTimeline usage didn't stand out to me.

I don't think it has any special meaning, see #2521 (comment)

MadLittleMods · 2022-07-13T01:23:02Z

src/client.ts

-            if (!timelineSet.canContain(event)) {
-                return undefined;
-            }


In order to make sure we're not regressing #2444 and #2454 for sure, do we have a specific testing strategy in the Element app to reproduce previously (main timeline events in a thread for example)? How do we know that those previous PR's fixed the problem besides reasoning about it?

@t3chguy Any hints here?

MadLittleMods · 2022-07-13T02:16:11Z

src/client.ts

@@ -5338,9 +5334,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
        // There is no guarantee that the event ended up in "timeline" (we might have switched to a neighbouring
        // timeline) - so check the room's index again. On the other hand, there's no guarantee the event ended up
        // anywhere, if it was later redacted, so we just return the timeline we first thought of.
-        return timelineSet.getTimelineForEvent(eventId)
-            ?? timelineSet.room.findThreadForEvent(event)?.liveTimeline // for Threads degraded support


?? timelineSet.room.findThreadForEvent(event)?.liveTimeline // for Threads degraded support was added in #2261. Is it necessary? I'm just trying to get the context behind why we have it.

What does Threads degraded support exactly map to?

If supportsExperimentalThreads is disabled all events will be added to the main timeline (eventShouldLiveIn always returns shouldLiveInRoom: true)

Threads degraded support

Server has no APIs to help the client so the client has to build the threads objects without filters & relations support on the server based on /sync and /messages data alone, which is a mode we have to continue to support.

Thanks for the context!

I think it's safe to drop this case given getTimelineForEvent is always used in a fire and forget manner, see #2521 (comment)

t3chguy · 2022-07-13T09:01:32Z

src/client.ts

@@ -5234,15 +5234,15 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     * <p>If the EventTimelineSet object already has the given event in its store, the
     * corresponding timeline will be returned. Otherwise, a /context request is
     * made, and used to construct an EventTimeline.
-     * If the event does not belong to this EventTimelineSet then undefined will be returned.
+     * If the event does not belong to this EventTimelineSet then it will ignored.


The event will be ignored? What does that even mean? This method isn't meant to process the given event, just use it as a pointer. What event timeline will be returned to the caller? The caller would now have need to manually check that the returned timeline is valid for what they asked for, I guess by your other change lower down by attempting to add an event and by asserting that it worked, that seems rather strange

Let's first discuss the previous behavior. Previously, when the event didn't belong to the timelineSet, we would return undefined and create no additional timelines. Returning undefined has no special meaning given that all of the usage is always fire and forget meaning we don't use the timeline returned by client.getEventTimeline() and only use the function to load the event so it's available to the client.

In our usage, there is only a single spot where the caller uses the timeline returned by client.getEventTimeline(). This usage should be replaced by the fire and forget pattern and use room.findEventById(eventId) because it doesn't even use the timeline, it just wants the event that was loaded in as well.

It's probably a misnomer to call it getEventTimeline(): timeline in the first place as it's more accurately used as loadEventInTimeline(): Promise<void> everywhere.

And my new refreshLiveTimeline and getLatestTimeline usage is the only one where it needs an actually timeline.

With the updates, we're only working within the given timelineSet that was passed in (seems reasonable). If client.getEventTimeline() is really meant to just give the timeline for the eventId, then we should just provide the room instead which can look at all of the timelineSets (room.timelineSets).

Previously, we would return undefined in the case where the event doesn't belong in the timelineSet. Now we're returning a timeline in the timelineSet where all of the events returned by /context can go. This means events that we fetched, are actually added and not wasted. And it means that the main room timeline can be populated regardless if the eventId passed in was a threaded reply.

By ignored, I mean if the eventId is a threaded reply, it won't be added to the main room timelineSet that was passed in for example.

Our usage might be to be a fire-and-forget pattern (or wrong, in the case of needing to use findEventById instead), but as a public function and SDK we have to maintain a rationalized contract for the function name: it says it gets an event timeline, so it should do that (returning undefined if needed)

We can adjust our code to instead use a new updateEventTimeline() function or similar, but the existing getEventTimeline function can't realistically have a behavioural change like this.

The return undefined part is part of supportsExperimentalThreads which changed in https://github.com/matrix-org/matrix-js-sdk/pull/2444/files

Can we change the experimental implementation?

We can adjust our code to instead use a new updateEventTimeline() function or similar, but the existing getEventTimeline function can't realistically have a behavioural change like this.

In any case, this can work

I'm still not comfortable with the behavioural change here, sorry. While our usage might be fire-and-forget, we can't guarantee that all usages of the function are fire-and-forget. The documentation and function itself are not experimental in nature as well, preventing us from making arbitrary breaking changes.

Adding a function is more code, but I think it's worthwhile here. It can even call getEventTimeline() and ignore the return value - it looks a bit silly, but it's how we avoid unnecessary major version releases.

Conversation continued at #2852 (comment)

See matrix-org/matrix-js-sdk#2521 (comment)

turt2live · 2022-08-04T20:18:26Z

src/client.ts

@@ -5234,15 +5234,15 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     * <p>If the EventTimelineSet object already has the given event in its store, the
     * corresponding timeline will be returned. Otherwise, a /context request is
     * made, and used to construct an EventTimeline.
-     * If the event does not belong to this EventTimelineSet then undefined will be returned.
+     * If the event does not belong to this EventTimelineSet then it will ignored.


Our usage might be to be a fire-and-forget pattern (or wrong, in the case of needing to use findEventById instead), but as a public function and SDK we have to maintain a rationalized contract for the function name: it says it gets an event timeline, so it should do that (returning undefined if needed)

We can adjust our code to instead use a new updateEventTimeline() function or similar, but the existing getEventTimeline function can't realistically have a behavioural change like this.

…msc2716-marker-events-v2

MadLittleMods · 2022-08-29T21:22:08Z

spec/integ/matrix-client-event-timeline.spec.ts

-            ]);
+            // getEventTimeline -> thread.fetchInitialEvents
+            httpBackend.when("GET", "/rooms/!foo%3Abar/relations/" +
+                encodeURIComponent(THREAD_ROOT.event_id) + "/" +


There are some lints in CI: https://github.com/matrix-org/matrix-js-sdk/runs/8077711103?check_suite_focus=true

But I don't see them locally even after re-installing node_modules to ensure correct versions.

$ yarn lint yarn run v1.22.18 $ yarn lint:types && yarn lint:js $ tsc --noEmit $ eslint --max-warnings 0 src spec ✨ Done in 21.60s.

(on the correct branch, madlittlemods/refresh-timeline-when-we-see-msc2716-marker-events-v2)

This is also the same pattern we use in the existing tests here but don't appear because they're not in the diff so will need to refactor this.

Those are shown if you use tsc --strict - hence being reported by the Typescript Strict Error Checker

Can probably merge develop to resolve all of these unrelated errors now that #2835 fixed them up

turt2live

apologies for the late review on this - it somehow got lost in my queue :(

turt2live · 2022-09-10T03:45:18Z

src/client.ts

@@ -5234,15 +5234,15 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     * <p>If the EventTimelineSet object already has the given event in its store, the
     * corresponding timeline will be returned. Otherwise, a /context request is
     * made, and used to construct an EventTimeline.
-     * If the event does not belong to this EventTimelineSet then undefined will be returned.
+     * If the event does not belong to this EventTimelineSet then it will ignored.


I'm still not comfortable with the behavioural change here, sorry. While our usage might be fire-and-forget, we can't guarantee that all usages of the function are fire-and-forget. The documentation and function itself are not experimental in nature as well, preventing us from making arbitrary breaking changes.

Adding a function is more code, but I think it's worthwhile here. It can even call getEventTimeline() and ignore the return value - it looks a bit silly, but it's how we avoid unnecessary major version releases.

…msc2716-marker-events-v2 Conflicts: spec/integ/matrix-client-event-timeline.spec.ts src/client.ts

Split out from #2521

Split out from #2521 Context: #2521 (comment)

MadLittleMods · 2022-11-04T00:27:05Z

src/timeline-window.ts

        } else {
            const tl = this.timelineSet.getLiveTimeline();
            initFields(tl);
-            return Promise.resolve();
+            return;


Split out to #2849

MadLittleMods · 2022-11-04T00:27:13Z

src/models/event-timeline-set.ts

+        if (timeline.getTimelineSet() !== this) {
+            throw new Error(`EventTimelineSet.addEventToTimeline: Timeline=${timeline.toString()} does not belong " + 
+                "in timelineSet(threadId=${this.thread?.id})`);
+        }
+
+        // Make sure events don't get mixed in timelines they shouldn't be in
+        // (e.g. a threaded message should not be in the main timeline).
+        if (!this.canContain(event)) {
+            logger.warn(`EventTimelineSet.addEventToTimeline: Ignoring event=${event.getId()} that does not belong " + 
+                "in timeline=${timeline.toString()} timelineSet(threadId=${this.thread?.id})`);
+            return;
+        }


Split out to #2848

Add checks to `addEventToTimeline` as extra insurance that we don't mix events in the wrong timelines (main timeline vs thread timeline). Split out from #2521 Previously, we just relied on the callers to make sure they're doing the right thing and since it's easy to get it wrong, we mixed and bugs happened. Call stacks for how events get added to a timeline: - `TimelineSet.addEventsToTimeline` -> `TimelineSet.addEventToTimeline` -> `Timeline.addEvent` - `TimelineSet.addEventToTimeline` -> `Timeline.addEvent` - `TimelineSet.addLiveEvent` -> `TimelineSet.addEventToTimeline` -> `Timeline.addEvent`

A v2 of #2521

MadLittleMods · 2022-11-04T11:24:15Z

Closed as I went a different direction in this v2 PR, #2852

…2856) Add checks to `addEventToTimeline` as extra insurance that we don't mix events in the wrong timelines (main timeline vs thread timeline). Split out from #2521 This PR is a v2 of #2848 since it was reverted in #2853 Previously, we just relied on the callers to make sure they're doing the right thing and since it's easy to get it wrong, we mixed and bugs happened. Call stacks for how events get added to a timeline: - `TimelineSet.addEventsToTimeline` -> `TimelineSet.addEventToTimeline` -> `Timeline.addEvent` - `TimelineSet.addEventToTimeline` -> `Timeline.addEvent` - `TimelineSet.addLiveEvent` -> `TimelineSet.addEventToTimeline` -> `Timeline.addEvent`

MadLittleMods added 3 commits July 12, 2022 19:03

Fix getLatestTimeline not working when the latest even in the room wa…

5f4d10d

…s a threaded message See matrix-org/matrix-react-sdk#8354 (comment) Also have to keep in mind that we don't want to mix messages in the wrong timelines (main vs threaded timeline) - #2444 - #2454

Adjust tests to not include problem events instead of undefined timeline

e8dc590

Add tests for not being able to add mixed events

9882eb6

MadLittleMods commented Jul 13, 2022

View reviewed changes

Correct JSDoc and types for getEventTimeline

fdeb9e0

MadLittleMods commented Jul 13, 2022

View reviewed changes

No longer need check since it should always return a timeline

78f8019

MadLittleMods commented Jul 13, 2022

View reviewed changes

Add getLatestTimeline test for latest event being thread

50b5bb1

MadLittleMods commented Jul 13, 2022

View reviewed changes

MadLittleMods added the T-Defect label Jul 13, 2022

MadLittleMods added 2 commits July 12, 2022 21:23

Add non-optional client to Room instances

a3457e1

Fix lint

cdef5cb

MadLittleMods mentioned this pull request Jul 13, 2022

Ask to refresh timeline when historical messages are imported (MSC2716) matrix-org/matrix-react-sdk#8354

Closed

3 tasks

MadLittleMods changed the title ~~Draft: Fix getLatestTimeline not working when the latest event in the room is a threaded message~~ Fix getLatestTimeline not working when the latest event in the room is a threaded message Jul 13, 2022

MadLittleMods marked this pull request as ready for review July 13, 2022 02:58

MadLittleMods requested a review from a team as a code owner July 13, 2022 02:58

MadLittleMods requested review from t3chguy, kerryarchibald and justjanne July 13, 2022 02:58

t3chguy reviewed Jul 13, 2022

View reviewed changes

MadLittleMods requested a review from t3chguy July 13, 2022 15:28

MadLittleMods added a commit to matrix-org/matrix-react-sdk that referenced this pull request Jul 19, 2022

Use fire-forget pattern

ac998bd

See matrix-org/matrix-js-sdk#2521 (comment)

We expect void so return void

cd41d7e

MadLittleMods requested review from t3chguy and a team and removed request for t3chguy July 21, 2022 20:59

turt2live requested changes Aug 4, 2022

View reviewed changes

Merge branch 'develop' into madlittlemods/refresh-timeline-when-we-see-…

a3ea213

…msc2716-marker-events-v2

MadLittleMods requested a review from turt2live August 29, 2022 18:30

MadLittleMods commented Aug 29, 2022

View reviewed changes

turt2live requested changes Sep 10, 2022

View reviewed changes

MadLittleMods added 2 commits October 13, 2022 22:09

Merge branch 'develop' into madlittlemods/refresh-timeline-when-we-see-…

b97de19

…msc2716-marker-events-v2 Conflicts: spec/integ/matrix-client-event-timeline.spec.ts src/client.ts

Fix some lints

f82ea0c

MadLittleMods added a commit that referenced this pull request Nov 4, 2022

Extra insurance that we don't mix events in the wrong timelines

0f0e8f9

Split out from #2521

MadLittleMods mentioned this pull request Nov 4, 2022

Extra insurance that we don't mix events in the wrong timelines #2848

Merged

3 tasks

MadLittleMods added a commit that referenced this pull request Nov 4, 2022

We don't care about the timeline (just fire and forget)

a8794c2

Split out from #2521 Context: #2521 (comment)

MadLittleMods mentioned this pull request Nov 4, 2022

We don't care about the timeline (just fire and forget to load the event) #2849

Closed

3 tasks

MadLittleMods commented Nov 4, 2022

View reviewed changes

MadLittleMods mentioned this pull request Nov 4, 2022

Load Thread List with server-side assistance (MSC3856) #2602

Merged

4 tasks

MadLittleMods closed this Nov 4, 2022

MadLittleMods deleted the madlittlemods/refresh-timeline-when-we-see-msc2716-marker-events-v2 branch November 4, 2022 11:13

MadLittleMods added a commit that referenced this pull request Nov 4, 2022

Add getLatestLiveTimeline

2451e10

A v2 of #2521

MadLittleMods mentioned this pull request Nov 4, 2022

Fix refreshLiveTimeline(...) not working when the latest event in the room is a threaded message #2852

Closed

3 tasks

MadLittleMods mentioned this pull request Nov 4, 2022

Extra insurance that we don't mix events in the wrong timelines - v2 #2856

Merged

6 tasks

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Fix `getLatestTimeline` not working when the latest event in the room is a threaded message #2521

Fix `getLatestTimeline` not working when the latest event in the room is a threaded message #2521

MadLittleMods commented Jul 13, 2022 •

edited by github-actions bot

Loading

MadLittleMods Jul 13, 2022

MadLittleMods Jul 13, 2022 •

edited

Loading

MadLittleMods Jul 13, 2022

MadLittleMods Jul 13, 2022 •

edited

Loading

MadLittleMods Jul 13, 2022

MadLittleMods Jul 13, 2022

t3chguy Jul 13, 2022 •

edited

Loading

MadLittleMods Jul 13, 2022

t3chguy Jul 13, 2022

MadLittleMods Jul 13, 2022 •

edited

Loading

turt2live Aug 4, 2022

MadLittleMods Aug 29, 2022 •

edited

Loading

turt2live Sep 10, 2022

MadLittleMods Nov 4, 2022

turt2live Aug 4, 2022

MadLittleMods Aug 29, 2022 •

edited

Loading

t3chguy Aug 31, 2022

MadLittleMods Nov 3, 2022

turt2live left a comment

turt2live Sep 10, 2022

MadLittleMods Nov 4, 2022

MadLittleMods Nov 4, 2022

MadLittleMods commented Nov 4, 2022

	describe("canContain", () => {
	const mkThreadResponse = (root: MatrixEvent) => utils.mkEvent({
	event: true,
	type: EventType.RoomMessage,
	user: userA,
	room: roomId,
	content: {
	"body": "Thread response :: " + Math.random(),
	"m.relates_to": {
	"event_id": root.getId(),
	"m.in_reply_to": {
	"event_id": root.getId(),
	},
	"rel_type": "m.thread",
	},
	},
	}, room.client);

	let thread: Thread;

	beforeEach(() => {
	(client.supportsExperimentalThreads as jest.Mock).mockReturnValue(true);
	thread = new Thread("!thread_id:server", messageEvent, { room, client });
	});

	it("should throw if timeline set has no room", () => {
	const eventTimelineSet = new EventTimelineSet(undefined, {}, client);
	expect(() => eventTimelineSet.canContain(messageEvent)).toThrowError();
	});

	it("should return false if timeline set is for thread but event is not threaded", () => {
	const eventTimelineSet = new EventTimelineSet(room, {}, client, thread);
	expect(eventTimelineSet.canContain(replyEvent)).toBeFalsy();
	});

	it("should return false if timeline set it for thread but event it for a different thread", () => {
	const eventTimelineSet = new EventTimelineSet(room, {}, client, thread);
	const event = mkThreadResponse(replyEvent);
	expect(eventTimelineSet.canContain(event)).toBeFalsy();
	});

	it("should return false if timeline set is not for a thread but event is a thread response", () => {
	const eventTimelineSet = new EventTimelineSet(room, {}, client);
	const event = mkThreadResponse(replyEvent);
	expect(eventTimelineSet.canContain(event)).toBeFalsy();
	});

	it("should return true if the timeline set is not for a thread and the event is a thread root", () => {
	const eventTimelineSet = new EventTimelineSet(room, {}, client);
	expect(eventTimelineSet.canContain(messageEvent)).toBeTruthy();
	});

	it("should return true if the timeline set is for a thread and the event is its thread root", () => {
	const thread = new Thread(messageEvent.getId(), messageEvent, { room, client });
	const eventTimelineSet = new EventTimelineSet(room, {}, client, thread);
	messageEvent.setThread(thread);
	expect(eventTimelineSet.canContain(messageEvent)).toBeTruthy();
	});

	it("should return true if the timeline set is for a thread and the event is a response to it", () => {
	const thread = new Thread(messageEvent.getId(), messageEvent, { room, client });
	const eventTimelineSet = new EventTimelineSet(room, {}, client, thread);
	messageEvent.setThread(thread);
	const event = mkThreadResponse(messageEvent);
	expect(eventTimelineSet.canContain(event)).toBeTruthy();
	});
	});

Fix getLatestTimeline not working when the latest event in the room is a threaded message #2521

Fix getLatestTimeline not working when the latest event in the room is a threaded message #2521

Conversation

MadLittleMods commented Jul 13, 2022 • edited by github-actions bot Loading

Dev notes

Checklist

🐛 Bug Fixes

Choose a reason for hiding this comment

MadLittleMods Jul 13, 2022 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

MadLittleMods Jul 13, 2022 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

t3chguy Jul 13, 2022 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

MadLittleMods Jul 13, 2022 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

MadLittleMods Aug 29, 2022 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

MadLittleMods Aug 29, 2022 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

turt2live left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

MadLittleMods commented Nov 4, 2022

Fix `getLatestTimeline` not working when the latest event in the room is a threaded message #2521

Fix `getLatestTimeline` not working when the latest event in the room is a threaded message #2521

MadLittleMods commented Jul 13, 2022 •

edited by github-actions bot

Loading

MadLittleMods Jul 13, 2022 •

edited

Loading

MadLittleMods Jul 13, 2022 •

edited

Loading

t3chguy Jul 13, 2022 •

edited

Loading

MadLittleMods Jul 13, 2022 •

edited

Loading

MadLittleMods Aug 29, 2022 •

edited

Loading

MadLittleMods Aug 29, 2022 •

edited

Loading