polfan-server-js-client 0.1.99922 → 0.1.99924

package/src/IndexedObjectCollection.ts

@@ -1,226 +1,226 @@
-import {EventTarget, ObservableInterface} from "./EventTarget";
-
-export class IndexedCollection<KeyT, ValueT> {
-    protected _items: Map<KeyT, ValueT> = new Map();
-
-    public constructor(items: [key: KeyT, value: ValueT][] = []) {
-        this.set(...items);
-    }
-
-    public get items(): Map<KeyT, ValueT> {
-        return this._items;
-    }
-
-    public get length(): number {
-        return this._items.size;
-    }
-
-    public set(...items: [KeyT, ValueT][]): void {
-        for (const item of items) {
-            this._items.set(item[0], item[1]);
-        }
-    }
-
-    public get(id: KeyT): ValueT | undefined {
-        return this.items.get(id);
-    }
-
-    public has(id: KeyT): boolean {
-        return this.items.has(id);
-    }
-
-    public delete(...ids: KeyT[]): void {
-        for (const id of ids) {
-            this.items.delete(id);
-        }
-    }
-
-    public deleteAll(): void {
-        this.items.clear();
-    }
-
-    public findBy(field: keyof ValueT, valueToFind: any, limit: number = null): IndexedCollection<KeyT, ValueT> {
-        const result = new IndexedCollection<KeyT, ValueT>();
-        let item;
-        while (!(item = this.items.entries().next().value).done) {
-            if (limit && result.length === limit) {
-                break;
-            }
-            if (item[1][field] === valueToFind) {
-                result.set(item);
-            }
-        }
-        return result;
-    }
-
-    public map<MapT = any>(callback: (item: ValueT, index: KeyT) => MapT): MapT[] {
-        return Array.from(this.items.entries()).map((entry) => callback(entry[1], entry[0]));
-    }
-}
-
-export class IndexedObjectCollection<T> {
-    protected _items: IndexedCollection<string, T>;
-
-    public constructor(
-        public readonly id: keyof T | ((item: T) => any),
-        items: T[] = [],
-    ) {
-        this._items = new IndexedCollection<string, T>();
-        this.set(...items);
-    }
-
-    public get items(): T[] {
-        return Array.from(this._items.items.values());
-    }
-
-    public get length(): number {
-        return this._items.length;
-    }
-
-    public set(...items: T[]): void {
-        this._items.set(...(items.map(item => [this.getId(item), item] as [string, T])));
-    }
-
-    public get(id: any): T | undefined {
-        return this._items.get(id);
-    }
-
-    public getAt(index: number): T | undefined {
-        return this.items[index];
-    }
-
-    public has(id: any): boolean {
-        return this._items.has(id);
-    }
-
-    public delete(...ids: any[]): void {
-        this._items.delete(...ids);
-    }
-
-    public deleteAll(): void {
-        this._items.deleteAll();
-    }
-
-    public findBy(field: keyof T, valueToFind: any, limit: number = null): IndexedObjectCollection<T> {
-        const result = new IndexedObjectCollection<T>(this.id);
-        for (const value of this.items) {
-            if (limit && result.length === limit) {
-                break;
-            }
-            if (value[field] === valueToFind) {
-                result.set(value);
-            }
-        }
-        return result;
-    }
-
-    public map<MapT = any>(callback: (item: T, index: number, array: T[]) => MapT): MapT[] {
-        return this.items.map(callback);
-    }
-
-    protected getId(item: T): any {
-        return typeof this.id === 'function' ? this.id(item) : item[this.id];
-    }
-}
-
-interface ObservableCollectionEvent<KeyT> {
-    setItems?: KeyT[],
-    deletedItems?: KeyT[],
-}
-
-export class ObservableIndexedCollection<KeyT, ValueT> extends IndexedCollection<KeyT, ValueT> implements ObservableInterface {
-    protected eventTarget: EventTarget<ObservableCollectionEvent<KeyT>>;
-
-    public constructor(items: [key: KeyT, value: ValueT][] = []) {
-        super();
-        this.eventTarget = new EventTarget<ObservableCollectionEvent<KeyT>>();
-        this.set(...items);
-    }
-
-    public set(...items: [KeyT, ValueT][]) {
-        if (items.length) {
-            super.set(...items);
-            this.eventTarget.emit('change', {setItems: items.map(item => item[0])});
-        }
-    }
-
-    public delete(...ids: KeyT[]) {
-        if (ids.length) {
-            super.delete(...ids);
-            this.eventTarget.emit('change', {deletedItems: ids});
-        }
-    }
-
-    public deleteAll() {
-        if (this.length) {
-            const ids = this._items.keys();
-            super.deleteAll();
-            this.eventTarget.emit('change', {deletedItems: Array.from(ids)});
-        }
-    }
-
-    public on(eventName: 'change', handler: (ev?: ObservableCollectionEvent<KeyT>) => void): this {
-        this.eventTarget.on(eventName, handler);
-        return this;
-    }
-
-    public once(eventName: 'change', handler: (ev?: ObservableCollectionEvent<KeyT>) => void): this {
-        this.eventTarget.once(eventName, handler);
-        return this;
-    }
-
-    public off(eventName: string, handler: (ev?: ObservableCollectionEvent<KeyT>) => void): this {
-        this.eventTarget.off(eventName, handler);
-        return this;
-    }
-}
-
-export class ObservableIndexedObjectCollection<T> extends IndexedObjectCollection<T> implements ObservableInterface {
-    protected eventTarget: EventTarget<ObservableCollectionEvent<string>>;
-
-    public constructor(
-        public readonly id: keyof T | ((item: T) => string),
-        items: T[] = [],
-    ) {
-        super(id);
-        this.eventTarget = new EventTarget();
-        this.set(...items);
-    }
-
-    public set(...items: T[]) {
-        if (items.length) {
-            super.set(...items);
-            this.eventTarget.emit('change', {setItems: items.map(item => this.getId(item))});
-        }
-    }
-
-    public delete(...ids: string[]) {
-        if (ids.length) {
-            super.delete(...ids);
-            this.eventTarget.emit('change', {deletedItems: ids});
-        }
-    }
-
-    public deleteAll() {
-        if (this.length) {
-            const ids = this._items.items.keys();
-            super.deleteAll();
-            this.eventTarget.emit('change', {deletedItems: Array.from(ids)});
-        }
-    }
-
-    public on(eventName: 'change', handler: (ev?: ObservableCollectionEvent<string>) => void): this {
-        this.eventTarget.on(eventName, handler);
-        return this;
-    }
-
-    public once(eventName: 'change', handler: (ev?: ObservableCollectionEvent<string>) => void): this {
-        this.eventTarget.once(eventName, handler);
-        return this;
-    }
-
-    public off(eventName: string, handler: (ev?: ObservableCollectionEvent<string>) => void): this {
-        this.eventTarget.off(eventName, handler);
-        return this;
-    }
+import {EventTarget, ObservableInterface} from "./EventTarget";
+
+export class IndexedCollection<KeyT, ValueT> {
+    protected _items: Map<KeyT, ValueT> = new Map();
+
+    public constructor(items: [key: KeyT, value: ValueT][] = []) {
+        this.set(...items);
+    }
+
+    public get items(): Map<KeyT, ValueT> {
+        return this._items;
+    }
+
+    public get length(): number {
+        return this._items.size;
+    }
+
+    public set(...items: [KeyT, ValueT][]): void {
+        for (const item of items) {
+            this._items.set(item[0], item[1]);
+        }
+    }
+
+    public get(id: KeyT): ValueT | undefined {
+        return this.items.get(id);
+    }
+
+    public has(id: KeyT): boolean {
+        return this.items.has(id);
+    }
+
+    public delete(...ids: KeyT[]): void {
+        for (const id of ids) {
+            this.items.delete(id);
+        }
+    }
+
+    public deleteAll(): void {
+        this.items.clear();
+    }
+
+    public findBy(field: keyof ValueT, valueToFind: any, limit: number = null): IndexedCollection<KeyT, ValueT> {
+        const result = new IndexedCollection<KeyT, ValueT>();
+        let item;
+        while (!(item = this.items.entries().next().value).done) {
+            if (limit && result.length === limit) {
+                break;
+            }
+            if (item[1][field] === valueToFind) {
+                result.set(item);
+            }
+        }
+        return result;
+    }
+
+    public map<MapT = any>(callback: (item: ValueT, index: KeyT) => MapT): MapT[] {
+        return Array.from(this.items.entries()).map((entry) => callback(entry[1], entry[0]));
+    }
+}
+
+export class IndexedObjectCollection<T> {
+    protected _items: IndexedCollection<string, T>;
+
+    public constructor(
+        public readonly id: keyof T | ((item: T) => any),
+        items: T[] = [],
+    ) {
+        this._items = new IndexedCollection<string, T>();
+        this.set(...items);
+    }
+
+    public get items(): T[] {
+        return Array.from(this._items.items.values());
+    }
+
+    public get length(): number {
+        return this._items.length;
+    }
+
+    public set(...items: T[]): void {
+        this._items.set(...(items.map(item => [this.getId(item), item] as [string, T])));
+    }
+
+    public get(id: any): T | undefined {
+        return this._items.get(id);
+    }
+
+    public getAt(index: number): T | undefined {
+        return this.items[index];
+    }
+
+    public has(id: any): boolean {
+        return this._items.has(id);
+    }
+
+    public delete(...ids: any[]): void {
+        this._items.delete(...ids);
+    }
+
+    public deleteAll(): void {
+        this._items.deleteAll();
+    }
+
+    public findBy(field: keyof T, valueToFind: any, limit: number = null): IndexedObjectCollection<T> {
+        const result = new IndexedObjectCollection<T>(this.id);
+        for (const value of this.items) {
+            if (limit && result.length === limit) {
+                break;
+            }
+            if (value[field] === valueToFind) {
+                result.set(value);
+            }
+        }
+        return result;
+    }
+
+    public map<MapT = any>(callback: (item: T, index: number, array: T[]) => MapT): MapT[] {
+        return this.items.map(callback);
+    }
+
+    protected getId(item: T): any {
+        return typeof this.id === 'function' ? this.id(item) : item[this.id];
+    }
+}
+
+interface ObservableCollectionEvent<KeyT> {
+    setItems?: KeyT[],
+    deletedItems?: KeyT[],
+}
+
+export class ObservableIndexedCollection<KeyT, ValueT> extends IndexedCollection<KeyT, ValueT> implements ObservableInterface {
+    protected eventTarget: EventTarget<ObservableCollectionEvent<KeyT>>;
+
+    public constructor(items: [key: KeyT, value: ValueT][] = []) {
+        super();
+        this.eventTarget = new EventTarget<ObservableCollectionEvent<KeyT>>();
+        this.set(...items);
+    }
+
+    public set(...items: [KeyT, ValueT][]) {
+        if (items.length) {
+            super.set(...items);
+            this.eventTarget.emit('change', {setItems: items.map(item => item[0])});
+        }
+    }
+
+    public delete(...ids: KeyT[]) {
+        if (ids.length) {
+            super.delete(...ids);
+            this.eventTarget.emit('change', {deletedItems: ids});
+        }
+    }
+
+    public deleteAll() {
+        if (this.length) {
+            const ids = this._items.keys();
+            super.deleteAll();
+            this.eventTarget.emit('change', {deletedItems: Array.from(ids)});
+        }
+    }
+
+    public on(eventName: 'change', handler: (ev?: ObservableCollectionEvent<KeyT>) => void): this {
+        this.eventTarget.on(eventName, handler);
+        return this;
+    }
+
+    public once(eventName: 'change', handler: (ev?: ObservableCollectionEvent<KeyT>) => void): this {
+        this.eventTarget.once(eventName, handler);
+        return this;
+    }
+
+    public off(eventName: string, handler: (ev?: ObservableCollectionEvent<KeyT>) => void): this {
+        this.eventTarget.off(eventName, handler);
+        return this;
+    }
+}
+
+export class ObservableIndexedObjectCollection<T> extends IndexedObjectCollection<T> implements ObservableInterface {
+    protected eventTarget: EventTarget<ObservableCollectionEvent<string>>;
+
+    public constructor(
+        public readonly id: keyof T | ((item: T) => string),
+        items: T[] = [],
+    ) {
+        super(id);
+        this.eventTarget = new EventTarget();
+        this.set(...items);
+    }
+
+    public set(...items: T[]) {
+        if (items.length) {
+            super.set(...items);
+            this.eventTarget.emit('change', {setItems: items.map(item => this.getId(item))});
+        }
+    }
+
+    public delete(...ids: string[]) {
+        if (ids.length) {
+            super.delete(...ids);
+            this.eventTarget.emit('change', {deletedItems: ids});
+        }
+    }
+
+    public deleteAll() {
+        if (this.length) {
+            const ids = this._items.items.keys();
+            super.deleteAll();
+            this.eventTarget.emit('change', {deletedItems: Array.from(ids)});
+        }
+    }
+
+    public on(eventName: 'change', handler: (ev?: ObservableCollectionEvent<string>) => void): this {
+        this.eventTarget.on(eventName, handler);
+        return this;
+    }
+
+    public once(eventName: 'change', handler: (ev?: ObservableCollectionEvent<string>) => void): this {
+        this.eventTarget.once(eventName, handler);
+        return this;
+    }
+
+    public off(eventName: string, handler: (ev?: ObservableCollectionEvent<string>) => void): this {
+        this.eventTarget.off(eventName, handler);
+        return this;
+    }
 }

package/src/Permissions.ts

@@ -25,6 +25,8 @@ export class Permissions {
         ManagePermissions: {value: 1 << 10, maxLayer: Layer.Topic},
         CreateSpaceRooms: {value: 1 << 11, maxLayer: Layer.Space},
         ManageSpaceRooms: {value: 1 << 12, maxLayer: Layer.Space},
+        CreateEmoticons: {value: 1 << 13, maxLayer: Layer.Global},
+        ManageEmoticon: {value: 1 << 14, maxLayer: Layer.Space},
     };
 
     public static getNames(): (keyof typeof this.list)[] {

package/src/WebApiChatClient.ts

@@ -1,95 +1,95 @@
-import {AbstractChatClient, CommandResult, CommandsMap} from "./AbstractChatClient";
-import {ObservableInterface} from "./EventTarget";
-import {Envelope} from "./types/src";
-
-export interface WebApiChatClientOptions {
-    url: string;
-    token?: string;
-    temporaryNick?: string;
-    attemptsToSend?: number;
-    attemptDelayMs?: number;
-}
-
-enum WebApiChatClientEvent {
-    message = 'message',
-    error = 'error',
-    destroy = 'destroy',
-}
-
-export class WebApiChatClient extends AbstractChatClient implements ObservableInterface {
-    public readonly Event = WebApiChatClientEvent;
-
-    protected sendStack: {data: any, attempts: number, lastTimeoutId: any}[];
-
-    public constructor(private readonly options: WebApiChatClientOptions) {
-        super();
-        if (!this.options.token && !this.options.temporaryNick) {
-            throw new Error('Token or temporary nick is required');
-        }
-    }
-
-    public async send<CommandType extends keyof CommandsMap>(commandType: CommandType, commandData: CommandsMap[CommandType][0]):
-        Promise<CommandResult<CommandsMap[CommandType][1]>> {
-        const envelope = this.createEnvelope(commandType, commandData);
-        this.sendStack.push({data: envelope, attempts: 0, lastTimeoutId: null});
-        this.makeApiCall(this.sendStack.length - 1);
-        return this.createPromiseFromCommandEnvelope(envelope);
-    }
-
-    public destroy(): void {
-        // Cancel all awaiting requests
-        this.sendStack.forEach(item => {
-            if (item.lastTimeoutId) {
-                clearTimeout(item.lastTimeoutId);
-            }
-            this.awaitingResponse.delete(item.data.ref);
-        });
-        this.sendStack = [];
-        this.emit(this.Event.destroy, false);
-    }
-
-    protected async onMessage(reqId: number, response: Response): Promise<void> {
-        this.sendStack.splice(reqId, 1);
-        const envelope: Envelope = await response.json();
-        this.handleIncomingEnvelope(envelope);
-        this.emit(envelope.type, envelope.data);
-        this.emit(this.Event.message, envelope);
-    }
-
-    protected onError(reqId: number, body: string): void {
-        if (this.sendStack[reqId].attempts >= (this.options.attemptsToSend ?? 10)) {
-            this.sendStack.splice(reqId, 1);
-            this.handleEnvelopeSendError(this.sendStack[reqId].data, new Error(
-                `Cannot send ${body}; aborting after reaching the maximum connection errors`
-            ));
-            return;
-        }
-        this.sendStack[reqId].lastTimeoutId = setTimeout(
-            () => this.makeApiCall(reqId),
-            this.options.attemptDelayMs ?? 3000
-        );
-    }
-
-    protected makeApiCall(reqId: number): void {
-        this.sendStack[reqId].attempts++;
-        const bodyJson = JSON.stringify(this.sendStack[reqId].data);
-        const headers: any = {
-            'Content-Type': 'application/json',
-            Accept: 'application/json'
-        };
-
-        if (this.options.token) {
-            headers.Authorization = `Bearer ${this.options.token}`;
-        } else if (this.options.temporaryNick) {
-            headers.Authorization = `Temp ${this.options.temporaryNick}`;
-        }
-
-        fetch(this.options.url, {
-            headers,
-            body: bodyJson,
-            method: 'POST',
-        })
-            .then(response => this.onMessage(reqId, response))
-            .catch(() => this.onError(reqId, bodyJson));
-    }
+import {AbstractChatClient, CommandResult, CommandsMap} from "./AbstractChatClient";
+import {ObservableInterface} from "./EventTarget";
+import {Envelope} from "./types/src";
+
+export interface WebApiChatClientOptions {
+    url: string;
+    token?: string;
+    temporaryNick?: string;
+    attemptsToSend?: number;
+    attemptDelayMs?: number;
+}
+
+enum WebApiChatClientEvent {
+    message = 'message',
+    error = 'error',
+    destroy = 'destroy',
+}
+
+export class WebApiChatClient extends AbstractChatClient implements ObservableInterface {
+    public readonly Event = WebApiChatClientEvent;
+
+    protected sendStack: {data: any, attempts: number, lastTimeoutId: any}[];
+
+    public constructor(private readonly options: WebApiChatClientOptions) {
+        super();
+        if (!this.options.token && !this.options.temporaryNick) {
+            throw new Error('Token or temporary nick is required');
+        }
+    }
+
+    public async send<CommandType extends keyof CommandsMap>(commandType: CommandType, commandData: CommandsMap[CommandType][0]):
+        Promise<CommandResult<CommandsMap[CommandType][1]>> {
+        const envelope = this.createEnvelope(commandType, commandData);
+        this.sendStack.push({data: envelope, attempts: 0, lastTimeoutId: null});
+        this.makeApiCall(this.sendStack.length - 1);
+        return this.createPromiseFromCommandEnvelope(envelope);
+    }
+
+    public destroy(): void {
+        // Cancel all awaiting requests
+        this.sendStack.forEach(item => {
+            if (item.lastTimeoutId) {
+                clearTimeout(item.lastTimeoutId);
+            }
+            this.awaitingResponse.delete(item.data.ref);
+        });
+        this.sendStack = [];
+        this.emit(this.Event.destroy, false);
+    }
+
+    protected async onMessage(reqId: number, response: Response): Promise<void> {
+        this.sendStack.splice(reqId, 1);
+        const envelope: Envelope = await response.json();
+        this.handleIncomingEnvelope(envelope);
+        this.emit(envelope.type, envelope.data);
+        this.emit(this.Event.message, envelope);
+    }
+
+    protected onError(reqId: number, body: string): void {
+        if (this.sendStack[reqId].attempts >= (this.options.attemptsToSend ?? 10)) {
+            this.sendStack.splice(reqId, 1);
+            this.handleEnvelopeSendError(this.sendStack[reqId].data, new Error(
+                `Cannot send ${body}; aborting after reaching the maximum connection errors`
+            ));
+            return;
+        }
+        this.sendStack[reqId].lastTimeoutId = setTimeout(
+            () => this.makeApiCall(reqId),
+            this.options.attemptDelayMs ?? 3000
+        );
+    }
+
+    protected makeApiCall(reqId: number): void {
+        this.sendStack[reqId].attempts++;
+        const bodyJson = JSON.stringify(this.sendStack[reqId].data);
+        const headers: any = {
+            'Content-Type': 'application/json',
+            Accept: 'application/json'
+        };
+
+        if (this.options.token) {
+            headers.Authorization = `Bearer ${this.options.token}`;
+        } else if (this.options.temporaryNick) {
+            headers.Authorization = `Temp ${this.options.temporaryNick}`;
+        }
+
+        fetch(this.options.url, {
+            headers,
+            body: bodyJson,
+            method: 'POST',
+        })
+            .then(response => this.onMessage(reqId, response))
+            .catch(() => this.onError(reqId, bodyJson));
+    }
 }