@tf2pickup-org/mumble-client/dist/user.js

A simple bot for managing mumble servers

import { UserState } from '@tf2pickup-org/mumble-protocol';
import { InsufficientPermissionsError, UserNotRegisteredError, NoSuchChannelError, } from './errors/index.js';
import { syncProperty } from './sync-property.js';
export const MinusOneButUnsigned = 0xffffffff;
export class User {
    client;
    session;
    name;
    channelId = 0;
    _userId;
    mute = false;
    deaf = false;
    suppress = false;
    selfMute = false;
    selfDeaf = false;
    constructor(client, userState) {
        this.client = client;
        this.session = userState.session;
        this.syncState(userState);
    }
    get channel() {
        return this.client.channels.find(channel => channel.id === this.channelId);
    }
    get userId() {
        return this._userId;
    }
    set userId(userId) {
        this._userId = userId === MinusOneButUnsigned ? undefined : userId;
    }
    get isRegistered() {
        return this.userId !== undefined;
    }
    syncState(userState) {
        const changes = {
            ...syncProperty(this, 'name', userState.name),
            ...syncProperty(this, 'channelId', userState.channelId),
            ...syncProperty(this, 'userId', userState.userId),
            ...syncProperty(this, 'mute', userState.mute),
            ...syncProperty(this, 'deaf', userState.deaf),
            ...syncProperty(this, 'suppress', userState.suppress),
            ...syncProperty(this, 'selfMute', userState.selfMute),
            ...syncProperty(this, 'selfDeaf', userState.selfDeaf),
        };
        return changes;
    }
    async moveToChannel(channelId) {
        if (this.channelId === channelId) {
            return this;
        }
        const channel = this.client.channels.byId(channelId);
        if (!channel) {
            throw new NoSuchChannelError(channelId);
        }
        if (!(await channel.getPermissions()).canJoinChannel) {
            throw new InsufficientPermissionsError();
        }
        await this.client.command('moveUserToChannel', {
            sendPacket: [
                UserState,
                UserState.create({ session: this.session, channelId }),
            ],
            expectPacket: [
                UserState,
                userState => userState.session === this.session &&
                    userState.channelId === channelId,
            ],
        });
        return this;
    }
    async setSelfMute(selfMute) {
        await this.client.command('setSelfMute', {
            sendPacket: [
                UserState,
                UserState.create({ session: this.session, selfMute }),
            ],
            expectPacket: [UserState, ({ session }) => session === this.session],
        });
        return this;
    }
    async setSelfDeaf(selfDeaf) {
        await this.client.command('setSelfDeaf', {
            sendPacket: [
                UserState,
                UserState.create({ session: this.session, selfDeaf }),
            ],
            expectPacket: [UserState, ({ session }) => session === this.session],
        });
        return this;
    }
    async register() {
        await this.client.command('registerUser', {
            sendPacket: [
                UserState,
                UserState.create({ session: this.session, userId: 0 }),
            ],
            expectPacket: [UserState, ({ session }) => session === this.session],
        });
        return this;
    }
    async deregister() {
        if (this.userId === undefined) {
            throw new UserNotRegisteredError();
        }
        await this.client.deregisterUser(this.userId);
        return this;
    }
    async rename(name) {
        if (this.userId === undefined) {
            throw new UserNotRegisteredError();
        }
        await this.client.renameRegisteredUser(this.userId, name);
        return this;
    }
}
//# sourceMappingURL=user.js.map