reciple 5.4.0-pre.2 → 5.4.1-pre.2

package/bin/mjs/reciple/classes/builders/MessageCommandOptionBuilder.js

@@ -0,0 +1,67 @@
+/**
+ * Option builder for MessageCommandBuilder
+ */
+export class MessageCommandOptionBuilder {
+    name = '';
+    description = '';
+    required = false;
+    validator = () => true;
+    constructor(data) {
+        if (data?.name !== undefined)
+            this.setName(data.name);
+        if (data?.description !== undefined)
+            this.setDescription(data.description);
+        if (data?.required !== undefined)
+            this.setRequired(data.required);
+        if (data?.validator !== undefined)
+            this.setValidator(data.validator);
+    }
+    /**
+     * Set command option name
+     * @param name Option name
+     */
+    setName(name) {
+        if (typeof name !== 'string' || !name.match(/^[\w-]{1,32}$/))
+            throw new TypeError('name must be a string and match the regex /^[\\w-]{1,32}$/.');
+        this.name = name;
+        return this;
+    }
+    /**
+     * Set command option description
+     * @param description Option description
+     */
+    setDescription(description) {
+        if (!description || typeof description !== 'string')
+            throw new TypeError('description must be a string.');
+        this.description = description;
+        return this;
+    }
+    /**
+     * Set if this option is required
+     * @param required `true` if this option is required
+     */
+    setRequired(required) {
+        if (typeof required !== 'boolean')
+            throw new TypeError('required must be a boolean.');
+        this.required = required;
+        return this;
+    }
+    /**
+     * Set your custom function to validate given value for this option
+     * @param validator Custom function to validate value given for this option
+     */
+    setValidator(validator) {
+        if (!validator || typeof validator !== 'function')
+            throw new TypeError('validator must be a function.');
+        this.validator = validator;
+        return this;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            description: this.description,
+            required: this.required,
+            validator: this.validator,
+        };
+    }
+}

package/bin/mjs/reciple/classes/builders/SlashCommandBuilder.js

@@ -0,0 +1,204 @@
+import { CommandBuilderType } from '../../types/builders';
+import { isClass } from '../../util';
+import { normalizeArray, SlashCommandBuilder as DiscordJsSlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, SlashCommandBooleanOption, SlashCommandUserOption, SlashCommandChannelOption, SlashCommandRoleOption, SlashCommandAttachmentOption, SlashCommandMentionableOption, SlashCommandStringOption, SlashCommandIntegerOption, SlashCommandNumberOption, ApplicationCommandOptionType } from 'discord.js';
+/**
+ * Reciple builder for slash command
+ */
+export class SlashCommandBuilder extends DiscordJsSlashCommandBuilder {
+    type = CommandBuilderType.SlashCommand;
+    cooldown = 0;
+    requiredBotPermissions = [];
+    requiredMemberPermissions = [];
+    halt;
+    execute = () => { };
+    constructor(data) {
+        super();
+        if (data?.name !== undefined)
+            this.setName(data.name);
+        if (data?.description !== undefined)
+            this.setDescription(data.description);
+        if (data?.cooldown !== undefined)
+            this.setCooldown(Number(data?.cooldown));
+        if (data?.requiredBotPermissions !== undefined)
+            this.setRequiredBotPermissions(data.requiredBotPermissions);
+        if (data?.requiredMemberPermissions !== undefined)
+            this.setRequiredMemberPermissions(data.requiredMemberPermissions);
+        if (data?.halt !== undefined)
+            this.setHalt(this.halt);
+        if (data?.execute !== undefined)
+            this.setExecute(data.execute);
+        if (data?.nameLocalizations !== undefined)
+            this.setNameLocalizations(data.nameLocalizations);
+        if (data?.descriptionLocalizations !== undefined)
+            this.setDescriptionLocalizations(data.descriptionLocalizations);
+        if (data?.defaultMemberPermissions !== undefined)
+            this.setDefaultMemberPermissions(data.defaultMemberPermissions);
+        if (data?.dmPermission)
+            this.setDMPermission(true);
+        if (data?.defaultPermission)
+            this.setDefaultPermission(true);
+        if (data?.options) {
+            for (const option of data.options) {
+                SlashCommandBuilder.addOption(this, isClass(option) ? option : SlashCommandBuilder.resolveOption(option));
+            }
+        }
+    }
+    setCooldown(cooldown) {
+        this.cooldown = cooldown;
+        return this;
+    }
+    setRequiredBotPermissions(...permissions) {
+        this.requiredBotPermissions = normalizeArray(permissions);
+        return this;
+    }
+    setRequiredMemberPermissions(...permissions) {
+        this.requiredMemberPermissions = normalizeArray(permissions);
+        return this;
+    }
+    setHalt(halt) {
+        this.halt = halt ?? undefined;
+        return this;
+    }
+    setExecute(execute) {
+        if (!execute || typeof execute !== 'function')
+            throw new Error('execute must be a function.');
+        this.execute = execute;
+        return this;
+    }
+    /**
+     * Add option builder to command builder
+     */
+    static addOption(builder, option) {
+        if (option instanceof SlashCommandAttachmentOption) {
+            builder.addAttachmentOption(option);
+        }
+        else if (option instanceof SlashCommandBooleanOption) {
+            builder.addBooleanOption(option);
+        }
+        else if (option instanceof SlashCommandChannelOption) {
+            builder.addChannelOption(option);
+        }
+        else if (option instanceof SlashCommandIntegerOption) {
+            builder.addIntegerOption(option);
+        }
+        else if (option instanceof SlashCommandMentionableOption) {
+            builder.addMentionableOption(option);
+        }
+        else if (option instanceof SlashCommandNumberOption) {
+            builder.addNumberOption(option);
+        }
+        else if (option instanceof SlashCommandRoleOption) {
+            builder.addRoleOption(option);
+        }
+        else if (option instanceof SlashCommandStringOption) {
+            builder.addStringOption(option);
+        }
+        else if (option instanceof SlashCommandUserOption) {
+            builder.addUserOption(option);
+        }
+        else if (builder instanceof SlashCommandBuilder) {
+            if (option instanceof SlashCommandSubcommandBuilder) {
+                builder.addSubcommand(option);
+            }
+            else if (option instanceof SlashCommandSubcommandGroupBuilder) {
+                builder.addSubcommandGroup(option);
+            }
+        }
+        return builder;
+    }
+    /**
+     * Resolve option data
+     */
+    static resolveOption(option) {
+        let builder;
+        switch (option.type) {
+            case ApplicationCommandOptionType.Attachment:
+                builder = new SlashCommandAttachmentOption();
+                break;
+            case ApplicationCommandOptionType.Boolean:
+                builder = new SlashCommandBooleanOption();
+                break;
+            case ApplicationCommandOptionType.Channel:
+                builder = new SlashCommandChannelOption()
+                    .addChannelTypes(...(option.channelTypes ?? []));
+                break;
+            case ApplicationCommandOptionType.Integer:
+                builder = new SlashCommandIntegerOption()
+                    .addChoices(...(option.choices ?? []))
+                    .setAutocomplete(!!option.autocomplete);
+                if (option.maxValue)
+                    builder.setMaxValue(option.maxValue);
+                if (option.minValue)
+                    builder.setMinValue(option.minValue);
+                break;
+            case ApplicationCommandOptionType.Mentionable:
+                builder = new SlashCommandMentionableOption();
+                break;
+            case ApplicationCommandOptionType.Number:
+                builder = new SlashCommandNumberOption()
+                    .addChoices(...(option.choices ?? []))
+                    .setAutocomplete(!!option.autocomplete);
+                if (option.maxValue)
+                    builder.setMaxValue(option.maxValue);
+                if (option.minValue)
+                    builder.setMinValue(option.minValue);
+                break;
+            case ApplicationCommandOptionType.Role:
+                builder = new SlashCommandRoleOption();
+                break;
+            case ApplicationCommandOptionType.String:
+                builder = new SlashCommandStringOption()
+                    .addChoices(...(option.choices ?? []))
+                    .setAutocomplete(!!option.autocomplete);
+                if (option.maxLength)
+                    builder.setMaxLength(option.maxLength);
+                if (option.minLength)
+                    builder.setMinLength(option.minLength);
+                break;
+            case ApplicationCommandOptionType.User:
+                builder = new SlashCommandUserOption();
+                break;
+            case ApplicationCommandOptionType.Subcommand:
+                builder = new SlashCommandSubcommandBuilder();
+                for (const optionData of option.options) {
+                    this.addOption(builder, this.resolveOption(optionData));
+                }
+                break;
+            case ApplicationCommandOptionType.SubcommandGroup:
+                builder = new SlashCommandSubcommandGroupBuilder();
+                for (const subCommandData of option.options) {
+                    builder.addSubcommand(subCommandData instanceof SlashCommandSubcommandBuilder
+                        ? subCommandData
+                        : this.resolveOption(subCommandData));
+                }
+                break;
+            default:
+                throw new TypeError("Unknown option data");
+        }
+        if (!(builder instanceof SlashCommandSubcommandBuilder) && !(builder instanceof SlashCommandSubcommandGroupBuilder)
+            &&
+                option.type !== ApplicationCommandOptionType.Subcommand && option.type !== ApplicationCommandOptionType.SubcommandGroup) {
+            builder.setRequired(option.required ?? false);
+        }
+        return builder
+            .setName(option.name)
+            .setDescription(option.description)
+            .setNameLocalizations(option.nameLocalizations ?? null)
+            .setDescriptionLocalizations(option.descriptionLocalizations ?? null);
+    }
+    static resolveSlashCommand(commandData) {
+        return this.isSlashCommandBuilder(commandData) ? commandData : new SlashCommandBuilder(commandData);
+    }
+    /**
+     * Is a slash command builder
+     */
+    static isSlashCommandBuilder(builder) {
+        return builder instanceof SlashCommandBuilder;
+    }
+    /**
+     * Is a slash command execute data
+     */
+    static isSlashCommandExecuteData(executeData) {
+        return executeData.builder !== undefined && this.isSlashCommandBuilder(executeData.builder);
+    }
+}

package/bin/mjs/reciple/flags.js

@@ -0,0 +1,28 @@
+import { rawVersion } from './version';
+import { Command } from 'commander';
+/**
+ * Commander
+ */
+export const commander = new Command()
+    .name('reciple')
+    .description('Reciple.js - Discord.js handler cli')
+    .version(`v${rawVersion}`, '-v, --version')
+    .argument('[current-working-directory]', 'Change the current working directory')
+    .option('-t, --token <token>', 'Replace used bot token')
+    .option('-c, --config <config>', 'Change path to config file')
+    .option('-D, --debugmode', 'Enable debug mode')
+    .option('-y, --yes', 'Automatically agree to Reciple confirmation prompts')
+    .option('-v, --version', 'Display version')
+    .parse();
+/**
+ * Used flags
+ */
+export const flags = commander.opts();
+/**
+ * Token flag
+ */
+export const token = flags.token;
+/**
+ * Current working directory
+ */
+export const cwd = commander.args[0] || process.cwd();

package/bin/mjs/reciple/logger.js

@@ -0,0 +1,28 @@
+import { Logger, LogLevels } from 'fallout-utility';
+import { flags } from './flags';
+import chalk from 'chalk';
+/**
+ * Create new logger
+ * @param stringifyJSON stringify json objects in console
+ * @param debugmode display debug messages
+ * @param colorizeMessage add logger colours to messages
+ */
+export function createLogger(stringifyJSON, debugmode = false, colorizeMessage = true) {
+    return new Logger({
+        stringifyJSON: stringifyJSON,
+        enableDebugMode: flags.debugmode ?? debugmode,
+        loggerName: 'Main',
+        prefixes: {
+            [LogLevels.INFO]: (name) => `[${new Date().toLocaleTimeString(undefined, { hour12: false })}][${(name ? name + "/" : '') + "INFO"}]`,
+            [LogLevels.WARN]: (name) => `[${chalk.yellow(new Date().toLocaleTimeString(undefined, { hour12: false }))}][${chalk.yellow((name ? name + "/" : '') + "WARN")}]`,
+            [LogLevels.ERROR]: (name) => `[${chalk.red(new Date().toLocaleTimeString(undefined, { hour12: false }))}][${chalk.red((name ? name + "/" : '') + "ERROR")}]`,
+            [LogLevels.DEBUG]: (name) => `[${chalk.blue(new Date().toLocaleTimeString(undefined, { hour12: false }))}][${chalk.blue((name ? name + "/" : '') + "DEBUG")}]`
+        },
+        colorMessages: {
+            [LogLevels.INFO]: (message) => message,
+            [LogLevels.WARN]: (message) => !colorizeMessage ? message : chalk.yellow(message),
+            [LogLevels.ERROR]: (message) => !colorizeMessage ? message : chalk.red(message),
+            [LogLevels.DEBUG]: (message) => !colorizeMessage ? message : chalk.blue(message)
+        }
+    });
+}

package/bin/mjs/reciple/modules.js

@@ -0,0 +1,81 @@
+import { CommandBuilderType } from './types/builders';
+import { MessageCommandBuilder } from './classes/builders/MessageCommandBuilder';
+import { SlashCommandBuilder } from './classes/builders/SlashCommandBuilder';
+import { normalizeArray } from 'discord.js';
+import { isSupportedVersion, version } from './version';
+import { existsSync, mkdirSync, readdirSync } from 'fs';
+import wildcard from 'wildcard-match';
+import { cwd } from './flags';
+import path from 'path';
+/**
+ * Load modules from folder
+ * @param client Reciple client
+ * @param folder Modules folder
+ */
+export async function getModules(client, folder) {
+    const response = { commands: [], modules: [] };
+    const modulesDir = folder || path.join(cwd, 'modules');
+    if (!existsSync(modulesDir))
+        mkdirSync(modulesDir, { recursive: true });
+    const ignoredFiles = (client.config.ignoredFiles || []).map(file => file.endsWith('.js') ? file : `${file}.js`);
+    const scripts = readdirSync(modulesDir).filter(file => {
+        return file.endsWith('.js') && (!file.startsWith('_') && !file.startsWith('.')) && !ignoredFiles.some(f => wildcard(f)(file));
+    });
+    for (const script of scripts) {
+        const modulePath = path.join(modulesDir, script);
+        const commands = [];
+        let module_;
+        try {
+            const reqMod = require(modulePath);
+            module_ = reqMod?.default !== undefined ? reqMod.default : reqMod;
+            if (!module_?.versions.length)
+                throw new Error(`${modulePath} does not have supported versions.`);
+            const versions = normalizeArray([module_.versions]);
+            if (!client.config.disableVersionCheck && !versions.some(v => isSupportedVersion(v, version)))
+                throw new Error(`${modulePath} is unsupported; current version: ${version}; module supported versions: ` + versions.join(', ') ?? 'none');
+            if (!await Promise.resolve(module_.onStart(client)).catch(() => null))
+                throw new Error(script + ' onStart returned false or undefined.');
+            if (module_.commands) {
+                for (const command of module_.commands) {
+                    if (command.type === CommandBuilderType.MessageCommand) {
+                        commands.push(MessageCommandBuilder.resolveMessageCommand(command));
+                    }
+                    else if (command.type === CommandBuilderType.SlashCommand) {
+                        commands.push(SlashCommandBuilder.resolveSlashCommand(command));
+                    }
+                }
+            }
+        }
+        catch (error) {
+            if (client.isClientLogsEnabled()) {
+                client.logger.error(`Failed to load module ${script}`);
+                client.logger.error(error);
+            }
+            continue;
+        }
+        response.commands.push(...commands.filter((c) => {
+            if (!c.name) {
+                if (client.isClientLogsEnabled())
+                    client.logger.error(`A ${CommandBuilderType[c.type]} command name is not defined in ${modulePath}`);
+                return false;
+            }
+            if (c.type === CommandBuilderType.MessageCommand && c.options.length && c.options.some(o => !o.name)) {
+                if (client.isClientLogsEnabled())
+                    client.logger.error(`A ${CommandBuilderType[c.type]} option name is not defined in ${modulePath}`);
+                return false;
+            }
+            return true;
+        }));
+        response.modules.push({
+            script: module_,
+            info: {
+                filename: script,
+                versions: normalizeArray([module_.versions]),
+                path: modulePath
+            }
+        });
+        if (client.isClientLogsEnabled())
+            client.logger.info(`Loaded module ${modulePath}`);
+    }
+    return response;
+}

package/bin/mjs/reciple/permissions.js

@@ -0,0 +1,23 @@
+/**
+ * Check if the user has permissions to execute the given command name
+ * @param options options
+ */
+export function userHasCommandPermissions(options) {
+    const command = (options.commandPermissions?.enabled
+        ? options.commandPermissions?.commands.find(c => c.command.toLowerCase() === options.builder.name.toLowerCase())
+        : null)
+        ?? { permissions: options.builder.requiredMemberPermissions };
+    if (!command.permissions.length)
+        return true;
+    return options.memberPermissions ? options.memberPermissions.has(command.permissions) : false;
+}
+/**
+ * Check if the bot has the required permissions in a guild
+ * @param guild Guild
+ * @param requiredPermissions Required guild bot permissions
+ */
+export function botHasExecutePermissions(guild, requiredPermissions) {
+    if (!requiredPermissions?.length)
+        return true;
+    return guild?.members.me ? guild.members.me.permissions.has(requiredPermissions) : false;
+}

package/bin/mjs/reciple/registerApplicationCommands.js

@@ -0,0 +1,47 @@
+import { normalizeArray } from 'discord.js';
+import { SlashCommandBuilder } from './classes/builders/SlashCommandBuilder';
+/**
+ * Register application commands
+ * @param options Register application commands options
+ */
+export async function registerApplicationCommands(options) {
+    const client = options.client;
+    const guilds = normalizeArray(options.guilds);
+    const commands = Object.values(options.commands ?? client.commands.slashCommands).map(cmd => {
+        if (typeof cmd?.toJSON == 'undefined')
+            return cmd;
+        cmd = cmd;
+        if (SlashCommandBuilder.isSlashCommandBuilder(cmd) && client.config.commands.slashCommand.setRequiredPermissions) {
+            const permissions = client.config.commands.slashCommand.permissions.enabled
+                ? client.config.commands.slashCommand.permissions.commands.find(cmd_ => cmd_.command.toLowerCase() === cmd.name.toLowerCase())?.permissions
+                : undefined;
+            if (permissions) {
+                cmd.setRequiredMemberPermissions(...permissions);
+                if (client.isClientLogsEnabled())
+                    client.logger.debug(`Set required permissions for ${cmd.name}`);
+            }
+            client.commands.slashCommands[cmd.name] = cmd;
+        }
+        return cmd.toJSON();
+    }) ?? [];
+    if (!client.isReady())
+        throw new Error('Client is not ready');
+    if (!guilds || !guilds?.length) {
+        client.application?.commands.set(commands).then(() => {
+            if (client.isClientLogsEnabled())
+                client.logger.warn('No guilds were specified for application commands. Registered application commands globally.');
+        });
+    }
+    else {
+        if (client.isClientLogsEnabled())
+            client.logger.warn(`Registering ${commands.length} application commands to ${guilds.length} guild(s).`);
+        for (const guild of guilds) {
+            if (!guild)
+                continue;
+            client.application?.commands.set(commands, guild).then(() => {
+                if (client.isClientLogsEnabled())
+                    client.logger.warn(`Registered ${commands.length} application command(s) for ${guild}.`);
+            });
+        }
+    }
+}

package/bin/mjs/reciple/types/builders.js

@@ -0,0 +1,8 @@
+/**
+ * Types of command builders
+ */
+export var CommandBuilderType;
+(function (CommandBuilderType) {
+    CommandBuilderType[CommandBuilderType["MessageCommand"] = 0] = "MessageCommand";
+    CommandBuilderType[CommandBuilderType["SlashCommand"] = 1] = "SlashCommand";
+})(CommandBuilderType || (CommandBuilderType = {}));

package/bin/mjs/reciple/types/commands.js

@@ -0,0 +1,12 @@
+/**
+ * Command halt reasons
+ */
+export var CommandHaltReason;
+(function (CommandHaltReason) {
+    CommandHaltReason[CommandHaltReason["Error"] = 0] = "Error";
+    CommandHaltReason[CommandHaltReason["Cooldown"] = 1] = "Cooldown";
+    CommandHaltReason[CommandHaltReason["InvalidArguments"] = 2] = "InvalidArguments";
+    CommandHaltReason[CommandHaltReason["MissingArguments"] = 3] = "MissingArguments";
+    CommandHaltReason[CommandHaltReason["MissingMemberPermissions"] = 4] = "MissingMemberPermissions";
+    CommandHaltReason[CommandHaltReason["MissingBotPermissions"] = 5] = "MissingBotPermissions";
+})(CommandHaltReason || (CommandHaltReason = {}));

package/bin/mjs/reciple/types/paramOptions.js

@@ -0,0 +1 @@
+export {};

package/bin/mjs/reciple/util.js

@@ -0,0 +1,7 @@
+export function isClass(object) {
+    const isClassConstructor = object.constructor && object.constructor.toString().substring(0, 5) === 'class';
+    if (object.prototype === undefined)
+        return isClassConstructor;
+    const isPrototypeClassConstructor = object.prototype.constructor && object.prototype.constructor.toString && object.prototype.constructor.toString().substring(0, 5) === 'class';
+    return isClassConstructor || isPrototypeClassConstructor;
+}

package/bin/mjs/reciple/version.js

@@ -0,0 +1,38 @@
+import semver from 'semver';
+/**
+ * Current reciple version
+ */
+export const version = `${semver.coerce(require('../../package.json').version)}`;
+/**
+ * Current reciple version from package.json
+ */
+export const rawVersion = require('../../package.json').version;
+/**
+ * Check if the version is valid
+ * @param ver Version string to validated
+ */
+export function isValidVersion(ver) {
+    return semver.valid(semver.coerce(ver)) !== null;
+}
+/**
+ * Parse the version string
+ * @param ver Parse version string
+ */
+export function parseVersion(ver) {
+    if (!isValidVersion(ver))
+        throw new TypeError(`Invalid version: ${ver}`);
+    return semver.parse(ver);
+}
+/**
+ * Check if the given version is supported by the given version range
+ * @param versionRange Version range
+ * @param supportedVersion Version to match given version range
+ */
+export function isSupportedVersion(versionRange, supportedVersion) {
+    supportedVersion = supportedVersion || version;
+    if (!isValidVersion(versionRange))
+        throw new TypeError(`Invalid version: ${versionRange}`);
+    if (!isValidVersion(supportedVersion))
+        throw new TypeError(`Invalid supported version: ${supportedVersion}`);
+    return semver.satisfies(supportedVersion, versionRange);
+}

package/bin/types/index.d.ts

@@ -0,0 +1,17 @@
+export * from './reciple/classes/CommandCooldownManager';
+export * from './reciple/classes/MessageCommandOptionManager';
+export * from './reciple/classes/RecipleClient';
+export * from './reciple/classes/RecipleConfig';
+export * from './reciple/classes/builders/MessageCommandBuilder';
+export * from './reciple/classes/builders/MessageCommandOptionBuilder';
+export * from './reciple/classes/builders/SlashCommandBuilder';
+export * from './reciple/types/builders';
+export * from './reciple/types/commands';
+export * from './reciple/types/paramOptions';
+export * from './reciple/flags';
+export * from './reciple/logger';
+export * from './reciple/modules';
+export * from './reciple/permissions';
+export * from './reciple/registerApplicationCommands';
+export * from './reciple/util';
+export * from './reciple/version';

package/bin/{reciple → types/reciple}/classes/RecipleClient.d.ts

@@ -1,7 +1,7 @@
 import { MessageCommandBuilder, MessageCommandExecuteData, MessageCommandHaltData } from './builders/MessageCommandBuilder';
 import { SlashCommandBuilder, SlashCommandExecuteData, SlashCommandHaltData } from './builders/SlashCommandBuilder';
-import { ApplicationCommandBuilder } from '../registerApplicationCommands';
 import { AnyCommandBuilder, AnyCommandData, AnySlashCommandBuilder, CommandBuilderType } from '../types/builders';
+import { ApplicationCommandBuilder } from '../registerApplicationCommands';
 import { AnyCommandExecuteData, AnyCommandHaltData } from '../types/commands';
 import { CommandCooldownManager } from './CommandCooldownManager';
 import { RecipleClientAddModuleOptions } from '../types/paramOptions';