polfan-server-js-client 0.2.3 → 0.2.7

package/src/AbstractChatClient.ts

@@ -82,14 +82,30 @@ import {
     GetEmoticons,
     Emoticons,
     EmoticonDeleted,
-    NewEmoticon, Bans, GetBans, Ban, Unban, Kick, ClientData, GetClientData, SetClientData,
+    NewEmoticon,
+    Bans,
+    GetBans,
+    Ban,
+    Unban,
+    Kick,
+    ClientData,
+    GetClientData,
+    SetClientData,
     GetRoomSummary,
     GetSpaceSummary,
     RoomSummaryEvent,
     SpaceSummaryEvent,
-    SetCustomNick,
+    UpdateSpaceMember,
+    Relationships,
+    RelationshipDeleted,
+    NewRelationship,
+    DeleteRelationship,
+    CreateRelationship,
+    RoomSummaryUpdated, Pong, Ping,
 } from "./types/src/index";
 import {EventTarget} from "./EventTarget";
+import {GetRelationships} from "./types/src/schemes/commands/GetRelationships";
+import {UpdateRoomMember} from "./types/src/schemes/commands/UpdateRoomMember";
 
 type ArrayOfPromiseResolvers = [(value: any) => void, (reason?: any) => void];
 
@@ -139,7 +155,7 @@ export abstract class AbstractChatClient extends EventTarget {
         if (!this.awaitingResponse.has(envelope.ref)) {
             return;
         }
-        this.awaitingResponse.get(envelope.ref)[0](error);
+        this.awaitingResponse.get(envelope.ref)[1](error);
         this.awaitingResponse.delete(envelope.ref);
     }
 }
@@ -165,6 +181,10 @@ export type EventsMap = {
     Emoticons: Emoticons,
     Bans: Bans,
     ClientData: ClientData,
+    NewRelationship: NewRelationship,
+    RelationshipDeleted: RelationshipDeleted,
+    Relationships: Relationships,
+    Pong: Pong,
     // Space events
     DiscoverableSpaces: DiscoverableSpaces,
     SpaceJoined: SpaceJoined,
@@ -191,6 +211,7 @@ export type EventsMap = {
     RoomDeleted: RoomDeleted,
     RoomUpdated: RoomUpdated,
     RoomSummaryEvent: RoomSummaryEvent,
+    RoomSummaryUpdated: RoomSummaryUpdated,
     // Topic events
     NewTopic: NewTopic,
     TopicDeleted: TopicDeleted,
@@ -227,6 +248,10 @@ export type CommandsMap = {
     Kick: [Kick, EventsMap['Ok']],
     GetClientData: [GetClientData, EventsMap['ClientData']],
     SetClientData: [SetClientData, EventsMap['Ok']],
+    DeleteRelationship: [DeleteRelationship, EventsMap['RelationshipDeleted']],
+    CreateRelationship: [CreateRelationship, EventsMap['NewRelationship']],
+    GetRelationships: [GetRelationships, EventsMap['Relationships']],
+    Ping: [Ping, EventsMap['Pong']],
     // Space commands
     GetDiscoverableSpaces: [GetDiscoverableSpaces, EventsMap['DiscoverableSpaces']],
     JoinSpace: [JoinSpace, EventsMap['SpaceJoined']],
@@ -242,7 +267,7 @@ export type CommandsMap = {
     AssignRole: [AssignRole, EventsMap['SpaceMemberUpdated'] | EventsMap['RoomMemberUpdated']],
     DeassignRole: [DeassignRole, EventsMap['SpaceMemberUpdated'] | EventsMap['RoomMemberUpdated']],
     GetSpaceSummary: [GetSpaceSummary, EventsMap['SpaceSummaryEvent']],
-    SetCustomNick: [SetCustomNick, EventsMap['SpaceMemberUpdated']],
+    UpdateSpaceMember: [UpdateSpaceMember, EventsMap['SpaceMemberUpdated']],
     // Room commands
     JoinRoom: [JoinRoom, EventsMap['RoomJoined']],
     LeaveRoom: [LeaveRoom, EventsMap['RoomLeft']],
@@ -251,6 +276,7 @@ export type CommandsMap = {
     UpdateRoom: [UpdateRoom, EventsMap['RoomUpdated']],
     GetRoomMembers: [GetRoomMembers, EventsMap['RoomMembers']],
     GetRoomSummary: [GetRoomSummary, EventsMap['RoomSummaryEvent']],
+    UpdateRoomMember: [UpdateRoomMember, EventsMap['RoomMemberUpdated']],
     // Topic commands
     CreateTopic: [CreateTopic, EventsMap['NewTopic']],
     DeleteTopic: [DeleteTopic, EventsMap['TopicDeleted']],

package/src/FilesClient.ts

@@ -3,28 +3,41 @@ import {AbstractRestClient, RestClientResponse} from "./AbstractRestClient";
 export interface File {
     id: string;
     url: string;
-    original_url: string;
-    original_name: string;
-    mime_type: string;
+    name: string;
+    mime: string;
     size: number;
-    image_dimensions: [number, number] | null;
+    width?: number;
+    height?: number;
 }
 
 export class FilesClient extends AbstractRestClient {
-    protected defaultUrl: string = 'https://polfan.pl/webservice/api/files';
+    protected defaultUrl: string = 'https://files.devana.pl';
 
-    public async uploadFile(file: Parameters<typeof FormData.prototype.append>[1]): Promise<RestClientResponse<File>> {
-        const formData = new FormData();
-        formData.append('file', file);
+    public async uploadFile(file: globalThis.File | Blob): Promise<RestClientResponse<File>> {
+        const name = encodeURIComponent((file as globalThis.File).name ?? '');
+        let headers = {
+            ...this.getAuthHeaders(),
+            Accept: 'application/json',
+            'Content-Disposition': `attachment; filename="${name}"`,
+            'Content-Length': file.size
+        };
 
-        let headers = {...this.getAuthHeaders(), Accept: 'application/json'};
-
-        const response = await fetch(this.defaultUrl, {method: 'POST', body: formData, headers});
+        const response = await fetch(this.getUrl('files'), {
+            method: 'POST',
+            body: file,
+            headers
+        });
 
         return this.convertFetchResponse<File>(response);
     }
 
-    public async getFileMetadata(id: string): Promise<RestClientResponse<File>> {
-        return this.send('GET', '/' + id);
+    public async getFileMeta(id: string): Promise<RestClientResponse<File>> {
+        return this.send('GET', 'files/' + id);
+    }
+
+    public async getFileMetaBulk(ids: string[]): Promise<RestClientResponse<File[]>> {
+        const searchParams = new URLSearchParams();
+        ids.forEach(id => searchParams.append('id[]', id));
+        return this.send('GET', 'files?' + searchParams);
     }
 }

package/src/IndexedObjectCollection.ts

@@ -2,16 +2,11 @@ import {EventTarget, ObservableInterface} from "./EventTarget";
 
 export class IndexedCollection<KeyT, ValueT> {
     protected _items: Map<KeyT, ValueT> = new Map();
-    protected _mutationCounter: number = 0;
 
     public constructor(items: [key: KeyT, value: ValueT][] = []) {
         this.set(...items);
     }
 
-    public get mutationCounter(): number {
-        return this._mutationCounter;
-    }
-
     public get items(): Map<KeyT, ValueT> {
         return this._items;
     }
@@ -21,7 +16,6 @@ export class IndexedCollection<KeyT, ValueT> {
     }
 
     public set(...items: [KeyT, ValueT][]): void {
-        this._mutationCounter++;
         for (const item of items) {
             this._items.set(item[0], item[1]);
         }
@@ -58,6 +52,12 @@ export class IndexedCollection<KeyT, ValueT> {
         }
         return result;
     }
+
+    public createMirror(): IndexedCollection<KeyT, ValueT> {
+        const copy = new IndexedCollection<KeyT, ValueT>();
+        copy._items = this._items;
+        return copy;
+    }
 }
 
 export class IndexedObjectCollection<T> {
@@ -79,10 +79,6 @@ export class IndexedObjectCollection<T> {
         return this._items.length;
     }
 
-    public get mutationCounter(): number {
-        return this._items.mutationCounter;
-    }
-
     public set(...items: T[]): void {
         this._items.set(...(items.map(item => [this.getId(item), item] as [string, T])));
     }
@@ -120,6 +116,12 @@ export class IndexedObjectCollection<T> {
         return result;
     }
 
+    public createMirror(): IndexedObjectCollection<T> {
+        const copy = new IndexedObjectCollection<T>(this.id);
+        copy._items = this._items;
+        return copy;
+    }
+
     protected getId(item: T): any {
         return typeof this.id === 'function' ? this.id(item) : item[this.id];
     }
@@ -161,6 +163,13 @@ export class ObservableIndexedCollection<KeyT, ValueT> extends IndexedCollection
         }
     }
 
+    public createMirror(): ObservableIndexedCollection<KeyT, ValueT> {
+        const copy = new ObservableIndexedCollection<KeyT, ValueT>();
+        copy.eventTarget = this.eventTarget;
+        copy._items = this._items;
+        return copy;
+    }
+
     public on(eventName: 'change', handler: (ev?: ObservableCollectionEvent<KeyT>) => void): this {
         this.eventTarget.on(eventName, handler);
         return this;
@@ -211,6 +220,13 @@ export class ObservableIndexedObjectCollection<T> extends IndexedObjectCollectio
         }
     }
 
+    public createMirror(): IndexedObjectCollection<T> {
+        const copy = new ObservableIndexedObjectCollection<T>(this.id);
+        copy.eventTarget = this.eventTarget;
+        copy._items = this._items;
+        return copy;
+    }
+
     public on(eventName: 'change', handler: (ev?: ObservableCollectionEvent<string>) => void): this {
         this.eventTarget.on(eventName, handler);
         return this;

package/src/Permissions.ts

@@ -30,6 +30,7 @@ export class Permissions {
         ManageBan: {value: 1 << 15, maxLayer: Layer.Room},
         Kick: {value: 1 << 16, maxLayer: Layer.Room},
         ChangeOwnNick: {value: 1 << 17, maxLayer: Layer.Space},
+        ChangeOwnColor: {value: 1 << 18, maxLayer: Layer.Room},
     };
 
     public static getNames(): (keyof typeof this.list)[] {

package/src/WebSocketChatClient.ts

@@ -1,5 +1,5 @@
 import {ObservableInterface} from "./EventTarget";
-import {AbstractChatClient, CommandResult, CommandsMap} from "./AbstractChatClient";
+import {AbstractChatClient, CommandResult, CommandsMap, EventsMap} from "./AbstractChatClient";
 import {ChatStateTracker} from "./state-tracker/ChatStateTracker";
 import {Envelope} from "./types/src";
 
@@ -10,6 +10,20 @@ export interface WebSocketClientOptions {
     awaitQueueSendDelayMs?: number;
     stateTracking?: boolean;
     queryParams?: Record<string, string>;
+    /**
+     * Ping/pong configuration, enabled by default.
+     */
+    ping?: {
+        enabled?: boolean;
+        /**
+         * Time without activity after which a ping will be sent. Default is 10 seconds.
+         */
+        noActivityTimeoutMs?: number;
+        /**
+         * Time to wait for a pong response before considering the connection dead. Default is 2 seconds.
+         */
+        pongBackTimeoutMs?: number;
+    },
 }
 
 enum WebSocketChatClientEvent {
@@ -28,15 +42,27 @@ export class WebSocketChatClient extends AbstractChatClient implements Observabl
     protected connectingTimeoutId: any;
     protected authenticated: boolean;
     protected authenticatedResolvers: [() => void, (error: Error) => void];
+    protected pingIntervalId?: NodeJS.Timeout;
+    protected lastReceivedMessageAt?: number;
+    protected pingInFlight: boolean;
 
     public constructor(private readonly options: WebSocketClientOptions) {
         super();
         if (this.options.stateTracking ?? true) {
             this.state = new ChatStateTracker(this);
         }
+
+        options.ping ??= {};
+        options.ping.enabled ??= true;
+        options.ping.noActivityTimeoutMs ??= 15000;
+        options.ping.pongBackTimeoutMs ??= 5000;
     }
 
     public async connect(): Promise<void> {
+        if (this.isOpenWsState() || this.isConnectingWsState()) {
+            return;
+        }
+
         const params = new URLSearchParams(this.options.queryParams ?? {});
         params.set('token', this.options.token);
 
@@ -48,43 +74,47 @@ export class WebSocketChatClient extends AbstractChatClient implements Observabl
             this.options.connectingTimeoutMs ?? 10000
         );
         this.authenticated = false;
-
         return new Promise((...args) => this.authenticatedResolvers = args);
     }
 
     public disconnect(): void {
         this.sendQueue = [];
-        this.ws?.close();
+        this.ws?.close(1000); // Normal closure
         this.ws = null;
     }
 
     public async send<CommandType extends keyof CommandsMap>(commandType: CommandType, commandData: CommandsMap[CommandType][0]):
        Promise<CommandResult<CommandsMap[CommandType][1]>> {
-        if (!this.ws || [this.ws.CLOSED, this.ws.CLOSING].includes(this.ws.readyState)) {
-            throw new Error('Cannot send; close or closing connection state');
-        }
-
         const envelope = this.createEnvelope<CommandsMap[CommandType][0]>(commandType, commandData);
         const promise = this.createPromiseFromCommandEnvelope<CommandType>(envelope);
 
-        if (this.ws.readyState === this.ws.CONNECTING || !this.authenticated) {
+        if (this.isConnectingWsState() || !this.authenticated && this.isOpenWsState()) {
             this.sendQueue.push(envelope);
             return promise;
         }
 
-        if (this.ws.readyState !== this.ws.OPEN) {
-            throw new Error(`Invalid websocket state=${this.ws.readyState}`);
-        }
-
         this.sendEnvelope(envelope);
         return promise;
     }
 
+    public get isReady(): boolean {
+        return this.isOpenWsState() && this.authenticated;
+    }
+
     private sendEnvelope(envelope: Envelope): void {
-        this.ws.send(JSON.stringify(envelope));
+        if (this.isReady) {
+            this.ws.send(JSON.stringify(envelope));
+            return;
+        }
+
+        this.handleEnvelopeSendError(
+            envelope,
+            new Error(`Cannot send - client is not ready (state=${this.ws?.readyState ?? '[no connection]'}; authenticated=${this.authenticated})`)
+        );
     }
 
     private onMessage(event: MessageEvent): void {
+        this.lastReceivedMessageAt = Date.now();
         const envelope: Envelope = JSON.parse(event.data);
         this.handleIncomingEnvelope(envelope);
         this.emit(envelope.type, envelope.data);
@@ -95,6 +125,7 @@ export class WebSocketChatClient extends AbstractChatClient implements Observabl
             const isAuthenticated = envelope.type !== 'Bye';
             this.authenticated = isAuthenticated;
             if (isAuthenticated) {
+                this.startConnectionMonitor();
                 this.authenticatedResolvers[0]();
                 this.emit(this.Event.connect);
                 this.sendFromQueue();
@@ -105,10 +136,11 @@ export class WebSocketChatClient extends AbstractChatClient implements Observabl
     }
 
     private onClose(event: CloseEvent): void {
+        this.stopConnectionMonitor();
         clearTimeout(this.connectingTimeoutId);
         const reconnect = event.code !== 1000; // Connection was closed because of error
         if (reconnect) {
-            this.connect();
+            void this.connect();
         }
         this.emit(this.Event.disconnect, reconnect);
     }
@@ -129,4 +161,50 @@ export class WebSocketChatClient extends AbstractChatClient implements Observabl
         this.disconnect();
         this.emit(this.Event.error, new Error('Connection timeout'));
     }
+
+    private isConnectingWsState(): boolean {
+        return this.ws && this.ws.readyState === this.ws.CONNECTING;
+    }
+
+    private isOpenWsState(): boolean {
+        return this.ws && this.ws.readyState === this.ws.OPEN;
+    }
+
+    private startConnectionMonitor(): void {
+        if (!this.options.ping!.enabled) {
+            return;
+        }
+
+        this.lastReceivedMessageAt = Date.now();
+
+        this.pingIntervalId = setInterval(async () => {
+            if (!this.isReady || this.pingInFlight) {
+                return;
+            }
+
+            if ((Date.now() - this.lastReceivedMessageAt) < this.options.ping!.noActivityTimeoutMs) {
+                return;
+            }
+
+            const timeout = setTimeout(() => {
+                this.pingInFlight = false;
+                this.ws.close(3000); // Service Restart (reconnect)
+            }, this.options.ping.pongBackTimeoutMs);
+
+            this.pingInFlight = true;
+
+            this.send('Ping', {}).then(() => {
+                this.pingInFlight = false;
+                clearTimeout(timeout);
+            });
+        }, 1000);
+    }
+
+    private stopConnectionMonitor(): void {
+        if (this.pingIntervalId) {
+            clearInterval(this.pingIntervalId);
+            this.pingIntervalId = undefined;
+        }
+        this.pingInFlight = false;
+    }
 }

package/src/state-tracker/ChatStateTracker.ts

@@ -6,38 +6,54 @@ import {PermissionsManager} from "./PermissionsManager";
 import {DeferredTask} from "./AsyncUtils";
 import {EmoticonsManager} from "./EmoticonsManager";
 import {UsersManager} from "./UsersManager";
+import {RelationshipsManager} from "./RelationshipsManager";
 
 export class ChatStateTracker {
+    public readonly client: WebSocketChatClient;
+
     /**
      * State of your permissions.
      */
-    public readonly permissions = new PermissionsManager(this);
+    public readonly permissions: PermissionsManager;
 
     /**
      * State of the rooms you are in.
      */
-    public readonly rooms: RoomsManager = new RoomsManager(this);
+    public readonly rooms: RoomsManager;
 
     /**
      * State of the spaces you are in.
      */
-    public readonly spaces = new SpacesManager(this);
+    public readonly spaces: SpacesManager;
 
     /**
      * State of the emoticons (global and space-related).
      */
-    public readonly emoticons = new EmoticonsManager(this);
+    public readonly emoticons: EmoticonsManager;
 
     /**
      * Users related state.
      */
-    public readonly users = new UsersManager(this);
+    public readonly users: UsersManager;
+
+    /**
+     * State of relationships with other users.
+     */
+    public readonly relationships: RelationshipsManager;
 
     private _me: User = null;
     private readonly deferredSession = new DeferredTask();
 
-    public constructor(public readonly client: WebSocketChatClient) {
+    public constructor(client: WebSocketChatClient) {
+        this.client = client;
         this.client.on('Session', ev => this.handleSession(ev));
+
+        this.permissions = new PermissionsManager(this);
+        this.rooms = new RoomsManager(this);
+        this.spaces = new SpacesManager(this);
+        this.emoticons = new EmoticonsManager(this);
+        this.users = new UsersManager(this);
+        this.relationships = new RelationshipsManager(this);
     }
 
     public get me(): User | null {

package/src/state-tracker/EmoticonsManager.ts

@@ -21,18 +21,20 @@ export class EmoticonsManager {
     }
 
     public async get(spaceId?: string): Promise<ObservableIndexedObjectCollection<Emoticon>> {
-        if (this.emoticonsPromises.notExist(spaceId)) {
+        const key = spaceId ?? GLOBAL_KEY;
+
+        if (this.emoticonsPromises.notExist(key)) {
             this.emoticonsPromises.registerByFunction(async () => {
                 const result = await this.tracker.client.send('GetEmoticons', {spaceId});
                 if (result.error) {
                     throw result.error;
                 }
                 this.handleEmoticons(result.data);
-            }, spaceId ?? GLOBAL_KEY);
+            }, key);
         }
 
-        await this.emoticonsPromises.get(spaceId);
-        return this.list.get(spaceId);
+        await this.emoticonsPromises.get(key);
+        return this.list.get(key);
     }
 
     private handleEmoticons(event: Emoticons): void {

package/src/state-tracker/MessagesManager.ts

@@ -1,6 +1,5 @@
 import {ChatStateTracker} from "./ChatStateTracker";
 import {
-    ChatLocation,
     NewMessage,
     FollowedTopic,
     TopicFollowed,
@@ -8,7 +7,7 @@ import {
     RoomDeleted,
     RoomLeft,
     TopicDeleted,
-    FollowedTopicUpdated, RoomJoined, NewTopic, Session, Room,
+    FollowedTopicUpdated, RoomJoined, NewTopic, Session, Room, MessageType,
 } from "../types/src";
 import {
     IndexedCollection,
@@ -210,8 +209,8 @@ export class MessagesManager {
         const roomFollowedTopics = this.followedTopics.get(ev.message.location.roomId);
         const followedTopic = roomFollowedTopics?.get(ev.message.location.topicId);
 
-        if (! roomFollowedTopics || ! followedTopic) {
-            // Skip if we don't follow this room or targeted topic
+        if (!roomFollowedTopics || !followedTopic || ev.message.type === 'Ephemeral') {
+            // Skip if we don't follow this room or targeted topic or the message is ephemeral
             return;
         }
 

package/src/state-tracker/RelationshipsManager.ts

@@ -0,0 +1,68 @@
+import {ObservableIndexedObjectCollection} from "../IndexedObjectCollection";
+import {
+    NewRelationship,
+    RelationshipDeleted,
+    Relationships,
+    UserRelationship,
+    UserRelationshipType
+} from "../types/src";
+import {PromiseRegistry} from "./AsyncUtils";
+import {ChatStateTracker} from "./ChatStateTracker";
+
+const getId = (refUserId: string, type: UserRelationshipType): string => `${refUserId}-${type}`;
+const getIdFromRelationship = (relationship: UserRelationship): string => getId(relationship.refUser.id, relationship.type);
+
+export class RelationshipsManager {
+    private relationships: ObservableIndexedObjectCollection<UserRelationship> = new ObservableIndexedObjectCollection<UserRelationship>(getIdFromRelationship);
+    private promises = new PromiseRegistry();
+
+    public constructor(private tracker: ChatStateTracker) {
+        this.tracker.client.on('Relationships', ev => this.handleRelationships(ev));
+        this.tracker.client.on('NewRelationship', ev => this.handleNewRelationship(ev));
+        this.tracker.client.on('RelationshipDeleted', ev => this.handleRelationshipDeleted(ev));
+        this.tracker.client.on('Session', () => this.handleSession());
+    }
+
+    public async get(): Promise<ObservableIndexedObjectCollection<UserRelationship>> {
+        if (this.promises.notExist('all')) {
+            this.promises.registerByFunction(async () => {
+                const result = await this.tracker.client.send('GetRelationships', {});
+                if (result.error) {
+                    throw result.error;
+                }
+            }, 'all');
+        }
+
+        await this.promises.get('all');
+        return this.relationships;
+    }
+
+    public async exists(refUserId: string, type: UserRelationshipType): Promise<boolean> {
+        await this.get();
+        return this.relationships.has(getId(refUserId, type));
+    }
+
+    private handleRelationships(ev: Relationships): void {
+        this.relationships.deleteAll();
+        ev.relationships.forEach(relationship => {
+            this.relationships.set(relationship);
+        });
+    }
+
+    private handleNewRelationship(ev: NewRelationship): void {
+        if (this.promises.has('all')) {
+            this.relationships.set(ev.relationship);
+        }
+    }
+
+    private handleRelationshipDeleted(ev: RelationshipDeleted): void {
+        if (this.promises.has('all')) {
+            this.relationships.delete(getIdFromRelationship(ev.relationship));
+        }
+    }
+
+    private handleSession(): void {
+        this.promises.forgetAll();
+        this.relationships.deleteAll();
+    }
+}

package/src/state-tracker/RoomMessagesHistory.ts

@@ -5,6 +5,7 @@ import {TopicHistoryWindow} from "./TopicHistoryWindow";
 
 export class RoomMessagesHistory {
     private historyWindows = new IndexedCollection<string, TopicHistoryWindow>();
+    private traverseLock: boolean = false;
 
     public constructor(
         private room: Room,
@@ -14,6 +15,8 @@ export class RoomMessagesHistory {
         this.tracker.client.on('NewTopic', ev => this.handleNewTopic(ev));
         this.tracker.client.on('TopicDeleted', ev => this.handleTopicDeleted(ev));
 
+        this.updateTraverseLock(this.room);
+
         if (this.room.defaultTopic) {
             this.createHistoryWindowForTopic(this.room.defaultTopic);
         }
@@ -25,7 +28,7 @@ export class RoomMessagesHistory {
     public async getMessagesWindow(topicId: string): Promise<TopicHistoryWindow | undefined> {
         let historyWindow = this.historyWindows.get(topicId);
 
-        if (! historyWindow) {
+        if (!historyWindow) {
             const topic = (await this.tracker.rooms.getTopics(this.room.id, [topicId])).get(topicId);
 
             if (topic) {
@@ -36,13 +39,19 @@ export class RoomMessagesHistory {
         return this.historyWindows.get(topicId);
     }
 
-    private handleRoomUpdated(ev: RoomUpdated): void {
+    private async handleRoomUpdated(ev: RoomUpdated): Promise<void> {
         if (this.room.id === ev.room.id) {
             this.room = ev.room;
 
+            this.updateTraverseLock(ev.room);
+
             if (ev.room.defaultTopic) {
                 this.createHistoryWindowForTopic(ev.room.defaultTopic);
             }
+
+            for (const [, window] of Array.from(this.historyWindows.items)) {
+                await window.setTraverseLock(this.traverseLock);
+            }
         }
     }
 
@@ -63,7 +72,11 @@ export class RoomMessagesHistory {
             return;
         }
 
-        this.historyWindows.set([topic.id, new TopicHistoryWindow(this.room.id, topic.id, this.tracker)]);
+        const historyWindow = new TopicHistoryWindow(this.room.id, topic.id, this.tracker);
+
+        void historyWindow.setTraverseLock(this.traverseLock);
+
+        this.historyWindows.set([topic.id, historyWindow]);
 
         // If new topic refers to some message from this room, update other structures
         if (topic.refMessage) {
@@ -71,4 +84,8 @@ export class RoomMessagesHistory {
             refHistoryWindow?._updateMessageReference(topic);
         }
     }
+
+    private updateTraverseLock(room: Room): void {
+        this.traverseLock = room.history.mode === 'Ephemeral';
+    }
 }