reciple 5.4.1-pre.5 → 5.4.3

package/bin/mjs/reciple/flags.js

@@ -1,28 +0,0 @@
-import { rawVersion } from './version.js';
-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

@@ -1,28 +0,0 @@
-import { Logger, LogLevels } from 'fallout-utility';
-import { flags } from './flags.js';
-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

@@ -1,81 +0,0 @@
-import { CommandBuilderType } from './types/builders.js';
-import { MessageCommandBuilder } from './classes/builders/MessageCommandBuilder.js';
-import { SlashCommandBuilder } from './classes/builders/SlashCommandBuilder.js';
-import { normalizeArray } from 'discord.js';
-import { isSupportedVersion, version } from './version.js';
-import { existsSync, mkdirSync, readdirSync } from 'fs';
-import wildcard from 'wildcard-match';
-import { cwd } from './flags.js';
-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

@@ -1,23 +0,0 @@
-/**
- * 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/types/builders.js

@@ -1,8 +0,0 @@
-/**
- * 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

@@ -1,12 +0,0 @@
-/**
- * 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

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

package/bin/mjs/reciple/util.js

@@ -1,7 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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);
-}