reciple 1.0.0

package/bin/bin.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Config_1 = require("./reciple/classes/Config");
+const Client_1 = require("./reciple/classes/Client");
+const fs_1 = require("fs");
+const fallout_utility_1 = require("fallout-utility");
+if ((0, fs_1.readdirSync)('./').length > 0 && !(0, fs_1.existsSync)('./reciple.yml')) {
+    const ask = (0, fallout_utility_1.input)('This directory does not contain reciple.yml. Would you like to init axis here? [y/n] ');
+    if (ask !== 'y')
+        process.exit(0);
+}
+const config = new Config_1.RecipleConfig('./reciple.yml').parseConfig().getConfig();
+const client = new Client_1.RecipleClient(Object.assign({ config: config }, config.client));
+(() => __awaiter(void 0, void 0, void 0, function* () {
+    yield client.startModules();
+    client.on('ready', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        client.logger.warn(`Logged in as ${((_a = client.user) === null || _a === void 0 ? void 0 : _a.tag) || 'Unknown'}!`);
+        yield client.loadModules();
+        client.addCommandListeners();
+    }));
+    client.login(config.token);
+}))();

package/bin/index.d.ts

@@ -0,0 +1,10 @@
+export * from './reciple/classes/Client';
+export * from './reciple/classes/Config';
+export * from './reciple/classes/builders/MessageCommandBuilder';
+export * from './reciple/classes/builders/InteractionCommandBuilder';
+export * from './reciple/commandPermissions';
+export * from './reciple/flags';
+export * from './reciple/logger';
+export * from './reciple/modules';
+export * from './reciple/registerInteractionCommands';
+export * from './reciple/version';

package/bin/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./reciple/classes/Client"), exports);
+__exportStar(require("./reciple/classes/Config"), exports);
+__exportStar(require("./reciple/classes/builders/MessageCommandBuilder"), exports);
+__exportStar(require("./reciple/classes/builders/InteractionCommandBuilder"), exports);
+__exportStar(require("./reciple/commandPermissions"), exports);
+__exportStar(require("./reciple/flags"), exports);
+__exportStar(require("./reciple/logger"), exports);
+__exportStar(require("./reciple/modules"), exports);
+__exportStar(require("./reciple/registerInteractionCommands"), exports);
+__exportStar(require("./reciple/version"), exports);

package/bin/reciple/classes/Client.d.ts

@@ -0,0 +1,34 @@
+import { Client, ClientEvents, ClientOptions, Interaction, Message } from 'discord.js';
+import { Logger as LoggerConstructor } from 'fallout-utility';
+import { MessageCommandBuilder, RecipleMessageCommandExecute } from './builders/MessageCommandBuilder';
+import { InteractionCommandBuilder, RecipleInteractionCommandExecute } from './builders/InteractionCommandBuilder';
+import { RecipleScript } from '../modules';
+import { Config } from './Config';
+export interface RecipleClientOptions extends ClientOptions {
+    config: Config;
+}
+export interface RecipleClientCommands {
+    MESSAGE_COMMANDS: {
+        [key: string]: MessageCommandBuilder;
+    };
+    INTERACTION_COMMANDS: {
+        [key: string]: InteractionCommandBuilder;
+    };
+}
+export interface RecipleClientEvents extends ClientEvents {
+    recipleMessageCommandCreate: [command: RecipleMessageCommandExecute];
+    recipleInteractionCommandCreate: [command: RecipleInteractionCommandExecute];
+}
+export declare class RecipleClient extends Client {
+    config?: Config;
+    commands: RecipleClientCommands;
+    modules: RecipleScript[];
+    logger: LoggerConstructor;
+    version: string;
+    constructor(options: RecipleClientOptions);
+    startModules(): Promise<RecipleClient>;
+    loadModules(): Promise<RecipleClient>;
+    addCommandListeners(): RecipleClient;
+    messageCommandExecute(message: Message): Promise<RecipleClient>;
+    interactionCommandExecute(interaction: Interaction): Promise<RecipleClient>;
+}

package/bin/reciple/classes/Client.js

@@ -0,0 +1,131 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecipleClient = void 0;
+const discord_js_1 = require("discord.js");
+const fallout_utility_1 = require("fallout-utility");
+const MessageCommandBuilder_1 = require("./builders/MessageCommandBuilder");
+const InteractionCommandBuilder_1 = require("./builders/InteractionCommandBuilder");
+const registerInteractionCommands_1 = require("../registerInteractionCommands");
+const logger_1 = require("../logger");
+const modules_1 = require("../modules");
+const version_1 = require("../version");
+const commandPermissions_1 = require("../commandPermissions");
+class RecipleClient extends discord_js_1.Client {
+    constructor(options) {
+        super(options);
+        this.commands = { MESSAGE_COMMANDS: {}, INTERACTION_COMMANDS: {} };
+        this.modules = [];
+        this.logger = (0, logger_1.logger)(false);
+        this.version = version_1.version;
+        if (!options.config)
+            throw new Error('Config is not defined.');
+        this.config = options.config;
+        if (this.config.fileLogging.enabled)
+            this.logger.logFile(this.config.fileLogging.logFilePath, false);
+        this.logger.info('Reciple Client v' + version_1.version + ' is starting...');
+    }
+    startModules() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.info('Loading modules...');
+            const modules = yield (0, modules_1.loadModules)(this);
+            if (!modules)
+                throw new Error('Failed to load modules.');
+            this.modules = modules.modules.map(m => m.script);
+            for (const command of modules.commands) {
+                if (!command.name)
+                    continue;
+                if (command instanceof MessageCommandBuilder_1.MessageCommandBuilder) {
+                    this.commands.MESSAGE_COMMANDS[command.name] = command;
+                }
+                else if (command instanceof InteractionCommandBuilder_1.InteractionCommandBuilder) {
+                    this.commands.INTERACTION_COMMANDS[command.name] = command;
+                }
+            }
+            this.logger.info(`${Object.keys(this.commands.MESSAGE_COMMANDS).length} message commands loaded.`);
+            this.logger.info(`${Object.keys(this.commands.INTERACTION_COMMANDS).length} interaction commands loaded.`);
+            return this;
+        });
+    }
+    loadModules() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const module_ of this.modules) {
+                if (typeof (module_ === null || module_ === void 0 ? void 0 : module_.onLoad) === 'function')
+                    yield Promise.resolve(module_.onLoad(this));
+            }
+            this.logger.info(`${this.modules.length} modules loaded.`);
+            if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.commands.interactionCommand.registerCommands)
+                yield (0, registerInteractionCommands_1.registerInteractionCommands)(this);
+            return this;
+        });
+    }
+    addCommandListeners() {
+        var _a, _b;
+        if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.commands.messageCommand.enabled)
+            this.on('messageCreate', (message) => { this.messageCommandExecute(message); });
+        if ((_b = this.config) === null || _b === void 0 ? void 0 : _b.commands.interactionCommand.enabled)
+            this.on('interactionCreate', (interaction) => { this.interactionCommandExecute(interaction); });
+        return this;
+    }
+    messageCommandExecute(message) {
+        var _a, _b, _c, _d, _e;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!message.content)
+                return this;
+            const parseCommand = (0, fallout_utility_1.getCommand)(message.content, ((_a = this.config) === null || _a === void 0 ? void 0 : _a.prefix) || '!', ((_b = this.config) === null || _b === void 0 ? void 0 : _b.commands.messageCommand.commandArgumentSeparator) || ' ');
+            if (parseCommand && parseCommand.command) {
+                const command = this.commands.MESSAGE_COMMANDS[parseCommand.command];
+                if (command && (0, commandPermissions_1.commandPermissions)(command.name, ((_c = message.member) === null || _c === void 0 ? void 0 : _c.permissions) || null, (_d = this.config) === null || _d === void 0 ? void 0 : _d.permissions.messageCommands)) {
+                    if (!command.allowExecuteInDM && message.channel.type === 'DM')
+                        return this;
+                    if (!command.allowExecuteByBots && (message.author.bot || message.author.system))
+                        return this;
+                    if (command.validateOptions && !command.getCommandOptionValues(parseCommand)) {
+                        yield message.reply(((_e = this.config) === null || _e === void 0 ? void 0 : _e.messages.notEnoughArguments) || 'Not enough arguments.').catch((err) => this.logger.error(err));
+                        return this;
+                    }
+                    const options = {
+                        message: message,
+                        command: parseCommand,
+                        builder: command,
+                        client: this
+                    };
+                    yield Promise.resolve(command.execute(options));
+                    this.emit('recipleMessageCommandCreate', options);
+                }
+            }
+            return this;
+        });
+    }
+    interactionCommandExecute(interaction) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!interaction || !interaction.isCommand())
+                return this;
+            const command = this.commands.INTERACTION_COMMANDS[interaction.commandName];
+            if (command && (0, commandPermissions_1.commandPermissions)(command.name, interaction.memberPermissions, (_a = this.config) === null || _a === void 0 ? void 0 : _a.permissions.interactionCommands)) {
+                if (!command.allowExecuteInDM && interaction.member === null)
+                    return this;
+                const options = {
+                    interaction: interaction,
+                    command: command,
+                    builder: command,
+                    client: this
+                };
+                yield Promise.resolve(command.execute(options));
+                this.emit('recipleInteractionCommandCreate', options);
+            }
+            return this;
+        });
+    }
+}
+exports.RecipleClient = RecipleClient;

package/bin/reciple/classes/Config.d.ts

@@ -0,0 +1,55 @@
+import { ClientOptions, MessageOptions, PermissionResolvable } from 'discord.js';
+export interface Config {
+    token: string;
+    prefix: string;
+    commands: {
+        messageCommand: {
+            enabled: boolean;
+            commandArgumentSeparator: string;
+        };
+        interactionCommand: {
+            enabled: boolean;
+            registerCommands: boolean;
+            guilds: string[] | string;
+        };
+    };
+    permissions: {
+        messageCommands: {
+            enabled: boolean;
+            commands: {
+                command: string;
+                permissions: PermissionResolvable[];
+            }[];
+        };
+        interactionCommands: {
+            enabled: boolean;
+            commands: {
+                command: string;
+                permissions: PermissionResolvable[];
+            }[];
+        };
+    };
+    ignoredChannels: {
+        enabled: boolean;
+        convertToAllowList: boolean;
+        channels: string[];
+    };
+    fileLogging: {
+        enabled: boolean;
+        logFilePath: string;
+    };
+    client: ClientOptions;
+    messages: {
+        [key: string]: MessageOptions | string;
+    };
+    modulesFolder: string;
+}
+export declare class RecipleConfig {
+    config?: Config;
+    configPath: string;
+    constructor(configPath: string);
+    parseConfig(): RecipleConfig;
+    getConfig(): Config;
+    parseToken(askIfNull?: boolean): string | null;
+    private askToken;
+}

package/bin/reciple/classes/Config.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecipleConfig = void 0;
+const fallout_utility_1 = require("fallout-utility");
+const fs_1 = require("fs");
+const flags_1 = require("../flags");
+const path_1 = __importDefault(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+class RecipleConfig {
+    constructor(configPath) {
+        this.configPath = './reciple.yml';
+        if (!configPath)
+            throw new Error('Config path is not defined');
+        this.configPath = configPath;
+    }
+    parseConfig() {
+        if (!(0, fs_1.existsSync)(this.configPath)) {
+            const defaultConfigPath = path_1.default.join(__dirname, '../../../resource/reciple.yml');
+            if (!(0, fs_1.existsSync)(defaultConfigPath))
+                throw new Error('Default Config file not found. Please reinstall Reciple.');
+            const defaultConfig = (0, fs_1.readFileSync)(defaultConfigPath, 'utf-8');
+            (0, fs_1.writeFileSync)(this.configPath, defaultConfig, 'utf-8');
+            if (!(0, fs_1.existsSync)(this.configPath))
+                throw new Error('Failed to create config file.');
+            this.config = yaml_1.default.parse(defaultConfig);
+            if (this.config && this.config.token === 'TOKEN') {
+                this.config.token = this.askToken() || this.config.token;
+                (0, fs_1.writeFileSync)(this.configPath, (0, fallout_utility_1.replaceAll)(defaultConfig, 'TOKEN', this.config.token), 'utf-8');
+            }
+            return this;
+        }
+        if (!(0, fs_1.existsSync)(this.configPath))
+            throw new Error('Failed to read config file.');
+        const config = (0, fs_1.readFileSync)(this.configPath, 'utf-8');
+        this.config = yaml_1.default.parse(config);
+        return this;
+    }
+    getConfig() {
+        if (!this.config)
+            throw new Error('Config is not parsed.');
+        this.config.token = this.parseToken() || 'TOKEN';
+        return this.config;
+    }
+    parseToken(askIfNull = true) {
+        let token = flags_1.token || null;
+        if (token)
+            return token;
+        if (!this.config)
+            return token;
+        if (!this.config.token)
+            return token || (askIfNull ? this.askToken() : null);
+        const envToken = this.config.token.toString().split(':');
+        if (envToken.length === 2 && envToken[0].toLocaleLowerCase() === 'env' && envToken[1]) {
+            token = process.env[envToken[1]] || null;
+        }
+        else {
+            token = this.config.token;
+        }
+        return token || (askIfNull ? this.askToken() : null);
+    }
+    askToken() {
+        return flags_1.token || (0, fallout_utility_1.input)({ 'text': 'Bot Token >>> ', echo: '*', repeatIfEmpty: true, exitStrings: ['exit', 'quit', ''], sigint: true }) || null;
+    }
+}
+exports.RecipleConfig = RecipleConfig;

package/bin/reciple/classes/builders/InteractionCommandBuilder.d.ts

@@ -0,0 +1,15 @@
+import { SlashCommandBuilder } from '@discordjs/builders';
+import { CommandInteraction } from 'discord.js';
+import { RecipleClient } from '../Client';
+export interface RecipleInteractionCommandExecute {
+    interaction: CommandInteraction;
+    command: InteractionCommandBuilder;
+    builder: InteractionCommandBuilder;
+    client: RecipleClient;
+}
+export declare class InteractionCommandBuilder extends SlashCommandBuilder {
+    allowExecuteInDM: boolean;
+    execute: (options: RecipleInteractionCommandExecute) => void;
+    setAllowExecuteInDM(allowExecuteInDM: boolean): InteractionCommandBuilder;
+    setExecute(execute: (options: RecipleInteractionCommandExecute) => void): InteractionCommandBuilder;
+}

package/bin/reciple/classes/builders/InteractionCommandBuilder.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InteractionCommandBuilder = void 0;
+const builders_1 = require("@discordjs/builders");
+class InteractionCommandBuilder extends builders_1.SlashCommandBuilder {
+    constructor() {
+        super(...arguments);
+        this.allowExecuteInDM = true;
+        this.execute = (options) => { };
+    }
+    setAllowExecuteInDM(allowExecuteInDM) {
+        if (typeof allowExecuteInDM !== 'boolean')
+            throw new Error('allowExecuteInDM must be a boolean.');
+        this.allowExecuteInDM = allowExecuteInDM;
+        return this;
+    }
+    setExecute(execute) {
+        if (!execute || typeof execute !== 'function')
+            throw new Error('execute must be a function.');
+        this.execute = execute;
+        return this;
+    }
+}
+exports.InteractionCommandBuilder = InteractionCommandBuilder;

package/bin/reciple/classes/builders/MessageCommandBuilder.d.ts

@@ -0,0 +1,47 @@
+import { Message } from 'discord.js';
+import { RecipleClient } from '../Client';
+export interface CommandMessage {
+    command?: string;
+    args?: string[];
+    raw?: string;
+    prefix?: string;
+    separator?: string;
+}
+export interface RecipleMessageCommandExecute {
+    message: Message;
+    command: CommandMessage;
+    builder: MessageCommandBuilder;
+    client: RecipleClient;
+}
+export interface MessageCommandValidatedOption {
+    name: string;
+    value: any;
+    required: boolean;
+}
+export declare class MessageOption {
+    name: string;
+    description: string;
+    required: boolean;
+    validate: (value: any) => boolean;
+    setName(name: string): MessageOption;
+    setDescription(description: string): MessageOption;
+    setRequired(required: boolean): MessageOption;
+    setValidator(validator: (value: any) => boolean): MessageOption;
+}
+export declare class MessageCommandBuilder {
+    name: string;
+    description: string;
+    options: MessageOption[];
+    validateOptions: boolean;
+    allowExecuteInDM: boolean;
+    allowExecuteByBots: boolean;
+    execute: (options: RecipleMessageCommandExecute) => void;
+    setName(name: string): MessageCommandBuilder;
+    setAllowExecuteInDM(allowExecuteInDM: boolean): MessageCommandBuilder;
+    setAllowExecuteByBots(allowExecuteByBots: boolean): MessageCommandBuilder;
+    setDescription(description: string): MessageCommandBuilder;
+    setExecute(execute: (options: RecipleMessageCommandExecute) => void): MessageCommandBuilder;
+    addOption(option: MessageOption | ((constructor: MessageOption) => MessageOption)): MessageCommandBuilder;
+    setValidateOptions(validateOptions: boolean): MessageCommandBuilder;
+    getCommandOptionValues(options: CommandMessage): undefined | MessageCommandValidatedOption[];
+}

package/bin/reciple/classes/builders/MessageCommandBuilder.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageCommandBuilder = exports.MessageOption = void 0;
+class MessageOption {
+    constructor() {
+        this.name = '';
+        this.description = '';
+        this.required = true;
+        this.validate = () => true;
+    }
+    setName(name) {
+        if (typeof name !== 'string' || !name.match(/^[\w-]{1,32}$/))
+            throw new Error('name must be a string and match the regex /^[\\w-]{1,32}$/.');
+        this.name = name;
+        return this;
+    }
+    setDescription(description) {
+        if (!description || typeof description !== 'string')
+            throw new Error('description must be a string.');
+        this.description = description;
+        return this;
+    }
+    setRequired(required) {
+        if (typeof required !== 'boolean')
+            throw new Error('required must be a boolean.');
+        this.required = required;
+        return this;
+    }
+    setValidator(validator) {
+        if (!validator || typeof validator !== 'function')
+            throw new Error('validator must be a function.');
+        this.validate = validator;
+        return this;
+    }
+}
+exports.MessageOption = MessageOption;
+class MessageCommandBuilder {
+    constructor() {
+        this.name = '';
+        this.description = '';
+        this.options = [];
+        this.validateOptions = false;
+        this.allowExecuteInDM = true;
+        this.allowExecuteByBots = false;
+        this.execute = (options) => { };
+    }
+    setName(name) {
+        if (!name || typeof name !== 'string' || !name.match(/^[\w-]{1,32}$/))
+            throw new Error('name must be a string and match the regex /^[\\w-]{1,32}$/');
+        this.name = name;
+        return this;
+    }
+    setAllowExecuteInDM(allowExecuteInDM) {
+        if (typeof allowExecuteInDM !== 'boolean')
+            throw new Error('allowExecuteInDM must be a boolean.');
+        this.allowExecuteInDM = allowExecuteInDM;
+        return this;
+    }
+    setAllowExecuteByBots(allowExecuteByBots) {
+        if (typeof allowExecuteByBots !== 'boolean')
+            throw new Error('allowExecuteByBots must be a boolean.');
+        this.allowExecuteByBots = allowExecuteByBots;
+        return this;
+    }
+    setDescription(description) {
+        if (!description || typeof description !== 'string')
+            throw new Error('description must be a string.');
+        this.description = description;
+        return this;
+    }
+    setExecute(execute) {
+        if (!execute || typeof execute !== 'function')
+            throw new Error('execute must be a function.');
+        this.execute = execute;
+        return this;
+    }
+    addOption(option) {
+        if (!option)
+            throw new Error('option must be a MessageOption.');
+        option = typeof option === 'function' ? option(new MessageOption()) : option;
+        if (this.options.find(o => o.name === option.name))
+            throw new Error('option with name "' + option.name + '" already exists.');
+        if (this.options.length > 0 && !this.options[this.options.length - 1 < 0 ? 0 : this.options.length - 1].required && option.required)
+            throw new Error('All required options must be before optional options.');
+        this.options = [...this.options, option];
+        return this;
+    }
+    setValidateOptions(validateOptions) {
+        if (typeof validateOptions !== 'boolean')
+            throw new Error('validateOptions must be a boolean.');
+        this.validateOptions = validateOptions;
+        return this;
+    }
+    getCommandOptionValues(options) {
+        const args = options.args || [];
+        const required = this.options.filter(o => o.required);
+        const optional = this.options.filter(o => !o.required);
+        if (required.length > args.length)
+            return;
+        let i = 0;
+        let result = [];
+        for (const option of [...required, ...optional]) {
+            const arg = args[i];
+            if (!arg && option.required)
+                return;
+            if (!option.validate(arg))
+                return;
+            result = [...result, { name: option.name, value: arg, required: option.required }];
+            i++;
+        }
+        return result;
+    }
+}
+exports.MessageCommandBuilder = MessageCommandBuilder;

package/bin/reciple/commandPermissions.d.ts

@@ -0,0 +1,3 @@
+import { Permissions } from "discord.js";
+import { Config } from "./classes/Config";
+export declare function commandPermissions(commandName: string, member: Permissions | null, permissions?: Config['permissions']['messageCommands'] | Config['permissions']['interactionCommands']): boolean;

package/bin/reciple/commandPermissions.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commandPermissions = void 0;
+function commandPermissions(commandName, member, permissions) {
+    if (!(permissions === null || permissions === void 0 ? void 0 : permissions.enabled))
+        return true;
+    const command = permissions.commands.find(c => c.command.toLowerCase() === commandName.toLowerCase());
+    if (!command)
+        return true;
+    if (!command.permissions.length)
+        return true;
+    return member ? member.has(command.permissions) : false;
+}
+exports.commandPermissions = commandPermissions;

package/bin/reciple/flags.d.ts

@@ -0,0 +1 @@
+export declare const token: any;

package/bin/reciple/flags.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.token = void 0;
+const commander_1 = require("commander");
+const flags = commander_1.program
+    .option('-t, --token <token>', 'Replace used bot token')
+    .parse().opts();
+exports.token = flags.token;

package/bin/reciple/logger.d.ts

@@ -0,0 +1,2 @@
+import { Logger } from 'fallout-utility';
+export declare function logger(stringifyJSON: boolean): Logger;

package/bin/reciple/logger.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const fallout_utility_1 = require("fallout-utility");
+function logger(stringifyJSON) {
+    return new fallout_utility_1.Logger("Main", {
+        addPrefixToEveryJsonNewLines: stringifyJSON,
+        stringifyJSON: stringifyJSON,
+    });
+}
+exports.logger = logger;

package/bin/reciple/modules.d.ts

@@ -0,0 +1,23 @@
+import { RecipleClient } from './classes/Client';
+import { MessageCommandBuilder } from './classes/builders/MessageCommandBuilder';
+import { InteractionCommandBuilder } from './classes/builders/InteractionCommandBuilder';
+export declare type recipleCommands = (MessageCommandBuilder | InteractionCommandBuilder)[];
+export declare type loadedModules = {
+    commands: recipleCommands;
+    modules: RecipleModule[];
+};
+export interface RecipleScript {
+    versions: string | string[];
+    commands?: (MessageCommandBuilder | InteractionCommandBuilder)[];
+    onLoad?: (reciple: RecipleClient) => void;
+    onStart: (reciple: RecipleClient) => boolean;
+}
+export interface RecipleModule {
+    script: RecipleScript;
+    info: {
+        filename: string;
+        versions: string[];
+        path: string;
+    };
+}
+export declare function loadModules(client: RecipleClient): Promise<loadedModules>;