polfan-server-js-client 0.1.99922 → 0.1.99924

package/src/WebSocketChatClient.ts

@@ -1,132 +1,132 @@
-import {ObservableInterface} from "./EventTarget";
-import {AbstractChatClient, CommandResult, CommandsMap} from "./AbstractChatClient";
-import {ChatStateTracker} from "./state-tracker/ChatStateTracker";
-import {Envelope} from "./types/src";
-
-export interface WebSocketClientOptions {
-    url: string;
-    token?: string;
-    temporaryNick?: string;
-    connectingTimeoutMs?: number;
-    awaitQueueSendDelayMs?: number;
-    stateTracking?: boolean;
-}
-
-enum WebSocketChatClientEvent {
-    connect = 'connect',
-    disconnect = 'disconnect',
-    message = 'message',
-    error = 'error',
-}
-
-export class WebSocketChatClient extends AbstractChatClient implements ObservableInterface {
-    public readonly Event = WebSocketChatClientEvent;
-    public readonly state?: ChatStateTracker;
-
-    protected ws: WebSocket|null = null;
-    protected sendQueue: Envelope[] = [];
-    protected connectingTimeoutId: any;
-    protected authenticated: boolean;
-    protected authenticatedResolvers: [() => void, (error: Error) => void];
-
-    public constructor(private readonly options: WebSocketClientOptions) {
-        super();
-        if (!this.options.token && !this.options.temporaryNick) {
-            throw new Error('Token or temporary nick is required');
-        }
-        if (this.options.stateTracking ?? true) {
-            this.state = new ChatStateTracker(this);
-        }
-    }
-
-    public async connect(): Promise<void> {
-        const authString = this.options.token ? `token=${this.options.token}` : `nick=${this.options.temporaryNick}`;
-        this.ws = new WebSocket(`${this.options.url}?${authString}`);
-        this.ws.onclose = ev => this.onClose(ev);
-        this.ws.onmessage = ev => this.onMessage(ev);
-        this.connectingTimeoutId = setTimeout(
-            () => this.triggerConnectionTimeout(),
-            this.options.connectingTimeoutMs ?? 10000
-        );
-        this.authenticated = false;
-        return new Promise((...args) => this.authenticatedResolvers = args);
-    }
-
-    public disconnect(): void {
-        this.sendQueue = [];
-        this.ws?.close();
-        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) {
-            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;
-    }
-
-    private sendEnvelope(envelope: Envelope): void {
-        this.ws.send(JSON.stringify(envelope));
-    }
-
-    private onMessage(event: MessageEvent): void {
-        const envelope: Envelope = JSON.parse(event.data);
-        this.handleIncomingEnvelope(envelope);
-        this.emit(envelope.type, envelope.data);
-        this.emit(this.Event.message, envelope);
-
-        // Login successfully
-        if (!this.authenticated) {
-            const isAuthenticated = envelope.type !== 'Error';
-            this.authenticated = isAuthenticated;
-            if (isAuthenticated) {
-                this.authenticatedResolvers[0]();
-                this.emit(this.Event.connect);
-                this.sendFromQueue();
-            } else {
-                this.authenticatedResolvers[1](envelope.data);
-            }
-        }
-    }
-
-    private onClose(event: CloseEvent): void {
-        clearTimeout(this.connectingTimeoutId);
-        const reconnect = event.code !== 1000; // Connection was closed because of error
-        if (reconnect) {
-            this.connect();
-        }
-        this.emit(this.Event.disconnect, reconnect);
-    }
-
-    private sendFromQueue(): void {
-        // Send awaiting data to server
-        let lastDelay = 0;
-        for (const dataIndex in this.sendQueue) {
-            const envelope = this.sendQueue[dataIndex];
-            setTimeout(() => this.sendEnvelope(envelope), lastDelay);
-            lastDelay += this.options.awaitQueueSendDelayMs ?? 500;
-        }
-        this.sendQueue = [];
-        clearTimeout(this.connectingTimeoutId);
-    }
-
-    private triggerConnectionTimeout(): void {
-        this.disconnect();
-        this.emit(this.Event.error, new Error('Connection timeout'));
-    }
+import {ObservableInterface} from "./EventTarget";
+import {AbstractChatClient, CommandResult, CommandsMap} from "./AbstractChatClient";
+import {ChatStateTracker} from "./state-tracker/ChatStateTracker";
+import {Envelope} from "./types/src";
+
+export interface WebSocketClientOptions {
+    url: string;
+    token?: string;
+    temporaryNick?: string;
+    connectingTimeoutMs?: number;
+    awaitQueueSendDelayMs?: number;
+    stateTracking?: boolean;
+}
+
+enum WebSocketChatClientEvent {
+    connect = 'connect',
+    disconnect = 'disconnect',
+    message = 'message',
+    error = 'error',
+}
+
+export class WebSocketChatClient extends AbstractChatClient implements ObservableInterface {
+    public readonly Event = WebSocketChatClientEvent;
+    public readonly state?: ChatStateTracker;
+
+    protected ws: WebSocket|null = null;
+    protected sendQueue: Envelope[] = [];
+    protected connectingTimeoutId: any;
+    protected authenticated: boolean;
+    protected authenticatedResolvers: [() => void, (error: Error) => void];
+
+    public constructor(private readonly options: WebSocketClientOptions) {
+        super();
+        if (!this.options.token && !this.options.temporaryNick) {
+            throw new Error('Token or temporary nick is required');
+        }
+        if (this.options.stateTracking ?? true) {
+            this.state = new ChatStateTracker(this);
+        }
+    }
+
+    public async connect(): Promise<void> {
+        const authString = this.options.token ? `token=${this.options.token}` : `nick=${this.options.temporaryNick}`;
+        this.ws = new WebSocket(`${this.options.url}?${authString}`);
+        this.ws.onclose = ev => this.onClose(ev);
+        this.ws.onmessage = ev => this.onMessage(ev);
+        this.connectingTimeoutId = setTimeout(
+            () => this.triggerConnectionTimeout(),
+            this.options.connectingTimeoutMs ?? 10000
+        );
+        this.authenticated = false;
+        return new Promise((...args) => this.authenticatedResolvers = args);
+    }
+
+    public disconnect(): void {
+        this.sendQueue = [];
+        this.ws?.close();
+        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) {
+            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;
+    }
+
+    private sendEnvelope(envelope: Envelope): void {
+        this.ws.send(JSON.stringify(envelope));
+    }
+
+    private onMessage(event: MessageEvent): void {
+        const envelope: Envelope = JSON.parse(event.data);
+        this.handleIncomingEnvelope(envelope);
+        this.emit(envelope.type, envelope.data);
+        this.emit(this.Event.message, envelope);
+
+        // Login successfully
+        if (!this.authenticated) {
+            const isAuthenticated = envelope.type !== 'Error';
+            this.authenticated = isAuthenticated;
+            if (isAuthenticated) {
+                this.authenticatedResolvers[0]();
+                this.emit(this.Event.connect);
+                this.sendFromQueue();
+            } else {
+                this.authenticatedResolvers[1](envelope.data);
+            }
+        }
+    }
+
+    private onClose(event: CloseEvent): void {
+        clearTimeout(this.connectingTimeoutId);
+        const reconnect = event.code !== 1000; // Connection was closed because of error
+        if (reconnect) {
+            this.connect();
+        }
+        this.emit(this.Event.disconnect, reconnect);
+    }
+
+    private sendFromQueue(): void {
+        // Send awaiting data to server
+        let lastDelay = 0;
+        for (const dataIndex in this.sendQueue) {
+            const envelope = this.sendQueue[dataIndex];
+            setTimeout(() => this.sendEnvelope(envelope), lastDelay);
+            lastDelay += this.options.awaitQueueSendDelayMs ?? 500;
+        }
+        this.sendQueue = [];
+        clearTimeout(this.connectingTimeoutId);
+    }
+
+    private triggerConnectionTimeout(): void {
+        this.disconnect();
+        this.emit(this.Event.error, new Error('Connection timeout'));
+    }
 }

package/src/index.ts

@@ -1,23 +1,23 @@
-import {WebSocketChatClient} from "./WebSocketChatClient";
-import {WebApiChatClient} from "./WebApiChatClient";
-import {
-    IndexedCollection,
-    IndexedObjectCollection,
-    ObservableIndexedCollection,
-    ObservableIndexedObjectCollection
-} from "./IndexedObjectCollection";
-import { AuthClient, MyAccountInterface, TokenInterface } from "./AuthClient";
-import {FilesClient, File} from "./FilesClient";
-import { Permissions, PermissionDefinition, Layer } from "./Permissions";
-import * as ChatTypes from './types/src';
-
-export {
-    IndexedCollection, ObservableIndexedCollection,
-    IndexedObjectCollection, ObservableIndexedObjectCollection,
-    Permissions, PermissionDefinition, Layer,
-    WebSocketChatClient, WebApiChatClient,
-    AuthClient, MyAccountInterface, TokenInterface,
-    FilesClient, File
-};
-
+import {WebSocketChatClient} from "./WebSocketChatClient";
+import {WebApiChatClient} from "./WebApiChatClient";
+import {
+    IndexedCollection,
+    IndexedObjectCollection,
+    ObservableIndexedCollection,
+    ObservableIndexedObjectCollection
+} from "./IndexedObjectCollection";
+import { AuthClient, MyAccountInterface, TokenInterface } from "./AuthClient";
+import {FilesClient, File} from "./FilesClient";
+import { Permissions, PermissionDefinition, Layer } from "./Permissions";
+import * as ChatTypes from './types/src';
+
+export {
+    IndexedCollection, ObservableIndexedCollection,
+    IndexedObjectCollection, ObservableIndexedObjectCollection,
+    Permissions, PermissionDefinition, Layer,
+    WebSocketChatClient, WebApiChatClient,
+    AuthClient, MyAccountInterface, TokenInterface,
+    FilesClient, File
+};
+
 export type {ChatTypes};

package/src/state-tracker/ChatStateTracker.ts

@@ -1,42 +1,47 @@
-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";
-
-export class ChatStateTracker {
-    /**
-     * State of your permissions.
-     */
-    public readonly permissions = new PermissionsManager(this);
-    /**
-     * State of the rooms you are in.
-     */
-    public readonly rooms: RoomsManager = new RoomsManager(this);
-    /**
-     * State of the spaces you are in.
-     */
-    public readonly spaces = new SpacesManager(this);
-
-    private _me: User = null;
-    private readonly deferredSession = new DeferredTask();
-
-    public constructor(public readonly client: WebSocketChatClient) {
-        this.client.on('Session', ev => this.handleSession(ev));
-    }
-
-    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";
+
+export class ChatStateTracker {
+    /**
+     * State of your permissions.
+     */
+    public readonly permissions = new PermissionsManager(this);
+    /**
+     * State of the rooms you are in.
+     */
+    public readonly rooms: RoomsManager = new RoomsManager(this);
+    /**
+     * State of the spaces you are in.
+     */
+    public readonly spaces = new SpacesManager(this);
+    /**
+     * State of the emoticons (global and space-related).
+     */
+    public readonly emoticons = new EmoticonsManager(this);
+
+    private _me: User = null;
+    private readonly deferredSession = new DeferredTask();
+
+    public constructor(public readonly client: WebSocketChatClient) {
+        this.client.on('Session', ev => this.handleSession(ev));
+    }
+
+    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/EmoticonsManager.ts

@@ -0,0 +1,67 @@
+import {ChatStateTracker} from "./ChatStateTracker";
+import {
+    IndexedCollection,
+    ObservableIndexedObjectCollection
+} from "../IndexedObjectCollection";
+import {Emoticon, EmoticonDeleted, Emoticons, NewEmoticon, SpaceDeleted} from "../types/src";
+import {PromiseRegistry} from "./AsyncUtils";
+
+const GLOBAL_KEY = 'global';
+
+export class EmoticonsManager {
+    private list: IndexedCollection<string, ObservableIndexedObjectCollection<Emoticon>> = new IndexedCollection();
+    private emoticonsPromises = new PromiseRegistry();
+    
+    public constructor(private tracker: ChatStateTracker) {
+        this.tracker.client.on('Emoticons', ev => this.handleEmoticons(ev));
+        this.tracker.client.on('NewEmoticon', ev => this.handleNewEmoticon(ev));
+        this.tracker.client.on('EmoticonDeleted', ev => this.handleEmoticonDeleted(ev));
+        this.tracker.client.on('SpaceDeleted', ev => this.handleSpaceDeleted(ev));
+        this.tracker.client.on('Session', () => this.handleSession());
+    }
+
+    public async get(spaceId?: string): Promise<ObservableIndexedObjectCollection<Emoticon>> {
+        if (this.emoticonsPromises.notExist(spaceId)) {
+            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);
+        }
+
+        await this.emoticonsPromises.get(spaceId);
+        return this.list.get(spaceId);
+    }
+
+    private handleEmoticons(event: Emoticons): void {
+        const spaceId = event.location.spaceId ?? GLOBAL_KEY;
+
+        if (!this.list.has(spaceId)) {
+            this.list.set([spaceId, new ObservableIndexedObjectCollection<Emoticon>('id')]);
+        }
+
+        const collection = this.list.get(spaceId);
+        collection.set(...event.emoticons);
+    }
+
+    private handleNewEmoticon(ev: NewEmoticon): void {
+        const collection = this.list.get(ev.emoticon.spaceId ?? GLOBAL_KEY);
+        collection?.set(ev.emoticon);
+    }
+
+    private handleEmoticonDeleted(ev: EmoticonDeleted): void {
+        const collection = this.list.get(ev.spaceId ?? GLOBAL_KEY);
+        collection?.delete(ev.emoticonId);
+    }
+
+    private handleSpaceDeleted(event: SpaceDeleted): void {
+        this.list.delete(event.id);
+    }
+
+    private handleSession(): void {
+        this.list.deleteAll();
+        this.emoticonsPromises.forgetAll();
+    }
+}

package/src/state-tracker/RoomMessagesHistory.ts

@@ -1,74 +1,74 @@
-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.refMessage) {
-            const refHistoryWindow = this.historyWindows.get(topic.refMessage.location.topicId);
-            refHistoryWindow?._updateMessageReference(topic);
-        }
-    }
+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.refMessage) {
+            const refHistoryWindow = this.historyWindows.get(topic.refMessage.location.topicId);
+            refHistoryWindow?._updateMessageReference(topic);
+        }
+    }
 }

package/src/types/src/index.ts

@@ -92,6 +92,13 @@ import {TopicUpdated} from "./schemes/events/TopicUpdated";
 import {GetDiscoverableSpaces} from "./schemes/commands/GetDiscoverableSpaces";
 import {DiscoverableSpaces} from "./schemes/events/DiscoverableSpaces";
 import {SpaceSummary} from "./schemes/SpaceSummary";
+import {Emoticon} from "./schemes/Emoticon";
+import {Emoticons} from "./schemes/events/Emoticons";
+import {GetEmoticons} from "./schemes/commands/GetEmoticons";
+import {CreateEmoticon} from "./schemes/commands/CreateEmoticon";
+import {DeleteEmoticon} from "./schemes/commands/DeleteEmoticon";
+import {NewEmoticon} from "./schemes/events/NewEmoticon";
+import {EmoticonDeleted} from "./schemes/events/EmoticonDeleted";
 
 export {
     // objects
@@ -114,6 +121,7 @@ export {
     ChatLocation,
     SpaceSummary,
     SpaceDiscoverable,
+    Emoticon,
     // events
     Bye,
     Error,
@@ -156,6 +164,9 @@ export {
     Owners,
     Ok,
     DiscoverableSpaces,
+    Emoticons,
+    EmoticonDeleted,
+    NewEmoticon,
     // commands
     AssignRole,
     GetMessages,
@@ -195,4 +206,7 @@ export {
     Topics,
     GetTopics,
     GetDiscoverableSpaces,
+    GetEmoticons,
+    CreateEmoticon,
+    DeleteEmoticon,
 };

package/src/types/src/schemes/Emoticon.ts

@@ -0,0 +1,9 @@
+import {User} from "./User";
+
+export interface Emoticon {
+    id: string;
+    spaceId?: string;
+    name: string;
+    fileId: string;
+    user: User;
+}