polfan-server-js-client 0.1.992 → 0.1.994

package/build/types/AbstractChatClient.d.ts

@@ -1,4 +1,4 @@
-import { Bye, GetSession, JoinSpace, Session, SpaceJoined, Error as ErrorType, SpaceLeft, SpaceMemberJoined, SpaceMemberLeft, SpaceMemberUpdated, SpaceDeleted, SpaceMembers, SpaceRooms, NewRole, RoomDeleted, RoomJoined, RoomLeft, RoomMemberLeft, RoomMemberJoined, RoomMembers, NewRoom, NewTopic, TopicDeleted, NewMessage, GetPermissionOverwrites, GetComputedPermissions, LeaveSpace, CreateSpace, DeleteSpace, GetSpaceMembers, GetSpaceRooms, CreateRole, DeleteRole, AssignRole, DeassignRole, SetPermissionOverwrites, JoinRoom, LeaveRoom, CreateRoom, DeleteRoom, GetRoomMembers, CreateTopic, DeleteTopic, CreateMessage, Envelope, PermissionOverwrites, PermissionOverwritesUpdated, RoomMemberUpdated, UpdateRole, RoleUpdated, Ack, UserUpdated, UpdateRoom, RoomUpdated, UpdateSpace, SpaceUpdated, PermissionOverwriteTargets, GetPermissionOverwriteTargets, Owners, Ok, GetOwners, CreateOwner, RoleDeleted, FollowedTopicUpdated, TopicFollowed, TopicUnfollowed, FollowedTopics, FollowTopic, UnfollowTopic, GetFollowedTopics } from "./types/src/index";
+import { Bye, GetSession, JoinSpace, Session, SpaceJoined, Error as ErrorType, SpaceLeft, SpaceMemberJoined, SpaceMemberLeft, SpaceMemberUpdated, SpaceDeleted, SpaceMembers, SpaceRooms, NewRole, RoomDeleted, RoomJoined, RoomLeft, RoomMemberLeft, RoomMemberJoined, RoomMembers, NewRoom, NewTopic, TopicDeleted, NewMessage, GetPermissionOverwrites, GetComputedPermissions, LeaveSpace, CreateSpace, DeleteSpace, GetSpaceMembers, GetSpaceRooms, CreateRole, DeleteRole, AssignRole, DeassignRole, SetPermissionOverwrites, JoinRoom, LeaveRoom, CreateRoom, DeleteRoom, GetRoomMembers, CreateTopic, DeleteTopic, CreateMessage, Envelope, PermissionOverwrites, PermissionOverwritesUpdated, RoomMemberUpdated, UpdateRole, RoleUpdated, Ack, UserUpdated, UpdateRoom, RoomUpdated, UpdateSpace, SpaceUpdated, PermissionOverwriteTargets, GetPermissionOverwriteTargets, Owners, Ok, GetOwners, CreateOwner, RoleDeleted, FollowedTopicUpdated, TopicFollowed, TopicUnfollowed, FollowedTopics, FollowTopic, UnfollowTopic, GetFollowedTopics, Messages, GetMessages, Topics, GetTopics } from "./types/src/index";
 import { EventTarget } from "./EventTarget";
 type ArrayOfPromiseResolvers = [(value: any) => void, (reason?: any) => void];
 export declare abstract class AbstractChatClient extends EventTarget {
@@ -58,6 +58,8 @@ export type EventsMap = {
     TopicUnfollowed: TopicUnfollowed;
     FollowedTopics: FollowedTopics;
     FollowedTopicUpdated: FollowedTopicUpdated;
+    Messages: Messages;
+    Topics: Topics;
 };
 /**
  * Map of commands and their corresponding events.
@@ -96,5 +98,7 @@ export type CommandsMap = {
     FollowTopic: [FollowTopic, EventsMap['TopicFollowed']];
     UnfollowTopic: [UnfollowTopic, EventsMap['TopicUnfollowed']];
     GetFollowedTopics: [GetFollowedTopics, EventsMap['FollowedTopics']];
+    GetMessages: [GetMessages, EventsMap['Messages']];
+    GetTopics: [GetTopics, EventsMap['Topics']];
 };
 export {};

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

@@ -1,17 +1,18 @@
 import { ChatStateTracker } from "./ChatStateTracker";
-import { ChatLocation, Message, FollowedTopic } from "../types/src";
+import { FollowedTopic } from "../types/src";
 import { ObservableIndexedObjectCollection } from "../IndexedObjectCollection";
-export declare const getCombinedId: (location: ChatLocation) => string;
+import { RoomMessagesHistory } from "./RoomMessagesHistory";
 export declare class MessagesManager {
     private tracker;
-    private readonly list;
+    private readonly roomHistories;
     private readonly followedTopics;
     private readonly followedTopicsPromises;
+    private readonly deferredSession;
     constructor(tracker: ChatStateTracker);
     /**
-     * Get collection of the messages written in topic.
+     * Get history manager for given room ID.
      */
-    get(location: ChatLocation): Promise<ObservableIndexedObjectCollection<Message> | undefined>;
+    getRoomHistory(roomId: string): Promise<RoomMessagesHistory | undefined>;
     /**
      * Cache followed topics for all joined rooms in a space and fetch them in bulk if necessary.
      * Then you can get them using getRoomFollowedTopics().
@@ -31,16 +32,13 @@ export declare class MessagesManager {
      * Calculate missed messages from any topic in given room.
      * @return Undefined if you are not in room, stats object otherwise.
      */
-    calculateRoomMissedMessages(roomId: string): Promise<{
-        missed: number;
-        missedMore: boolean;
-    } | undefined>;
+    calculateRoomMissedMessages(roomId: string): Promise<number | undefined>;
     /**
      * For internal use. If you want to delete the message, execute a proper command on client object.
      * @internal
      */
     _deleteByTopicIds(roomId: string, ...topicIds: string[]): void;
-    private createHistoryForNewTopic;
+    private createHistoryForNewRoom;
     private handleNewMessage;
     private handleFollowedTopicUpdated;
     private handleTopicFollowed;

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

@@ -0,0 +1,17 @@
+import { ChatStateTracker } from "./ChatStateTracker";
+import { Room } from "../types/src";
+import { TopicHistoryWindow } from "./TopicHistoryWindow";
+export declare class RoomMessagesHistory {
+    private room;
+    private tracker;
+    private historyWindows;
+    constructor(room: Room, tracker: ChatStateTracker);
+    /**
+     * Returns a history window object for the given topic ID, allowing you to view message history.
+     */
+    getMessagesWindow(topicId: string): Promise<TopicHistoryWindow | undefined>;
+    private handleRoomUpdated;
+    private handleNewTopic;
+    private handleTopicDeleted;
+    private createHistoryWindowForTopic;
+}

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

@@ -10,6 +10,7 @@ export declare class RoomsManager {
     private readonly members;
     private readonly deferredSession;
     private readonly membersPromises;
+    private readonly topicsPromises;
     constructor(tracker: ChatStateTracker);
     /**
      * Get collection of room members.
@@ -24,9 +25,10 @@ export declare class RoomsManager {
      */
     get(): Promise<ObservableIndexedObjectCollection<Room>>;
     /**
-     * Get collection of room topics.
+     * Get a collection of locally cached Topic objects for given room.
+     * You can pass topic ids as second argument, to try to fetch them from the server.
      */
-    getTopics(roomId: string): Promise<ObservableIndexedObjectCollection<Topic> | undefined>;
+    getTopics(roomId: string, tryToFetchTopicIds?: string[]): Promise<ObservableIndexedObjectCollection<Topic> | undefined>;
     private deleteRoom;
     private deleteRoomsBySpaceId;
     private handleSpaceMemberUpdated;

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

@@ -0,0 +1,58 @@
+import { Message, MessageReference } from "../types/src";
+import { ChatStateTracker } from "./ChatStateTracker";
+import { ObservableIndexedObjectCollection } from "../IndexedObjectCollection";
+export declare enum WindowState {
+    UNINITIALIZED = 0,
+    LATEST = 1,
+    PAST = 2
+}
+export declare abstract class TraversableRemoteCollection<T> extends ObservableIndexedObjectCollection<T> {
+    /**
+     * Current mode od collection window. To change mode, call one of available fetch methods.
+     */
+    get state(): WindowState;
+    /**
+     * Maximum numer of items stored in window.
+     * Null for unlimited.
+     */
+    limit: number | null;
+    private currentState;
+    private fetchingState;
+    resetToLatest(): Promise<void>;
+    fetchPrevious(): Promise<void>;
+    fetchNext(): Promise<void>;
+    protected abstract fetchLatestItems(): Promise<T[]>;
+    protected abstract fetchItemsBefore(): Promise<T[] | null>;
+    protected abstract fetchItemsAfter(): Promise<T[] | null>;
+    protected abstract isLatestItemLoaded(): Promise<boolean>;
+    protected refreshMode(): Promise<void>;
+    private throwIfFetchingInProgress;
+    private addItems;
+    /**
+     * Return array with messages of count that matching limit.
+     */
+    private trimItemsArrayToLimit;
+}
+export declare class TopicHistoryWindow extends TraversableRemoteCollection<Message> {
+    private roomId;
+    private topicId;
+    private tracker;
+    /**
+     * Reexported available window modes enum.
+     */
+    readonly WindowState: typeof WindowState;
+    constructor(roomId: string, topicId: string, tracker: ChatStateTracker);
+    /**
+     * For internal use.
+     * @internal
+     */
+    _setTopicReference(ref: MessageReference): void;
+    private handleNewMessage;
+    private handleSession;
+    protected fetchItemsAfter(): Promise<Message[] | null>;
+    protected fetchItemsBefore(): Promise<Message[] | null>;
+    protected fetchLatestItems(): Promise<Message[]>;
+    private getTopic;
+    private getLatestMessageId;
+    protected isLatestItemLoaded(): Promise<boolean>;
+}

package/build/types/types/src/index.d.ts

@@ -1,5 +1,5 @@
 import { Envelope } from "./schemes/Envelope";
-import { Message } from "./schemes/Message";
+import { Message, MessageType } from "./schemes/Message";
 import { PermissionOverwritesValue } from "./schemes/PermissionOverwritesValue";
 import { Role } from "./schemes/Role";
 import { Room } from "./schemes/Room";
@@ -85,4 +85,8 @@ import { TopicUnfollowed } from "./schemes/events/TopicUnfollowed";
 import { TopicFollowed } from "./schemes/events/TopicFollowed";
 import { GetFollowedTopics } from "./schemes/commands/GetFollowedTopics";
 import { FollowedTopicUpdated } from "./schemes/events/FollowedTopicUpdated";
-export { Envelope, Message, Role, Room, RoomType, RoomMember, RoomSummary, Space, SpaceMember, Topic, FollowedTopic, User, UserState, PermissionOverwritesValue, ChatLocation, MessageReference, Bye, Error, NewMessage, NewRole, NewRoom, NewTopic, TopicFollowed, TopicUnfollowed, FollowedTopics, FollowedTopicUpdated, ComputedPermissions, PermissionOverwrites, PermissionOverwritesUpdated, RoleDeleted, RoleUpdated, RoomDeleted, RoomUpdated, RoomJoined, RoomLeft, RoomMemberJoined, RoomMemberLeft, RoomMembers, RoomMemberUpdated, UserUpdated, Session, SpaceDeleted, SpaceUpdated, SpaceJoined, SpaceLeft, SpaceMemberJoined, SpaceMemberLeft, SpaceMembers, SpaceMemberUpdated, SpaceRooms, TopicDeleted, PermissionOverwriteTargets, Owners, Ok, AssignRole, CreateMessage, Ack, CreateRole, CreateRoom, CreateSpace, CreateTopic, FollowTopic, UnfollowTopic, GetFollowedTopics, DeassignRole, DeleteRole, DeleteRoom, DeleteSpace, DeleteTopic, SetPermissionOverwrites, GetPermissionOverwrites, GetComputedPermissions, GetRoomMembers, GetSession, GetSpaceMembers, GetSpaceRooms, JoinRoom, JoinSpace, LeaveRoom, LeaveSpace, UpdateRole, UpdateSpace, UpdateRoom, GetPermissionOverwriteTargets, CreateOwner, DeleteOwner, GetOwners, };
+import { GetMessages } from "./schemes/commands/GetMessages";
+import { Messages } from "./schemes/events/Messages";
+import { Topics } from "./schemes/events/Topics";
+import { GetTopics } from "./schemes/commands/GetTopics";
+export { Envelope, Message, MessageType, Role, Room, RoomType, RoomMember, RoomSummary, Space, SpaceMember, Topic, FollowedTopic, User, UserState, PermissionOverwritesValue, ChatLocation, MessageReference, Bye, Error, Messages, NewMessage, NewRole, NewRoom, NewTopic, TopicFollowed, TopicUnfollowed, FollowedTopics, FollowedTopicUpdated, ComputedPermissions, PermissionOverwrites, PermissionOverwritesUpdated, RoleDeleted, RoleUpdated, RoomDeleted, RoomUpdated, RoomJoined, RoomLeft, RoomMemberJoined, RoomMemberLeft, RoomMembers, RoomMemberUpdated, UserUpdated, Session, SpaceDeleted, SpaceUpdated, SpaceJoined, SpaceLeft, SpaceMemberJoined, SpaceMemberLeft, SpaceMembers, SpaceMemberUpdated, SpaceRooms, TopicDeleted, PermissionOverwriteTargets, Owners, Ok, AssignRole, GetMessages, CreateMessage, Ack, CreateRole, CreateRoom, CreateSpace, CreateTopic, FollowTopic, UnfollowTopic, GetFollowedTopics, DeassignRole, DeleteRole, DeleteRoom, DeleteSpace, DeleteTopic, SetPermissionOverwrites, GetPermissionOverwrites, GetComputedPermissions, GetRoomMembers, GetSession, GetSpaceMembers, GetSpaceRooms, JoinRoom, JoinSpace, LeaveRoom, LeaveSpace, UpdateRole, UpdateSpace, UpdateRoom, GetPermissionOverwriteTargets, CreateOwner, DeleteOwner, GetOwners, Topics, GetTopics, };

package/build/types/types/src/schemes/FollowedTopic.d.ts

@@ -3,5 +3,4 @@ export interface FollowedTopic {
     location: ChatLocation;
     lastAckMessageId: string | null;
     missed: number | null;
-    missedMoreThan: number | null;
 }

package/build/types/types/src/schemes/Message.d.ts

@@ -1,8 +1,14 @@
 import { User } from "./User";
+export declare enum MessageType {
+    Text = "Text",
+    Join = "Join",
+    Leave = "Leave"
+}
 export interface Message {
     id: string;
     createdAt: string;
-    author: User;
-    content: string;
+    type: MessageType;
+    user: User;
+    content?: string;
     topicRef: string | null;
 }

package/{src/types/dist/schemes/commands/Ack.d.ts → build/types/types/src/schemes/commands/GetMessages.d.ts}

@@ -1,5 +1,6 @@
 import { ChatLocation } from "../ChatLocation";
-export interface Ack {
+export interface GetMessages {
     location: ChatLocation;
-    messageId?: string;
+    before?: string;
+    after?: string;
 }

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

@@ -0,0 +1,4 @@
+export interface GetTopics {
+    roomId: string;
+    topicIds: string[];
+}

package/{src/types/dist/schemes/events/NewMessage.d.ts → build/types/types/src/schemes/events/Messages.d.ts}

@@ -1,6 +1,6 @@
-import { Message } from "../Message";
 import { ChatLocation } from "../ChatLocation";
-export interface NewMessage {
+import { Message } from "../Message";
+export interface Messages {
     location: ChatLocation;
-    message: Message;
+    messages: Message[];
 }

package/build/types/types/src/schemes/events/Topics.d.ts

@@ -0,0 +1,6 @@
+import { ChatLocation } from "../ChatLocation";
+import { Topic } from "../Topic";
+export interface Topics {
+    location: ChatLocation;
+    topics: Topic[];
+}

package/package.json

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

package/src/AbstractChatClient.ts

@@ -69,6 +69,10 @@ import {
     FollowTopic,
     UnfollowTopic,
     GetFollowedTopics,
+    Messages,
+    GetMessages,
+    Topics,
+    GetTopics,
 } from "./types/src/index";
 import {EventTarget} from "./EventTarget";
 
@@ -173,6 +177,8 @@ export type EventsMap = {
     TopicUnfollowed: TopicUnfollowed,
     FollowedTopics: FollowedTopics,
     FollowedTopicUpdated: FollowedTopicUpdated,
+    Messages: Messages,
+    Topics: Topics,
 };
 
 /**
@@ -216,4 +222,6 @@ export type CommandsMap = {
     FollowTopic: [FollowTopic, EventsMap['TopicFollowed']],
     UnfollowTopic: [UnfollowTopic, EventsMap['TopicUnfollowed']],
     GetFollowedTopics: [GetFollowedTopics, EventsMap['FollowedTopics']],
+    GetMessages: [GetMessages, EventsMap['Messages']],
+    GetTopics: [GetTopics, EventsMap['Topics']],
 }

package/src/state-tracker/MessagesManager.ts

@@ -1,30 +1,27 @@
 import {ChatStateTracker} from "./ChatStateTracker";
 import {
     ChatLocation,
-    Message,
     NewMessage,
-    Topic,
     FollowedTopic,
     TopicFollowed,
     TopicUnfollowed,
     RoomDeleted,
     RoomLeft,
     TopicDeleted,
-    FollowedTopicUpdated, RoomJoined, NewTopic, Session,
+    FollowedTopicUpdated, RoomJoined, NewTopic, Session, Room,
 } from "../types/src";
 import {
     IndexedCollection,
     ObservableIndexedObjectCollection
 } from "../IndexedObjectCollection";
-import {PromiseRegistry} from "./AsyncUtils";
-
-export const getCombinedId = (location: ChatLocation) => (location.roomId ?? '') + (location.topicId ?? '');
+import {DeferredTask, PromiseRegistry} from "./AsyncUtils";
+import {RoomMessagesHistory} from "./RoomMessagesHistory";
 
 export class MessagesManager {
-    // Temporary not lazy loaded; server must implement GetTopicMessages command.
-    private readonly list = new IndexedCollection<string, ObservableIndexedObjectCollection<Message>>();
+    private readonly roomHistories = new IndexedCollection<string, RoomMessagesHistory>();
     private readonly followedTopics = new IndexedCollection<string, ObservableIndexedObjectCollection<FollowedTopic>>();
     private readonly followedTopicsPromises = new PromiseRegistry();
+    private readonly deferredSession = new DeferredTask();
 
     public constructor(private tracker: ChatStateTracker) {
         this.tracker.client.on('Session', ev => this.handleSession(ev));
@@ -40,10 +37,11 @@ export class MessagesManager {
     }
 
     /**
-     * Get collection of the messages written in topic.
+     * Get history manager for given room ID.
      */
-    public async get(location: ChatLocation): Promise<ObservableIndexedObjectCollection<Message> | undefined> {
-        return this.list.get(getCombinedId(location));
+    public async getRoomHistory(roomId: string): Promise<RoomMessagesHistory | undefined> {
+        await this.deferredSession.promise;
+        return this.roomHistories.get(roomId);
     }
 
     /**
@@ -122,23 +120,17 @@ export class MessagesManager {
      * Calculate missed messages from any topic in given room.
      * @return Undefined if you are not in room, stats object otherwise.
      */
-    public async calculateRoomMissedMessages(roomId: string): Promise<{missed: number, missedMore: boolean} | undefined> {
+    public async calculateRoomMissedMessages(roomId: string): Promise<number | undefined> {
         const collection = await this.getRoomFollowedTopics(roomId);
 
-        if (! collection) {
-            return undefined;
-        }
-
-        let missed: number = 0, missedMore: boolean = false;
-
-        for (const followedTopic of collection.items) {
-            missed += followedTopic.missed ?? followedTopic.missedMoreThan ?? 0;
-            if (followedTopic.missedMoreThan) {
-                missedMore = true;
-            }
+        if (collection) {
+            return collection.items.reduce(
+                (previousValue, currentValue) => previousValue + (currentValue.missed ?? 0),
+                0,
+            );
         }
 
-        return {missed, missedMore};
+        return undefined;
     }
 
     /**
@@ -146,32 +138,14 @@ export class MessagesManager {
      * @internal
      */
     public _deleteByTopicIds(roomId: string, ...topicIds: string[]): void {
-        this.list.delete(...topicIds.map(topicId => getCombinedId({roomId, topicId})));
         this.followedTopics.get(roomId)?.delete(...topicIds);
     }
 
-    private createHistoryForNewTopic(roomId: string, ...newTopics: Topic[]): void {
-        for (const newTopic of newTopics) {
-            const newTopicCombinedId = getCombinedId({roomId, topicId: newTopic.id});
-
-            this.list.set([newTopicCombinedId, new ObservableIndexedObjectCollection<Message>('id')]);
-
-            // If new topic refers to some message from this room, update other structures
-            if (newTopic.messageRef) {
-                const refTopicCombinedId = getCombinedId({roomId, topicId: newTopic.messageRef.topicId});
-                const refTopicMessages = this.list.get(refTopicCombinedId);
-                const refMessage = refTopicMessages?.get(newTopic.messageRef.messageId);
-
-                if (refMessage) {
-                    // Update referenced topic ID in message
-                    refTopicMessages.set({...refMessage, topicRef: newTopic.id});
-                }
-            }
-        }
+    private createHistoryForNewRoom(room: Room): void {
+        this.roomHistories.set([room.id, new RoomMessagesHistory(room, this.tracker)]);
     }
 
     private handleNewMessage(ev: NewMessage): void {
-        this.list.get(getCombinedId(ev.location))?.set(ev.message);
         this.updateLocallyFollowedTopicOnNewMessage(ev);
     }
 
@@ -188,23 +162,21 @@ export class MessagesManager {
     }
 
     private handleRoomDeleted(ev: RoomDeleted): void {
+        this.roomHistories.delete(ev.id);
         this.clearRoomFollowedTopicsStructures(ev.id);
     }
 
     private handleRoomJoin(ev: RoomJoined): void {
-        if (ev.room.defaultTopic) {
-            this.createHistoryForNewTopic(ev.room.id, ev.room.defaultTopic)
-        }
+        this.createHistoryForNewRoom(ev.room)
         this.clearRoomFollowedTopicsStructures(ev.room.id);
     }
 
     private handleRoomLeft(ev: RoomLeft): void {
+        this.roomHistories.delete(ev.id);
         this.clearRoomFollowedTopicsStructures(ev.id);
     }
 
     private async handleNewTopic(ev: NewTopic): Promise<void> {
-        this.createHistoryForNewTopic(ev.roomId, ev.topic);
-
         if (this.followedTopics.has(ev.roomId)) {
             // Check if the new topic is followed by user
             // only if client asked for followed topics list before for this room
@@ -224,11 +196,10 @@ export class MessagesManager {
     }
 
     private handleSession(ev: Session): void {
-        ev.state.rooms.forEach(room => {
-            if (room.defaultTopic) {
-                this.createHistoryForNewTopic(room.id, room.defaultTopic);
-            }
-        });
+        this.followedTopics.deleteAll();
+        this.roomHistories.deleteAll();
+        ev.state.rooms.forEach(room => this.createHistoryForNewRoom(room));
+        this.deferredSession.resolve();
     }
 
     private updateLocallyFollowedTopicOnNewMessage(ev: NewMessage): void {
@@ -240,19 +211,16 @@ export class MessagesManager {
             return;
         }
 
-        const isMe = ev.message.author.id === this.tracker.me?.id;
+        const isMe = ev.message.user.id === this.tracker.me?.id;
 
         let update: Partial<FollowedTopic>;
 
         if (isMe) {
             // Reset missed messages count if new message is authored by me
-            update = {missed: 0, missedMoreThan: null, lastAckMessageId: ev.message.id};
+            update = {missed: 0, lastAckMessageId: ev.message.id};
         } else {
             // ...add 1 otherwise
-            update = {
-                missed: followedTopic.missed === null ? null : followedTopic.missed + 1,
-                missedMoreThan: followedTopic.missedMoreThan === null ? null : followedTopic.missedMoreThan,
-            };
+            update = {missed: followedTopic.missed === null ? null : followedTopic.missed + 1};
         }
 
         roomFollowedTopics.set({...followedTopic, ...update});

package/src/state-tracker/RoomMessagesHistory.ts

@@ -0,0 +1,78 @@
+import {ChatStateTracker} from "./ChatStateTracker";
+import {NewTopic, Room, RoomUpdated, Topic, TopicDeleted} from "../types/src";
+import {IndexedCollection,} from "../IndexedObjectCollection";
+import {TopicHistoryWindow} from "./TopicHistoryWindow";
+
+export class RoomMessagesHistory {
+    private historyWindows = new IndexedCollection<string, TopicHistoryWindow>();
+
+    public constructor(
+        private room: Room,
+        private tracker: ChatStateTracker,
+    ) {
+        this.tracker.client.on('RoomUpdated', ev => this.handleRoomUpdated(ev));
+        this.tracker.client.on('NewTopic', ev => this.handleNewTopic(ev));
+        this.tracker.client.on('TopicDeleted', ev => this.handleTopicDeleted(ev));
+
+        if (this.room.defaultTopic) {
+            this.createHistoryWindowForTopic(this.room.defaultTopic);
+        }
+    }
+
+    /**
+     * Returns a history window object for the given topic ID, allowing you to view message history.
+     */
+    public async getMessagesWindow(topicId: string): Promise<TopicHistoryWindow | undefined> {
+        let historyWindow = this.historyWindows.get(topicId);
+
+        if (! historyWindow) {
+            const topic = (await this.tracker.rooms.getTopics(this.room.id, [topicId])).get(topicId);
+
+            if (topic) {
+                this.createHistoryWindowForTopic(topic);
+            }
+        }
+
+        return this.historyWindows.get(topicId);
+    }
+
+    private handleRoomUpdated(ev: RoomUpdated): void {
+        if (this.room.id === ev.room.id) {
+            this.room = ev.room;
+
+            if (ev.room.defaultTopic) {
+                this.createHistoryWindowForTopic(ev.room.defaultTopic);
+            }
+        }
+    }
+
+    private handleNewTopic(ev: NewTopic): void {
+        if (this.room.id === ev.roomId) {
+            this.createHistoryWindowForTopic(ev.topic);
+        }
+    }
+
+    private handleTopicDeleted(ev: TopicDeleted): void {
+        if (this.room.id === ev.location.roomId) {
+            this.historyWindows.delete(ev.location.topicId);
+        }
+    }
+
+    private createHistoryWindowForTopic(topic: Topic): void {
+        if (this.historyWindows.has(topic.id)) {
+            return;
+        }
+
+        this.historyWindows.set([topic.id, new TopicHistoryWindow(this.room.id, topic.id, this.tracker)]);
+
+        // If new topic refers to some message from this room, update other structures
+        if (topic.messageRef) {
+            const refHistoryWindow = this.historyWindows.get(topic.messageRef.topicId);
+
+            refHistoryWindow._setTopicReference({
+                topicId: topic.id, // Reverse the reference
+                messageId: topic.messageRef.messageId,
+            });
+        }
+    }
+}

package/src/state-tracker/RoomsManager.ts

@@ -23,6 +23,7 @@ export class RoomsManager {
     private readonly members = new IndexedCollection<string, ObservableIndexedObjectCollection<RoomMember>>();
     private readonly deferredSession = new DeferredTask();
     private readonly membersPromises = new PromiseRegistry();
+    private readonly topicsPromises = new PromiseRegistry();
 
     public constructor(private tracker: ChatStateTracker) {
         this.messages = new MessagesManager(tracker);
@@ -88,10 +89,31 @@ export class RoomsManager {
     }
 
     /**
-     * Get collection of room topics.
+     * Get a collection of locally cached Topic objects for given room.
+     * You can pass topic ids as second argument, to try to fetch them from the server.
      */
-    public async getTopics(roomId: string): Promise<ObservableIndexedObjectCollection<Topic> | undefined> {
+    public async getTopics(roomId: string, tryToFetchTopicIds?: string[]): Promise<ObservableIndexedObjectCollection<Topic> | undefined> {
         await this.deferredSession.promise;
+
+        if (tryToFetchTopicIds?.length) {
+            // Topic can be fetched if it isn't already cached and fetch is not already in progress
+            const canFetch = (topicId: string) => ! this.topics.get(roomId)?.has(topicId) && ! this.topicsPromises.has(roomId + topicId);
+            const idsToFetch = tryToFetchTopicIds.filter(canFetch);
+
+            if (idsToFetch.length) {
+                const promise = this.tracker
+                    .client
+                    .send('GetTopics', {roomId, topicIds: idsToFetch})
+                    .then(result => this.topics.get(result.data.location.roomId)?.set(...result.data.topics));
+
+                idsToFetch.forEach(topicId => this.topicsPromises.register(promise, roomId + topicId));
+            }
+
+            for (const topicId of tryToFetchTopicIds) {
+                await this.topicsPromises.get(roomId + topicId);
+            }
+        }
+
         return this.topics.get(roomId);
     }