polfan-server-js-client 0.2.91 → 0.2.93

package/build/types/state-tracker/TopicHistoryWindow.d.ts

@@ -67,9 +67,11 @@ export declare abstract class TraversableRemoteCollection<ItemT, EventMapT exten
     resetToLatest(): Promise<void>;
     fetchPrevious(): Promise<void>;
     fetchNext(): Promise<void>;
+    jumpTo(id: string): Promise<void>;
     protected abstract fetchLatestItems(): Promise<ItemT[]>;
     protected abstract fetchItemsBefore(): Promise<ItemT[] | null>;
     protected abstract fetchItemsAfter(): Promise<ItemT[] | null>;
+    protected abstract fetchItemsAround(id: string): Promise<ItemT[] | null>;
     protected abstract isLatestItemLoaded(): Promise<boolean>;
     protected refreshFetchedState(): Promise<void>;
     protected addItems(newItems: ItemT[], to: 'head' | 'tail'): void;
@@ -100,12 +102,14 @@ export declare class TopicHistoryWindow extends TraversableRemoteCollection<Mess
     resetToLatest(): Promise<void>;
     fetchNext(): Promise<void>;
     fetchPrevious(): Promise<void>;
+    jumpTo(id: string): Promise<void>;
     /**
      * For internal use.
      * @internal
      */
     _updateMessageReference(refTopic: Topic): void;
     protected fetchItemsAfter(): Promise<Message[] | null>;
+    protected fetchItemsAround(id: string): Promise<Message[] | null>;
     protected fetchItemsBefore(): Promise<Message[] | null>;
     protected fetchLatestItems(): Promise<Message[]>;
     private getTopic;

package/build/types/types/src/schemes/commands/GetMessages.d.ts

@@ -3,5 +3,6 @@ export interface GetMessages {
     location: ChatLocation;
     before?: string;
     after?: string;
+    around?: string;
     limit?: number;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polfan-server-js-client",
-  "version": "0.2.91",
+  "version": "0.2.93",
   "description": "JavaScript client library for handling communication with Polfan chat server.",
   "author": "Jarosław Żak",
   "license": "MIT",

package/src/state-tracker/RoomsManager.ts

@@ -153,18 +153,17 @@ export class RoomsManager {
         for (const room of this.list.findBy('spaceId', ev.spaceId).items) {
             const roomMembers = this.members.get(room.id);
 
-            if (! roomMembers || ! roomMembers.has(ev.userId)) {
+            if (!roomMembers || !roomMembers.has(ev.userId)) {
                 // Skip update if member list for this room is not loaded
                 // or user is not in room
                 continue;
             }
 
+            // Update space member in roomMember, but first fill the user object (it's null in event)
             const roomMember = roomMembers.get(ev.userId);
-            const user = roomMember.spaceMember.user;
-
-            // Update space member but first fill user object (it's null in event object)
-            roomMember.spaceMember = {...ev.member, user};
-            roomMembers.set(roomMember);
+            const spaceMember = ev.member;
+            spaceMember.user = roomMember.spaceMember.user;
+            roomMembers.set({ ...roomMember, spaceMember });
         }
     }
 
@@ -243,8 +242,9 @@ export class RoomsManager {
         }
 
         if (room.defaultTopic.id === ev.topic.id) {
-            room.defaultTopic = ev.topic;
-            this.list.set(room);
+            const newRoom = { ...room };
+            newRoom.defaultTopic = ev.topic;
+            this.list.set(newRoom);
         }
     }
 

package/src/state-tracker/TopicHistoryWindow.ts

@@ -202,12 +202,40 @@ export abstract class TraversableRemoteCollection<
         }
     }
 
+    public async jumpTo(id: string): Promise<void> {
+        if (this.internalState.ongoing || this._items.has(id)) {
+            return;
+        }
+
+        let result: ItemT[] | null;
+        const originalState = this.state;
+        this.internalState.ongoing = WindowState.PAST;
+
+        try {
+            result = await this.fetchItemsAround(id);
+            this.internalState.lastFetchCount = result ? result.length : 0;
+        } finally {
+            this.internalState.ongoing = undefined;
+        }
+
+        if (!result) {
+            return;
+        }
+
+        this._items.deleteAll(); // Directly call deleteAll to prevent event emit.
+        this.addItems(result, 'tail');
+        this.internalState.current = WindowState.PAST;
+        this.emitChangeWithDiff(true, originalState);
+    }
+
     protected abstract fetchLatestItems(): Promise<ItemT[]>;
 
     protected abstract fetchItemsBefore(): Promise<ItemT[] | null>;
 
     protected abstract fetchItemsAfter(): Promise<ItemT[] | null>;
 
+    protected abstract fetchItemsAround(id: string): Promise<ItemT[] | null>;
+
     protected abstract isLatestItemLoaded(): Promise<boolean>;
 
     protected async refreshFetchedState(): Promise<void> {
@@ -334,6 +362,13 @@ export class TopicHistoryWindow extends TraversableRemoteCollection<
         return super.fetchPrevious();
     }
 
+    public async jumpTo(id: string): Promise<void> {
+        if (this.internalState.traverseLock) {
+            return;
+        }
+        return super.jumpTo(id);
+    }
+
     /**
      * For internal use.
      * @internal
@@ -368,6 +403,20 @@ export class TopicHistoryWindow extends TraversableRemoteCollection<
         return result.data.messages;
     }
 
+    protected async fetchItemsAround(id: string): Promise<Message[] | null> {
+        const result = await this.tracker.client.send('GetMessages', {
+            location: {roomId: this.roomId, topicId: this.topicId},
+            around: id,
+            limit: this.internalState.fetchLimit,
+        });
+
+        if (result.error) {
+            throw new Error(`Cannot fetch messages: ${result.error.message}`);
+        }
+
+        return result.data.messages;
+    }
+
     protected async fetchItemsBefore(): Promise<Message[] | null> {
         const beforeId = this.getAt(0)?.id;
 
@@ -446,4 +495,4 @@ export class TopicHistoryWindow extends TraversableRemoteCollection<
             this.eventTarget.emit('reftopicsdeleted', refTopicIds);
         }
     }
-}
+}

package/src/types/src/schemes/commands/GetMessages.ts

@@ -4,5 +4,6 @@ export interface GetMessages {
     location: ChatLocation;
     before?: string;
     after?: string;
+    around?: string;
     limit?: number;
 }

package/tests/history-window.test.ts

@@ -18,12 +18,32 @@ const messages: SimpleMessage[] = [
 ];
 
 class TestableHistoryWindow extends TraversableRemoteCollection<SimpleMessage> {
+    declare protected internalState: TraversableRemoteCollection<SimpleMessage>['internalState'] & {
+        traverseLock: boolean,
+    };
+
     public createMirror(): TraversableRemoteCollection<SimpleMessage> {
         throw new Error('Method not implemented.');
     }
 
     public constructor() {
         super('id');
+        this.internalState.traverseLock = false;
+    }
+
+    public async setTraverseLock(lock: boolean): Promise<void> {
+        this.internalState.traverseLock = lock;
+
+        if (lock && (this.state !== WindowState.LIVE && this.state !== WindowState.LATEST)) {
+            await super.resetToLatest();
+        }
+    }
+
+    public async jumpTo(id: string): Promise<void> {
+        if (this.internalState.traverseLock) {
+            return;
+        }
+        return super.jumpTo(id);
     }
 
     public simulateNewMessageReceived(): void {
@@ -49,6 +69,18 @@ class TestableHistoryWindow extends TraversableRemoteCollection<SimpleMessage> {
         return messages.slice(after + 1, after + 4);
     }
 
+    protected async fetchItemsAround(id: string): Promise<SimpleMessage[] | null> {
+        const numericId = parseInt(id, 10);
+        const item = messages.find(m => m.id === numericId);
+        if (!item) {
+            return null;
+        }
+        const index = messages.indexOf(item);
+        const start = Math.max(0, index - Math.floor(this.fetchLimit / 2));
+        const end = Math.min(messages.length, index + Math.ceil(this.fetchLimit / 2));
+        return messages.slice(start, end);
+    }
+
     protected async fetchItemsBefore(): Promise<SimpleMessage[]> {
         const before = this.getAt(0)?.id;
         if (before === undefined) {
@@ -177,6 +209,57 @@ test('history window - reset to latest', async () => {
     [7,8,9].forEach(id => expect(window.items.map(item => item.id)).toContain(id));
 });
 
+test('history window - jump to message', async () => {
+    const window = new TestableHistoryWindow();
+    window.limit = 5;
+    window.fetchLimit = 3;
+
+    await window.resetToLatest(); // [7,8,9]
+    await window.jumpTo('2'); // [1,2,3]
+
+    expect(window.state).toEqual(WindowState.PAST);
+    expect(window.items).toHaveLength(3);
+    [1,2,3].forEach(id => expect(window.items.map(item => item.id)).toContain(id));
+});
+
+test('history window - jump to message already in window', async () => {
+    const window = new TestableHistoryWindow();
+    window.limit = 5;
+    window.fetchLimit = 3;
+
+    await window.resetToLatest(); // [7,8,9]
+    const itemsBeforeJump = window.items;
+    await window.jumpTo('8');
+
+    expect(window.items).toEqual(itemsBeforeJump);
+});
+
+test('history window - jump to non-existent message', async () => {
+    const window = new TestableHistoryWindow();
+    window.limit = 5;
+    window.fetchLimit = 3;
+
+    await window.resetToLatest(); // [7,8,9]
+    const itemsBeforeJump = window.items;
+    await window.jumpTo('99'); // non-existent
+
+    expect(window.items).toEqual(itemsBeforeJump);
+});
+
+test('history window - jump to message with traverseLock', async () => {
+    const window = new TestableHistoryWindow();
+    window.limit = 5;
+    window.fetchLimit = 3;
+
+    await window.resetToLatest(); // [7,8,9]
+    await window.setTraverseLock(true);
+    await window.jumpTo('2');
+
+    expect(window.state).toEqual(WindowState.LATEST);
+    expect(window.items).toHaveLength(3);
+    [7,8,9].forEach(id => expect(window.items.map(item => item.id)).toContain(id));
+});
+
 test('history window - trim messages window to limit', async () => {
     const window = new TestableHistoryWindow();
     window.limit = 5;
@@ -284,4 +367,4 @@ test('history window - high/low watermark limit (retainRatio)', async () => {
     expect(window.items).toHaveLength(3);
     [7, 8, 9].forEach(id => expect(window.items.map(item => item.id)).toContain(id));
     expect(window.state).toEqual(WindowState.LATEST);
-});
+});