polfan-server-js-client 0.3.3 → 0.4.1

package/src/state-tracker/ChatStateTracker.ts

@@ -1,72 +1,72 @@
-import {WebSocketChatClient} from "../WebSocketChatClient";
-import {Session, User} from "../types/src";
-import {RoomsManager} from "./RoomsManager";
-import {SpacesManager} from "./SpacesManager";
-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: PermissionsManager;
-
-    /**
-     * State of the rooms you are in.
-     */
-    public readonly rooms: RoomsManager;
-
-    /**
-     * State of the spaces you are in.
-     */
-    public readonly spaces: SpacesManager;
-
-    /**
-     * State of the emoticons (global and space-related).
-     */
-    public readonly emoticons: EmoticonsManager;
-
-    /**
-     * Users related state.
-     */
-    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(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 {
-        return this._me;
-    }
-
-    public async getMe(): Promise<User> {
-        await this.deferredSession.promise;
-        return this._me;
-    }
-
-    private handleSession(ev: Session): void {
-        this._me = ev.user;
-        this.deferredSession.resolve();
-    }
+import {WebSocketChatClient} from "../WebSocketChatClient";
+import {Session, User} from "../types/src";
+import {RoomsManager} from "./RoomsManager";
+import {SpacesManager} from "./SpacesManager";
+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: PermissionsManager;
+
+    /**
+     * State of the rooms you are in.
+     */
+    public readonly rooms: RoomsManager;
+
+    /**
+     * State of the spaces you are in.
+     */
+    public readonly spaces: SpacesManager;
+
+    /**
+     * State of the emoticons (global and space-related).
+     */
+    public readonly emoticons: EmoticonsManager;
+
+    /**
+     * Users related state.
+     */
+    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(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 {
+        return this._me;
+    }
+
+    public async getMe(): Promise<User> {
+        await this.deferredSession.promise;
+        return this._me;
+    }
+
+    private handleSession(ev: Session): void {
+        this._me = ev.user;
+        this.deferredSession.resolve();
+    }
 }

package/src/state-tracker/RoomMessagesHistory.ts

@@ -6,7 +6,6 @@ import {TopicHistoryWindow, WindowState} from "./TopicHistoryWindow";
 export class RoomMessagesHistory {
     private historyWindows = new IndexedCollection<string, TopicHistoryWindow>();
     private traverseLock: boolean = false;
-    private timeLimitedHistory: boolean = false;
 
     public constructor(
         private room: Room,
@@ -16,7 +15,7 @@ export class RoomMessagesHistory {
         this.tracker.client.on('NewTopic', ev => this.handleNewTopic(ev));
         this.tracker.client.on('TopicDeleted', ev => this.handleTopicDeleted(ev));
 
-        this.updateHistoryMode(this.room);
+        this.updateTraverseLock(this.room);
 
         if (this.room.defaultTopic) {
             this.createHistoryWindowForTopic(this.room.defaultTopic);
@@ -47,23 +46,13 @@ export class RoomMessagesHistory {
      *
      * The window bindings are preserved; only windows that the application had
      * actually pulled to the latest page (state === LATEST) are refreshed, with
-     * a single request instead of a chain of catch-up requests. Windows that
-     * were never pulled (LIVE) or belong to an ephemeral room are left untouched
-     * so their in-memory context survives the reconnect.
-     *
-     * How a refreshed window is rebuilt depends on the room history mode: rooms
-     * keeping the full history are simply reset to the latest page (it can
-     * always be traversed back on demand), while rooms with a time-limited
-     * history (MaxAge) load the messages missed during the downtime on top of
-     * the already loaded ones, with the messages returned in both deduplicated.
-     * The maxAge retention applies to what the server serves - so that users
-     * joining later do not see the older conversation - and never to what this
-     * client already has: messages the user witnessed stay in the window until
-     * they are pushed out by its own size limit.
+     * a single resetToLatest instead of a chain of catch-up requests. Windows
+     * that were never pulled (LIVE) or belong to an ephemeral room are left
+     * untouched so their in-memory context survives the reconnect.
      */
     public async resync(room: Room): Promise<void> {
         this.room = room;
-        this.updateHistoryMode(room);
+        this.updateTraverseLock(room);
 
         if (this.room.defaultTopic) {
             this.createHistoryWindowForTopic(this.room.defaultTopic);
@@ -79,13 +68,7 @@ export class RoomMessagesHistory {
                     continue;
                 }
 
-                if (window.state !== WindowState.LATEST) {
-                    continue;
-                }
-
-                if (this.timeLimitedHistory) {
-                    await window.resyncToLatest();
-                } else {
+                if (window.state === WindowState.LATEST) {
                     await window.resetToLatest(true);
                 }
             } catch (_e) {
@@ -100,7 +83,7 @@ export class RoomMessagesHistory {
         if (this.room.id === ev.room.id) {
             this.room = ev.room;
 
-            this.updateHistoryMode(ev.room);
+            this.updateTraverseLock(ev.room);
 
             if (ev.room.defaultTopic) {
                 this.createHistoryWindowForTopic(ev.room.defaultTopic);
@@ -151,8 +134,7 @@ export class RoomMessagesHistory {
         }
     }
 
-    private updateHistoryMode(room: Room): void {
-        this.traverseLock = room.history?.mode === 'Ephemeral';
-        this.timeLimitedHistory = room.history?.mode === 'MaxAge';
+    private updateTraverseLock(room: Room): void {
+        this.traverseLock = room.history.mode === 'Ephemeral';
     }
 }

package/src/state-tracker/TopicHistoryWindow.ts

@@ -45,7 +45,6 @@ export abstract class TraversableRemoteCollection<
         fetchLimit: number,
         lastFetchCount: number,
         oldestId: string | null,
-        gaps: string[],
     } = {
         current: WindowState.LIVE,
         ongoing: undefined,
@@ -54,7 +53,6 @@ export abstract class TraversableRemoteCollection<
         fetchLimit: 50,
         lastFetchCount: 0,
         oldestId: null,
-        gaps: [],
     };
 
     /**
@@ -105,21 +103,6 @@ export abstract class TraversableRemoteCollection<
         return [WindowState.LATEST, WindowState.LIVE].includes(this.state);
     }
 
-    /**
-     * IDs of the items the window could not stitch to the ones loaded before
-     * them: there is a gap in front of each of them, i.e. the item right above
-     * it in the window is not its real predecessor and an unknown number of
-     * items in between was never fetched.
-     *
-     * Such a gap appears when the collection is resynchronised after a
-     * reconnect (see resyncToLatest) and more items than a single page arrived
-     * while the connection was down. The markers are kept in the window order
-     * and disappear together with the items they point at.
-     */
-    public get gaps(): readonly string[] {
-        return [...this.internalState.gaps];
-    }
-
     public get hasOldest(): boolean {
         return this.state === WindowState.OLDEST
             || this.state === WindowState.LATEST && this.length < this.fetchLimit
@@ -145,68 +128,11 @@ export abstract class TraversableRemoteCollection<
         }
 
         this._items.deleteAll(); // Directly call deleteAll to prevent event emit.
-        this.internalState.gaps = []; // Whole content is replaced, old markers mean nothing.
         this.addItems(result, 'tail');
         this.internalState.current = WindowState.LATEST;
         this.emitChangeWithDiff(true, originalState);
     }
 
-    /**
-     * Refresh the window with the latest page, keeping the already loaded items
-     * instead of replacing them.
-     *
-     * This is the reconnect-friendly variant of resetToLatest: the items missed
-     * while the connection was down are pulled with a single request and merged
-     * on top of the loaded ones (items returned in both are deduplicated), so
-     * the context the application already had does not disappear. The window
-     * size limit is the only thing that pushes the oldest items out.
-     *
-     * An empty or partial page is not a reason to drop anything: it only means
-     * the collection has little (or nothing) left on the remote side, while the
-     * items loaded earlier are still valid. When the page is full and does not
-     * reach the loaded items, an unknown number of items in between was never
-     * fetched - both parts are still kept, and the seam between them is recorded
-     * in `gaps` so the application can show where the history is not continuous.
-     */
-    public async resyncToLatest(): Promise<void> {
-        if (this.internalState.ongoing) {
-            return;
-        }
-
-        let result;
-        const originalState = this.state;
-        this.internalState.ongoing = WindowState.LATEST;
-
-        try {
-            result = await this.fetchLatestItems();
-            this.internalState.lastFetchCount = result.length;
-        } finally {
-            this.internalState.ongoing = undefined;
-        }
-
-        const loaded = this.items;
-        const fetchedIds = new Set(result.map(item => this.getId(item)));
-        // Items present in the page are taken from it - the server copy is the
-        // up-to-date one.
-        const retained = loaded.filter(item => ! fetchedIds.has(this.getId(item)));
-
-        // Nothing can be missing in between when there is nothing to stitch,
-        // when the page is everything the remote side has (it is shorter than
-        // the requested limit), or when the page reaches the newest loaded item.
-        const isContinuous = ! retained.length
-            || result.length < this.internalState.fetchLimit
-            || fetchedIds.has(this.getId(loaded[loaded.length - 1]));
-
-        if (! isContinuous) {
-            this.markGapBefore(this.getId(result[0]));
-        }
-
-        this._items.deleteAll(); // Directly call deleteAll to prevent event emit.
-        this.addItems([...retained, ...result], 'tail');
-        this.internalState.current = WindowState.LATEST;
-        this.emitChangeWithDiff(true, originalState);
-    }
-
     public async fetchPrevious(): Promise<void> {
         if (this.internalState.ongoing || this.hasOldest) {
             return;
@@ -214,7 +140,6 @@ export abstract class TraversableRemoteCollection<
 
         let result;
         const originalState = this.state;
-        const firstItem = this.getAt(0);
         this.internalState.ongoing = WindowState.PAST;
 
         try {
@@ -229,6 +154,7 @@ export abstract class TraversableRemoteCollection<
         }
 
         if (! result.length) {
+            const firstItem = this.getAt(0);
             this.internalState.oldestId = firstItem ? this.getId(firstItem) : null;
 
             await this.refreshFetchedState();
@@ -242,13 +168,6 @@ export abstract class TraversableRemoteCollection<
             return;
         }
 
-        if (firstItem) {
-            // The fetch asked for the items right before the one that was first,
-            // so whatever came back is its real predecessor: a gap marked in
-            // front of it (it used to be the top of the window) is closed now.
-            this.clearGapBefore(this.getId(firstItem));
-        }
-
         this.addItems(result, 'head');
         await this.refreshFetchedState();
         this.emitChangeWithDiff(true, originalState);
@@ -298,7 +217,6 @@ export abstract class TraversableRemoteCollection<
 
             if (result) {
                 this._items.deleteAll(); // Directly call deleteAll to prevent event emit.
-                this.internalState.gaps = []; // Whole content is replaced, old markers mean nothing.
                 this.addItems(result, 'tail');
                 await this.refreshFetchedState();
             }
@@ -309,16 +227,6 @@ export abstract class TraversableRemoteCollection<
         this.emitChangeWithDiff(!!result, originalState);
     }
 
-    public delete(...ids: string[]): void {
-        super.delete(...ids);
-        this.dropDanglingGaps();
-    }
-
-    public deleteAll(): void {
-        super.deleteAll();
-        this.internalState.gaps = [];
-    }
-
     protected abstract fetchLatestItems(): Promise<ItemT[]>;
 
     protected abstract fetchItemsBefore(): Promise<ItemT[] | null>;
@@ -347,8 +255,6 @@ export abstract class TraversableRemoteCollection<
         // Directly calls to prevent event emit.
         this._items.deleteAll();
         this._items.set(...(result.map(item => [this.getId(item), item] as [string, ItemT])));
-
-        this.dropDanglingGaps();
     }
 
     protected emitChangeWithDiff(itemChanged: boolean, originalState: WindowState): void {
@@ -357,37 +263,6 @@ export abstract class TraversableRemoteCollection<
         }
     }
 
-    /**
-     * Record that the history is not continuous in front of the given item.
-     */
-    protected markGapBefore(id: string): void {
-        if (! this.internalState.gaps.includes(id)) {
-            this.internalState.gaps = [...this.internalState.gaps, id];
-        }
-    }
-
-    /**
-     * Forget the gap in front of the given item - the items before it are known
-     * to be its real predecessors now.
-     */
-    protected clearGapBefore(id: string): void {
-        if (this.internalState.gaps.includes(id)) {
-            this.internalState.gaps = this.internalState.gaps.filter(gapId => gapId !== id);
-        }
-    }
-
-    /**
-     * Forget the gap markers pointing at items that are no longer in the window
-     * (trimmed, deleted or replaced), so `gaps` never refers to nothing.
-     */
-    protected dropDanglingGaps(): void {
-        if (! this.internalState.gaps.length) {
-            return;
-        }
-
-        this.internalState.gaps = this.internalState.gaps.filter(id => this.has(id));
-    }
-
     /**
      * Return array with messages trimmed using High/Low Watermark strategy.
      */
@@ -472,13 +347,6 @@ export class TopicHistoryWindow extends TraversableRemoteCollection<
         return super.resetToLatest(force);
     }
 
-    public async resyncToLatest(): Promise<void> {
-        if (this.internalState.traverseLock) {
-            return;
-        }
-        return super.resyncToLatest();
-    }
-
     public async fetchNext(): Promise<void> {
         if (this.internalState.traverseLock) {
             return;

package/src/state-tracker/UsersManager.ts

@@ -42,7 +42,7 @@ export class UsersManager {
     private handleUsers(users: User[]): void {
         users.forEach(newUser => {
             const oldUser = this.users.get(newUser.id);
-            if (oldUser && oldUser.online !== newUser.online) {
+            if (oldUser && oldUser.status !== newUser.status) {
                 this.onlineStatus.emit('change', newUser);
             }
         });

package/src/state-tracker/functions.ts

@@ -1,29 +1,29 @@
-import {Role, RoomMember, SpaceMember, User} from "../types/src";
-
-export function reorderRolesOnPriorityUpdate(allRoles: Role[], oldRole: Role, updatedRole: Role): Role[] {
-    // If the priority has changed, adjust the rest of roles
-    const increased = (updatedRole.priority - oldRole.priority) > 0;
-    const decreased = ! increased;
-    const changedRoles: Role[] = [];
-
-    allRoles.forEach(role => {
-        if (role.id === updatedRole.id) {
-            // Skip the updated role
-            return;
-        }
-        if (increased && oldRole.priority <= role.priority) {
-            role.priority--;
-            changedRoles.push(role);
-        }
-        if (decreased && updatedRole.priority <= role.priority) {
-            role.priority++;
-            changedRoles.push(role);
-        }
-    });
-
-    return changedRoles;
-}
-
-export function extractUserFromMember(member: RoomMember | SpaceMember): User | null {
-    return member.user ?? (member as RoomMember).spaceMember?.user;
+import {Role, RoomMember, SpaceMember, User} from "../types/src";
+
+export function reorderRolesOnPriorityUpdate(allRoles: Role[], oldRole: Role, updatedRole: Role): Role[] {
+    // If the priority has changed, adjust the rest of roles
+    const increased = (updatedRole.priority - oldRole.priority) > 0;
+    const decreased = ! increased;
+    const changedRoles: Role[] = [];
+
+    allRoles.forEach(role => {
+        if (role.id === updatedRole.id) {
+            // Skip the updated role
+            return;
+        }
+        if (increased && oldRole.priority <= role.priority) {
+            role.priority--;
+            changedRoles.push(role);
+        }
+        if (decreased && updatedRole.priority <= role.priority) {
+            role.priority++;
+            changedRoles.push(role);
+        }
+    });
+
+    return changedRoles;
+}
+
+export function extractUserFromMember(member: RoomMember | SpaceMember): User | null {
+    return member.user ?? (member as RoomMember).spaceMember?.user;
 }

package/src/types/src/index.ts

@@ -8,7 +8,7 @@ import {RoomSummary, RoomSummaryExtras} from "./schemes/RoomSummary";
 import {Space, SpaceDiscoverable} from "./schemes/Space";
 import {SpaceMember} from "./schemes/SpaceMember";
 import {Topic} from "./schemes/Topic";
-import {User} from "./schemes/User";
+import {User, UserStatus} from "./schemes/User";
 import {UserState} from "./schemes/UserState";
 import {Bye} from "./schemes/events/Bye";
 import {Error} from "./schemes/events/Error";
@@ -134,7 +134,7 @@ import {GetUserInfo} from "./schemes/commands/GetUserInfo";
 import {UserInfo} from "./schemes/events/UserInfo";
 import {UserInformation} from "./schemes/UserInformation";
 import {SetSessionData, SessionPush} from "./schemes/commands/SetSessionData";
-import {SessionData} from "./schemes/SessionData";
+import {SessionData, SessionPlatform} from "./schemes/SessionData";
 import {GetSessionData} from "./schemes/commands/GetSessionData";
 import {UserData, PrivateMessagePolicy} from "./schemes/UserData";
 import {SetUserData} from "./schemes/commands/SetUserData";
@@ -145,6 +145,14 @@ import {Uninvite} from "./schemes/commands/Uninvite";
 import {GetInvited} from "./schemes/commands/GetInvited";
 import {Invited} from "./schemes/events/Invited";
 import {TopicUnfollowed} from "./schemes/events/TopicUnfollowed";
+import {MessageReaction, ReactionType, ToggledReaction, UserReaction} from "./schemes/Reaction";
+import {MessagePoll, MessagePollOption} from "./schemes/MessagePoll";
+import {React} from "./schemes/commands/React";
+import {Unreact} from "./schemes/commands/Unreact";
+import {GetReactionDetails} from "./schemes/commands/GetReactionDetails";
+import {ReactionUpdated} from "./schemes/events/ReactionUpdated";
+import {Reacted} from "./schemes/events/Reacted";
+import {ReactionDetails} from "./schemes/events/ReactionDetails";
 
 export {
     // objects
@@ -168,6 +176,7 @@ export {
     FollowedTopic,
     NotificationLevel,
     User,
+    UserStatus,
     UserState,
     PermissionOverwritesValue,
     ChatLocation,
@@ -183,8 +192,15 @@ export {
     UserInformation,
     SessionPush,
     SessionData,
+    SessionPlatform,
     UserData,
     PrivateMessagePolicy,
+    ReactionType,
+    MessageReaction,
+    UserReaction,
+    ToggledReaction,
+    MessagePoll,
+    MessagePollOption,
     // events
     Bye,
     Error,
@@ -242,6 +258,9 @@ export {
     MessagesRedacted,
     UserInfo,
     Invited,
+    ReactionUpdated,
+    Reacted,
+    ReactionDetails,
     // commands
     AssignRole,
     GetMessages,
@@ -309,4 +328,7 @@ export {
     Invite,
     Uninvite,
     GetInvited,
+    React,
+    Unreact,
+    GetReactionDetails,
 };

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

@@ -1,7 +1,9 @@
 import {User} from "./User";
 import {ChatLocation} from "./ChatLocation";
+import {MessageReaction} from "./Reaction";
+import {MessagePoll} from "./MessagePoll";
 
-export type MessageType = 'Text'|'RoomJoin'|'RoomMemberAdd'|'RoomLeave'|'SpaceJoin'|'SpaceLeave'|'TopicChange'|'CustomNickChange'|'Ephemeral';
+export type MessageType = 'Text'|'RoomJoin'|'RoomMemberAdd'|'RoomLeave'|'SpaceJoin'|'SpaceLeave'|'TopicChange'|'CustomNickChange'|'Ephemeral'|'Poll';
 
 export interface MessageAuthor {
     user: User;
@@ -18,4 +20,6 @@ export interface Message {
     content?: string;
     topicRef: string | null;
     attachments: string[] | null;
+    reactions: MessageReaction[];
+    poll?: MessagePoll;
 }

package/src/types/src/schemes/MessagePoll.ts

@@ -0,0 +1,12 @@
+import {ReactionType} from "./Reaction";
+
+export interface MessagePollOption {
+    type: ReactionType;
+    value: string;
+    label: string;
+}
+
+export interface MessagePoll {
+    multipleChoice: boolean;
+    options: MessagePollOption[];
+}

package/src/types/src/schemes/Reaction.ts

@@ -0,0 +1,16 @@
+export type ReactionType = 'Emoji' | 'Emoticon';
+
+export interface MessageReaction {
+    type: ReactionType;
+    value: string;
+    count: number;
+}
+
+export interface UserReaction {
+    type: ReactionType;
+    value: string;
+}
+
+export interface ToggledReaction extends UserReaction {
+    isAdded: boolean;
+}

package/src/types/src/schemes/SessionData.ts

@@ -1,5 +1,12 @@
 import {SessionPush} from "./commands/SetSessionData";
 
+/**
+ * Platform of a client session. Reported on connect (the `platform` query
+ * parameter) and independent of the push registration.
+ */
+export type SessionPlatform = 'web' | 'ios' | 'android' | 'desktop';
+
 export interface SessionData {
+    platform?: SessionPlatform;
     push?: SessionPush;
-}
+}

package/src/types/src/schemes/User.ts

@@ -1,9 +1,25 @@
 export type UserTags = 'bot' | 'temp' | string;
 
+/**
+ * Availability of a user, aggregated over all of their sessions.
+ *
+ * - `Offline` - no session is connected and none can be reached asynchronously.
+ * - `Online` - at least one session holds a live connection.
+ * - `OnlineAsync` - no live connection, but a push-registered device was active
+ *   recently, so a message will still reach the user.
+ */
+export enum UserStatus {
+    Offline = 0,
+    Online = 1,
+    OnlineAsync = 2,
+}
+
 export interface User {
     id: string;
     nick: string;
     avatar: string;
     tags: UserTags[];
+    status: UserStatus;
+    /** @deprecated Use {@link status}. Kept for clients older than the numeric status. */
     online: boolean;
-}
+}