sliding sync: add support for typing extension

spec/integ/sliding-sync-sdk.spec.ts

@@ -809,4 +809,106 @@ describe("SlidingSyncSdk", () => {
             });
         });
     });
+    describe("ExtensionTyping", () => {
+        let ext: Extension;
+        beforeAll(async () => {
+            await setupClient();
+            const hasSynced = sdk!.sync();
+            await httpBackend!.flushAllExpected();
+            await hasSynced;
+            ext = findExtension("typing");
+        });
+        it("gets enabled on the initial request only", () => {
+            expect(ext.onRequest(true)).toEqual({
+                enabled: true,
+            });
+            expect(ext.onRequest(false)).toEqual(undefined);
+        });
+        it("processes typing notifications", async () => {
+            const roomId = "!room:id";
+            mockSlidingSync!.emit(SlidingSyncEvent.RoomData, roomId, {
+                name: "Room with typing",
+                required_state: [],
+                timeline: [
+                    mkOwnStateEvent(EventType.RoomCreate, { creator: selfUserId }, ""),
+                    mkOwnStateEvent(EventType.RoomMember, { membership: "join" }, selfUserId),
+                    mkOwnStateEvent(EventType.RoomPowerLevels, { users: { [selfUserId]: 100 } }, ""),
+                    mkOwnEvent(EventType.RoomMessage, { body: "hello" }),
+                ],
+                initial: true,
+            });
+            const room = client!.getRoom(roomId)!;
+            expect(room).toBeDefined();
+            expect(room.getMember(selfUserId)?.typing).toEqual(false);
+            ext.onResponse({
+                rooms: {
+                    [roomId]: [
+                        {
+                            type: EventType.Typing,
+                            content: {
+                                user_ids: [selfUserId],
+                            },
+                        },
+                    ],
+                },
+            });
+            expect(room.getMember(selfUserId)?.typing).toEqual(true);
+            ext.onResponse({
+                rooms: {
+                    [roomId]: [
+                        {
+                            type: EventType.Typing,
+                            content: {
+                                user_ids: [],
+                            },
+                        },
+                    ],
+                },
+            });
+            expect(room.getMember(selfUserId)?.typing).toEqual(false);
+        });
+        it("gracefully handles missing rooms and members when typing", async () => {
+            const roomId = "!room:id";
+            mockSlidingSync!.emit(SlidingSyncEvent.RoomData, roomId, {
+                name: "Room with typing",
+                required_state: [],
+                timeline: [
+                    mkOwnStateEvent(EventType.RoomCreate, { creator: selfUserId }, ""),
+                    mkOwnStateEvent(EventType.RoomMember, { membership: "join" }, selfUserId),
+                    mkOwnStateEvent(EventType.RoomPowerLevels, { users: { [selfUserId]: 100 } }, ""),
+                    mkOwnEvent(EventType.RoomMessage, { body: "hello" }),
+                ],
+                initial: true,
+            });
+            const room = client!.getRoom(roomId)!;
+            expect(room).toBeDefined();
+            expect(room.getMember(selfUserId)?.typing).toEqual(false);
+            ext.onResponse({
+                rooms: {
+                    [roomId]: [
+                        {
+                            type: EventType.Typing,
+                            content: {
+                                user_ids: ["@someone:else"],
+                            },
+                        },
+                    ],
+                },
+            });
+            expect(room.getMember(selfUserId)?.typing).toEqual(false);
+            ext.onResponse({
+                rooms: {
+                    "!something:else": [
+                        {
+                            type: EventType.Typing,
+                            content: {
+                                user_ids: [selfUserId],
+                            },
+                        },
+                    ],
+                },
+            });
+            expect(room.getMember(selfUserId)?.typing).toEqual(false);
+        });
+    });
 });

src/sliding-sync-sdk.ts

@@ -233,6 +233,46 @@ class ExtensionAccountData implements Extension {
     }
 }
 
+class ExtensionTyping implements Extension {
+    public constructor(private readonly client: MatrixClient) {}
+
+    public name(): string {
+        return "typing";
+    }
+
+    public when(): ExtensionState {
+        return ExtensionState.PostProcess;
+    }
+
+    public onRequest(isInitial: boolean): object | undefined {
+        if (!isInitial) {
+            return undefined;
+        }
+        return {
+            enabled: true,
+        };
+    }
+
+    public onResponse(data: {rooms: Record<string, Event[]>}): void {
+        if (!data || !data.rooms) {
+            return;
+        }
+
+        for (const roomId in data.rooms) {
+            const ephemeralEvents = mapEvents(this.client, roomId, data.rooms[roomId]);
+            const room = this.client.getRoom(roomId);
+            if (!room) {
+                logger.warn("got typing events for room but room doesn't exist on client:", roomId);
+                continue;
+            }
+            room.addEphemeralEvents(ephemeralEvents);
+            ephemeralEvents.forEach((e) => {
+                this.client.emit(ClientEvent.Event, e);
+            });
+        }
+    }
+}
+
 /**
  * A copy of SyncApi such that it can be used as a drop-in replacement for sync v2. For the actual
  * sliding sync API, see sliding-sync.ts or the class SlidingSync.
@@ -273,6 +313,7 @@ export class SlidingSyncSdk {
         const extensions: Extension[] = [
             new ExtensionToDevice(this.client),
             new ExtensionAccountData(this.client),
+            new ExtensionTyping(this.client),
         ];
         if (this.opts.crypto) {
             extensions.push(