reciple 1.0.0

package/bin/reciple/modules.js

@@ -0,0 +1,77 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadModules = void 0;
+const fs_1 = require("fs");
+const MessageCommandBuilder_1 = require("./classes/builders/MessageCommandBuilder");
+const InteractionCommandBuilder_1 = require("./classes/builders/InteractionCommandBuilder");
+const path_1 = __importDefault(require("path"));
+function loadModules(client) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = { commands: [], modules: [] };
+        const modulesDir = ((_a = client.config) === null || _a === void 0 ? void 0 : _a.modulesFolder) || './modules';
+        const logger = client.logger;
+        if (!(0, fs_1.existsSync)(modulesDir))
+            (0, fs_1.mkdirSync)(modulesDir, { recursive: true });
+        const scripts = (0, fs_1.readdirSync)(modulesDir).filter(file => file.endsWith('.js') && (!file.startsWith('_') && !file.startsWith('.')));
+        for (const script of scripts) {
+            const modulePath = path_1.default.resolve(modulesDir, script);
+            const commands = [];
+            let module_;
+            try {
+                module_ = require(modulePath);
+                if (!module_.versions || !(typeof module_.versions === 'object' ? module_.versions : [module_.versions]).includes(client.version))
+                    throw new Error('Module versions is not defined or unsupported.');
+                if (!module_.onStart(client))
+                    throw new Error(script + ' onStart is not defined or returned false.');
+                if (module_.commands) {
+                    for (const command of module_.commands) {
+                        if (!(command instanceof MessageCommandBuilder_1.MessageCommandBuilder) && !(command instanceof InteractionCommandBuilder_1.InteractionCommandBuilder)) {
+                            continue;
+                        }
+                        commands.push(command);
+                    }
+                }
+            }
+            catch (error) {
+                logger.error(`Failed to load module ${script}`);
+                logger.error(error);
+                continue;
+            }
+            response.commands = response.commands.concat(commands.filter((c) => {
+                if (!c.name) {
+                    logger.error(`A message command name is not defined in ${script}`);
+                    return false;
+                }
+                if (c instanceof MessageCommandBuilder_1.MessageCommandBuilder && c.options.some(o => !o.name)) {
+                    logger.error(`A message command option name is not defined in ${script}`);
+                    return false;
+                }
+                return true;
+            }));
+            response.modules.push({
+                script: module_,
+                info: {
+                    filename: script,
+                    versions: typeof module_.versions === 'string' ? [module_.versions] : module_.versions,
+                    path: modulePath
+                }
+            });
+            logger.info(`Loaded module ${script}`);
+        }
+        return response;
+    });
+}
+exports.loadModules = loadModules;

package/bin/reciple/registerInteractionCommands.d.ts

@@ -0,0 +1,2 @@
+import { RecipleClient } from "./classes/Client";
+export declare function registerInteractionCommands(client: RecipleClient): Promise<void>;

package/bin/reciple/registerInteractionCommands.js

@@ -0,0 +1,35 @@
+"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.registerInteractionCommands = void 0;
+function registerInteractionCommands(client) {
+    var _a, _b, _c;
+    return __awaiter(this, void 0, void 0, function* () {
+        const commands = Object.values(client.commands.INTERACTION_COMMANDS).map(c => c.toJSON());
+        if (!commands.length) {
+            client.logger.warn('No interaction commands found.');
+            return;
+        }
+        if (!((_a = client.config) === null || _a === void 0 ? void 0 : _a.commands.interactionCommand.guilds.length)) {
+            yield ((_b = client.application) === null || _b === void 0 ? void 0 : _b.commands.set(commands).catch(e => client.logger.error(e)));
+            client.logger.warn('No guilds were specified for interaction commands. Registered commands for all guilds.');
+        }
+        else {
+            const guilds = typeof client.config.commands.interactionCommand.guilds === 'string' ? [client.config.commands.interactionCommand.guilds] : client.config.commands.interactionCommand.guilds;
+            client.logger.warn(`Registering ${commands.length} interaction commands for ${guilds.length} guild(s).`);
+            for (const guild of guilds) {
+                yield ((_c = client.application) === null || _c === void 0 ? void 0 : _c.commands.set(commands, guild).catch(e => client.logger.error(e)));
+                client.logger.warn(`Registered ${commands.length} interaction commands for ${guild}.`);
+            }
+        }
+    });
+}
+exports.registerInteractionCommands = registerInteractionCommands;

package/bin/reciple/version.d.ts

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

package/bin/reciple/version.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.version = void 0;
+exports.version = require('../../package.json').version;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "reciple",
+  "version": "1.0.0",
+  "description": "A Discord.js bot",
+  "author": "FalloutStudios",
+  "license": "GPL-3.0",
+  "main": "bin/index.js",
+  "bin": {
+    "reciple": "bin/bin.js"
+  },
+  "files": [
+    "bin",
+    "resource",
+    "package.json",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "clean": "rimraf bin",
+    "compile": "npm run clean && tsc",
+    "build": "npm run compile && npm un reciple -g && npm i ./ -g",
+    "build:publish": "npm run build && npm publish",
+    "test": "cd test && reciple",
+    "test:compile": "npm run build && npm run test:run"
+  },
+  "dependencies": {
+    "commander": "^9.1.0",
+    "discord.js": "^13.6.0",
+    "fallout-utility": "^1.3.9",
+    "yaml": "^1.10.2"
+  },
+  "devDependencies": {
+    "@types/node": "^17.0.23",
+    "typescript": "^4.6.3"
+  }
+}

package/resource/reciple.yml

@@ -0,0 +1,48 @@
+token: TOKEN
+prefix: '!'
+
+commands:
+  messageCommand:
+    enabled: true
+    commandArgumentSeparator: ' '
+  interactionCommand:
+    enabled: true
+    registerCommands: true
+    guilds: []
+
+permissions:
+  messageCommands:
+    enabled: true
+    commands:
+      - command: 'stop'
+        permissions: ['ADMINISTRATOR']
+  interactionCommands:
+    enabled: true
+    commands:
+      - command: 'stop'
+        permissions: ['ADMINISTRATOR']
+
+
+ignoredChannels:
+  enabled: false
+  convertToAllowList: false
+  channels: []
+
+fileLogging:
+  enabled: true
+  logFilePath: './logs/latest.log'
+
+client:
+  intents:
+    - 'GUILDS'
+    - 'GUILD_MEMBERS'
+    - 'GUILD_INVITES'
+    - 'GUILD_VOICE_STATES'
+    - 'GUILD_MESSAGES'
+    - 'GUILD_MESSAGE_REACTIONS'
+
+messages:
+  noPermission: 'You do not have permission to use this command.'
+  notEnoughArguments: 'Not enough arguments.'
+
+modulesFolder: 'modules'