fchat-rising/chat/slash_commands.ts

import core from './core';
import {Character, Conversation, userStatuses} from './interfaces';
import l from './localize';
import ChannelConversation = Conversation.ChannelConversation;
import PrivateConversation = Conversation.PrivateConversation;

export const enum ParamType {
    String, Number, Character, Enum
}

const defaultDelimiters: {[key: number]: string | undefined} = {[ParamType.Character]: ',', [ParamType.String]: ''};

export function isAction(this: void, text: string): boolean {
    return /^\/me\b/i.test(text);
}

export function isWarn(this: void, text: string): boolean {
    return /^\/warn\b/i.test(text);
}

export function isCommand(this: void, text: string): boolean {
    return text.charAt(0) === '/' && !isAction(text) && !isWarn(text);
}

export function parse(this: void | never, input: string, context: CommandContext): ((this: Conversation) => void) | string {
    const commandEnd = input.indexOf(' ');
    const name = input.substring(1, commandEnd !== -1 ? commandEnd : undefined).toLowerCase();
    const command = commands[name];
    if(command === undefined) return l('commands.unknown');
    const args = `${commandEnd !== -1 ? input.substr(commandEnd + 1) : ''}`;
    if(command.context !== undefined && (command.context & context) === 0) return l('commands.badContext');

    let index = 0;
    const values: (string | number)[] = [];

    if(command.params !== undefined)
        for(let i = 0; i < command.params.length; ++i) {
            while(args[index] === ' ') ++index;
            const param = command.params[i];
            if(index === -1)
                if(param.optional !== undefined) continue;
                else return l('commands.tooFewParams');
            let delimiter = param.delimiter !== undefined ? param.delimiter : defaultDelimiters[param.type];
            if(delimiter === undefined) delimiter = ' ';
            const endIndex = delimiter.length > 0 ? args.indexOf(delimiter, index) : args.length;
            const value = args.substring(index, endIndex !== -1 ? endIndex : undefined);
            if(value.length === 0)
                if(param.optional !== undefined) continue;
                else return l('commands.tooFewParams');
            values[i] = value;
            switch(param.type) {
                case ParamType.String:
                    if(i === command.params.length - 1) values[i] = args.substr(index);
                    break;
                case ParamType.Enum:
                    if((param.options !== undefined ? param.options : []).indexOf(value) === -1)
                        return l('commands.invalidParam', l(`commands.${name}.param${i}`));
                    break;
                case ParamType.Number:
                    const num = parseInt(value, 10);
                    if(isNaN(num))
                        return l('commands.invalidParam', l(`commands.${name}.param${i}`));
                    values[i] = num;
                    break;
                case ParamType.Character:
                    if(value.charAt(0) === '"' && value.charAt(value.length - 1) === '"') {
                        values[i] = value.substring(1, value.length - 1);
                        break;
                    }
                    const char = core.characters.get(value);
                    if(char.status === 'offline') return l('commands.invalidCharacter');
            }
            index = endIndex === -1 ? args.length : endIndex + 1;
        }
    return function(this: Conversation): void {
        command.exec(this, ...values);
    };
}

export const enum CommandContext {
    Console = 1 << 0,
    Channel = 1 << 1,
    Private = 1 << 2
}

export enum Permission {
    RoomOp = -1,
    RoomOwner = -2,
    ChannelMod = 4,
    ChatOp = 2,
    Admin = 1
}

export interface Command {
    readonly context?: CommandContext,                          //default implicit Console | Channel | Private
    readonly permission?: Permission
    readonly documented?: false,                                //default true
    readonly params?: {
        readonly type: ParamType
        readonly options?: ReadonlyArray<string>,               //default undefined
        readonly optional?: true,                               //default false
        readonly delimiter?: string,                            //default ' ' (',' for type: Character)
        validator?(data: string | number): boolean              //default undefined
    }[]
    exec(context: Conversation, ...params: (string | number | undefined)[]): void
}

const commands: {readonly [key: string]: Command | undefined} = {
    me: {
        exec: () => 'stub',
        context: CommandContext.Channel | CommandContext.Private,
        params: [{type: ParamType.String}]
    },
    reward: {
        exec: (_, character: string) => core.connection.send('RWD', {character}),
        permission: Permission.Admin,
        params: [{type: ParamType.Character}]
    },
    greports: {
        permission: Permission.ChannelMod,
        exec: () => core.connection.send('PCR')
    },
    join: {
        exec: (_, channel: string) => core.connection.send('JCH', {channel}),
        params: [{type: ParamType.String}]
    },
    close: {
        exec: (conv: PrivateConversation | ChannelConversation) => conv.close(),
        context: CommandContext.Private | CommandContext.Channel
    },
    priv: {
        exec: (_, character: string) => core.conversations.getPrivate(core.characters.get(character)).show(),
        params: [{type: ParamType.Character}]
    },
    uptime: {
        exec: () => core.connection.send('UPT')
    },
    clear: {
        exec: (conv: Conversation) => conv.clear()
    },
    status: {
        exec: (_, status: Character.Status, statusmsg: string = '') => core.connection.send('STA', {status, statusmsg}),
        params: [{type: ParamType.Enum, options: userStatuses}, {type: ParamType.String, optional: true}]
    },
    ad: {
        exec: (conv: ChannelConversation, message: string) =>
            core.connection.send('LRP', {channel: conv.channel.id, message}),
        context: CommandContext.Channel,
        params: [{type: ParamType.String}]
    },
    roll: {
        exec: (conv: ChannelConversation | PrivateConversation, dice: string) => {
            if(Conversation.isChannel(conv)) core.connection.send('RLL', {channel: conv.channel.id, dice});
            else core.connection.send('RLL', {recipient: conv.character.name, dice});
        },
        context: CommandContext.Channel | CommandContext.Private,
        params: [{type: ParamType.String}]
    },
    bottle: {
        exec: (conv: ChannelConversation | PrivateConversation) => {
            if(Conversation.isChannel(conv)) core.connection.send('RLL', {channel: conv.channel.id, dice: 'bottle'});
            else core.connection.send('RLL', {recipient: conv.character.name, dice: 'bottle'});
        },
        context: CommandContext.Channel | CommandContext.Private
    },
    warn: {
        exec: () => 'stub',
        permission: Permission.RoomOp,
        context: CommandContext.Channel,
        params: [{type: ParamType.String}]
    },
    kick: {
        exec: (conv: ChannelConversation, character: string) =>
            core.connection.send('CKU', {channel: conv.channel.id, character}),
        permission: Permission.RoomOp,
        context: CommandContext.Channel,
        params: [{type: ParamType.Character}]
    },
    ban: {
        exec: (conv: ChannelConversation, character: string) =>
            core.connection.send('CBU', {channel: conv.channel.id, character}),
        permission: Permission.RoomOp,
        context: CommandContext.Channel,
        params: [{type: ParamType.Character}]
    },
    unban: {
        exec: (conv: ChannelConversation, character: string) =>
            core.connection.send('CUB', {channel: conv.channel.id, character}),
        permission: Permission.RoomOp,
        context: CommandContext.Channel,
        params: [{type: ParamType.Character}]
    },
    banlist: {
        exec: (conv: ChannelConversation) => core.connection.send('CBL', {channel: conv.channel.id}),
        permission: Permission.RoomOp,
        context: CommandContext.Channel
    },
    timeout: {
        exec: (conv: ChannelConversation, character: string, length: number) =>
            core.connection.send('CTU', {channel: conv.channel.id, character, length}),
        permission: Permission.RoomOp,
        context: CommandContext.Channel,
        params: [{type: ParamType.Character, delimiter: ','}, {type: ParamType.Number, validator: (x) => x >= 1}]
    },
    gkick: {
        exec: (_, character: string) => core.connection.send('KIK', {character}),
        permission: Permission.ChatOp,
        params: [{type: ParamType.Character}]
    },
    gban: {
        exec: (_, character: string) => core.connection.send('ACB', {character}),
        permission: Permission.ChatOp,
        params: [{type: ParamType.Character}]
    },
    gunban: {
        exec: (_, character: string) => core.connection.send('UNB', {character}),
        permission: Permission.ChatOp,
        params: [{type: ParamType.Character}]
    },
    gtimeout: {
        exec: (_, character: string, time: number, reason: string) =>
            core.connection.send('TMO', {character, time, reason}),
        permission: Permission.ChatOp,
        params: [{type: ParamType.Character, delimiter: ','}, {type: ParamType.Number, validator: (x) => x >= 1}, {type: ParamType.String}]
    },
    setowner: {
        exec: (conv: ChannelConversation, character: string) =>
            core.connection.send('CSO', {channel: conv.channel.id, character}),
        permission: Permission.RoomOwner,
        context: CommandContext.Channel,
        params: [{type: ParamType.Character}]
    },
    ignore: {
        exec: (_, character: string) => core.connection.send('IGN', {action: 'add', character}),
        params: [{type: ParamType.Character}]
    },
    unignore: {
        exec: (_, character: string) => core.connection.send('IGN', {action: 'delete', character}),
        params: [{type: ParamType.Character}]
    },
    ignorelist: {
        exec: (conv: Conversation) => conv.infoText = l('chat.ignoreList', core.characters.ignoreList.join(', '))
    },
    makeroom: {
        exec: (_, channel: string) => core.connection.send('CCR', {channel}),
        params: [{type: ParamType.String}]
    },
    gop: {
        exec: (_, character: string) => core.connection.send('AOP', {character}),
        permission: Permission.Admin,
        params: [{type: ParamType.Character}]
    },
    gdeop: {
        exec: (_, character: string) => core.connection.send('DOP', {character}),
        permission: Permission.Admin,
        params: [{type: ParamType.Character}]
    },
    op: {
        exec: (conv: ChannelConversation, character: string) =>
            core.connection.send('COA', {channel: conv.channel.id, character}),
        permission: Permission.RoomOwner,
        context: CommandContext.Channel,
        params: [{type: ParamType.Character}]
    },
    deop: {
        exec: (conv: ChannelConversation, character: string) =>
            core.connection.send('COR', {channel: conv.channel.id, character}),
        permission: Permission.RoomOwner,
        context: CommandContext.Channel,
        params: [{type: ParamType.Character}]
    },
    scop: {
        exec: (_, character: string) => core.connection.send('SCP', {action: 'add', character}),
        permission: Permission.Admin,
        params: [{type: ParamType.Character}]
    },
    scdeop: {
        exec: (_, character: string) => core.connection.send('SCP', {action: 'remove', character}),
        permission: Permission.Admin,
        params: [{type: ParamType.Character}]
    },
    oplist: {
        exec: (conv: ChannelConversation) => core.connection.send('COL', {channel: conv.channel.id}),
        context: CommandContext.Channel
    },
    invite: {
        exec: (conv: ChannelConversation, character: string) =>
            core.connection.send('CIU', {channel: conv.channel.id, character}),
        permission: Permission.RoomOp,
        context: CommandContext.Channel,
        params: [{type: ParamType.Character}]
    },
    closeroom: {
        exec: (conv: ChannelConversation) => core.connection.send('RST', {channel: conv.channel.id, status: 'private'}),
        permission: Permission.RoomOwner,
        context: CommandContext.Channel
    },
    openroom: {
        exec: (conv: ChannelConversation) => core.connection.send('RST', {channel: conv.channel.id, status: 'public'}),
        permission: Permission.RoomOwner,
        context: CommandContext.Channel
    },
    setmode: {
        exec: (conv: ChannelConversation, mode: 'ads' | 'chat' | 'both') =>
            core.connection.send('RMO', {channel: conv.channel.id, mode}),
        permission: Permission.RoomOwner,
        context: CommandContext.Channel,
        params: [{type: ParamType.Enum, options: ['ads', 'chat', 'both']}]
    },
    setdescription: {
        exec: (conv: ChannelConversation, description: string) =>
            core.connection.send('CDS', {channel: conv.channel.id, description}),
        permission: Permission.RoomOp,
        context: CommandContext.Channel,
        params: [{type: ParamType.String}]
    },
    code: {
        exec: (conv: ChannelConversation) => {
            const active = <HTMLElement>document.activeElement;
            const elm = document.createElement('textarea');
            elm.value = `[session=${conv.channel.name}]${conv.channel.id}[/session]`;
            document.body.appendChild(elm);
            elm.select();
            document.execCommand('copy');
            document.body.removeChild(elm);
            active.focus();
            conv.infoText = l('commands.code.success');
        },
        permission: Permission.RoomOwner,
        context: CommandContext.Channel
    },
    killchannel: {
        exec: (conv: ChannelConversation) => core.connection.send('KIC', {channel: conv.channel.id}),
        permission: Permission.RoomOwner,
        context: CommandContext.Channel
    },
    createchannel: {
        exec: (_, channel: string) => core.connection.send('CRC', {channel}),
        permission: Permission.ChatOp,
        params: [{type: ParamType.String}]
    },
    broadcast: {
        exec: (_, message: string) => core.connection.send('BRO', {message}),
        permission: Permission.Admin,
        params: [{type: ParamType.String}]
    },
    reloadconfig: {
        exec: (_, save?: 'save') => core.connection.send('RLD', save !== undefined ? {save} : undefined),
        permission: Permission.Admin,
        params: [{type: ParamType.Enum, options: ['save'], optional: true}]
    },
    xyzzy: {
        exec: (_, command: string, arg: string) => core.connection.send('ZZZ', {command, arg}),
        permission: Permission.Admin,
        params: [{type: ParamType.String, delimiter: ' '}, {type: ParamType.String}]
    },
    elf: {
        exec: (conv: Conversation) => conv.infoText =
            'Now no one can say there\'s "not enough Elf." It\'s a well-kept secret, but elves love headpets. You should try it sometime.',
        documented: false
    }
};

export default commands;