discord-command.js v3.1.4

discord-command.js

This package is a command manager for your discord bot developped for Discord.js.

Basics

Installation: npm install discord-command.js

Get the handler & the command constructor

const { handler, command } = require("discord-command.js");

Note: handler is set to a global variable

1. Load a command

handler.register(resolvable, options);

If the resolvable is a path to a folder it gonna read every other folder in it that doesn't match the filter

• resolvable can be:
  • a path to a file/folder (relative or absolute) (1)
  • an object that fit the command constructor
  • a command

• options:
  • auto_categorise : gonna set the category of the command the same name as its parent folder
  • recursive : if the categories is set recursivly to the childrens of the current command
  • filter : callback function that gonna exclude the expected values

2. How to create a command

Using the command constructor.

const myCommand = new command(entries, executable, options);

Or by create a command object.

const myCommand = {
    "entries",       // obligatory
    "executable",    // obligatory
    "options"        // optional
}

For creating a command you must have 3 keys

• entries : string|string[] (the names of the command)
• executable : function (a callback function that gonna be the executable for this command (the arguments are given through destructuration))
• options: object|null (the options for this command)

executable :function({ channel, message, content, interaction, resolvable, content, args, bot, command })

options : { description, categories, childrens, interactionsTypes, interactionsOnly, timeout, onTimeout, }

Examples of the same command

module.exports = {
    entries: "ping",

    executable: function pingFunction({resolvable}) {
        resolvable.reply("Pong !");
    },

    options: {
        interactionsTypes: ["APPLICATION_COMMAND"]
    }
}

const { command } = require("discord-command.js");

const ping = new command(
    "ping",

    function pingFunction({resolvable}) {
        resolvable.reply("Pong !");
    },

    { interactionsTypes: ["APPLICATION_COMMAND"] }
);

module.exports = ping;

3. Configure the handler

Set the bot

First of all you need to specify the client on wich your bot run on by doing

handler.cache.set('client', /* Your client here */);

You need to specify that in case you want to get your client in an executable of a command or if you want to register slash commands.

Set any parameter of the configuration

The handler have a configuration variable with two function (get & set). In that folder you will see multiple variables that the handler use, you can personalise them with the set function like so

handler.configuration.set("prefix", "!");

You must enter the key and the value that you want to applied to it (the value must be the same type as the one before).

Set a default timeout

handler.cache.set("default_ontimeout", onTimeout);

4. Execute the commands

Using a global function

You can use a global function that works for Discord.Message and Discord.Interaction

Bot.on("messageCreate", message => handler.resolve(message));
Bot.on("interactionCreate", interaction => handler.resolve(interaction));

Using separated functions

You can using different functions too

Bot.on("messageCreate", message => handler.executeMessage(message));
Bot.on("interactionCreate", interaction => handler.executeInteraction(interaction));

Execute a command without an Interaction or Message

const ping = handler.hasCommand("ping");

ping.executable(); // executable is the main function of the command

Note : we don't give any arguments to the executable so we have to make sure that the command don't ask for them.

Advanced

1. Statics commands

Static commands are some commands that affect a certain category of command (like the default one) and act almost like a child of theme, that's mean that the command can be called like it was a child but with a specific prefix ("--" by default). Like for example if i create a command info that gonna tell me every utils informations of the previous/parent command i would call it like that : -ping --info, the utility of that is that in the info executable the command argument gonna point into the previous command (in that case "ping"). The other difference between a static command and a children is that the static don't gonna be a part of the command but a part of the category.

Examples

const infoCommand = {
    entries: 'info',
    executable: ({message, command}) => {
        message.reply(`The categories of ${command.entries[0]} is ${command.categories.join('-')}`);
    }
}

handler.staticCommands.add(infoCommand);

If i type -ping --info into the chat and ping have other and utils into its categories the bot would reply to me with that message : The categories of ping is utils-other

How to use

To add a command you can use add function in handler.staticCommands.add(obj,categories)

Function description

Note : if categories is not defined the command gonna go into the default category (will affect every categories)

2. Voice handler

The voice handler add a queu and a bunch of functions and properties per guild to help through voice connection.

How to use

First you need to get the queu from a guildId by using

handler.voice.get(guildId);

Function Description

Get the queu of of the current guild and if the queu is not set, create it and attribute it.

What is a queu ?

A queu is an object to manipulates voices between guilds more easily.

Methods and properties of a queu

3. White/Black lists

The handler have a white and black list, the white list is here to take the lead on the black. That's mean that it gonna check the white list before the black for example if you put @everyone on the black list but you put your tag into the white list you will be able to triggered a command. In both list you can add tags (Rothoven#4388), roles (@everyone | moderator) and id (775453112064147516).

handler.autorised.addWhiteList(devs);
handler.autorised.addBlackList('@everyone');
handler.autorised.enabled = true;

That will allowed the people that are in devs but not everybody else.

4. Registering slash commands

For now this feature is really small and basic but it will be updated into the v4.0.0.

So for registering some slash command you will need to use handler.registerCommandsApplication(commands, guilds) after login the bot. You can see here that you can specify the guilds where the commands gonna be registered. (For thoses who wonders, the slash commands gonna be registered only if the command can be triggered by interaction)

Bot.login(/* your token */).then(() => { 
	handler.registerCommandsApplication(handler.commands)
});

Function declaration | Arguments | Types | Descritpion | |---|:---:|---| | commands | Array<command> | None | | guilds | Array<sttring> | The ids of the guilds |

5. Handler properties and methods.