commandkit 0.0.8 → 0.0.10

package/dist/CommandKit.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommandKit = void 0;
-const handlers_1 = require("./handlers");
-class CommandKit {
-    _data;
-    constructor({ ...options }) {
-        if (!options.client) {
-            throw new Error('"client" is required when instantiating CommandKit.');
-        }
-        if (options.validationsPath && !options.commandsPath) {
-            throw new Error('"commandsPath" is required when "validationsPath" is set.');
-        }
-        this._data = {
-            ...options,
-            commands: [],
-        };
-        this._init();
-    }
-    _init() {
-        // Event handler
-        if (this._data.eventsPath) {
-            new handlers_1.EventHandler({
-                client: this._data.client,
-                eventsPath: this._data.eventsPath,
-            });
-        }
-        // Validation handler
-        let validationFunctions = [];
-        if (this._data.validationsPath) {
-            const validationHandler = new handlers_1.ValidationHandler({
-                validationsPath: this._data.validationsPath,
-            });
-            validationFunctions = validationHandler.getValidations();
-        }
-        // Command handler
-        if (this._data.commandsPath) {
-            const commandHandler = new handlers_1.CommandHandler({
-                client: this._data.client,
-                commandsPath: this._data.commandsPath,
-                devGuildIds: this._data.devGuildIds || [],
-                devUserIds: this._data.devUserIds || [],
-                validations: validationFunctions,
-            });
-            this._data.commands = commandHandler.getCommands();
-        }
-    }
-    get commands() {
-        return this._data.commands.map((cmd) => {
-            const { run, ...command } = cmd;
-            return command;
-        });
-    }
-}
-exports.CommandKit = CommandKit;

package/dist/handlers/command-handler/CommandHandler.d.ts

@@ -1,12 +0,0 @@
-import { CommandHandlerData, CommandHandlerOptions } from './typings';
-import { ContextCommandObject, SlashCommandObject } from '../../../typings';
-export declare class CommandHandler {
-    _data: CommandHandlerData;
-    constructor({ ...options }: CommandHandlerOptions);
-    _init(): void;
-    _buildCommands(): void;
-    _registerCommands(): void;
-    _handleCommands(): void;
-    _areSlashCommandsDifferent(appCommand: any, localCommand: any): true | undefined;
-    getCommands(): (SlashCommandObject | ContextCommandObject)[];
-}

package/dist/handlers/command-handler/CommandHandler.js

@@ -1,258 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommandHandler = void 0;
-const get_paths_1 = require("../../utils/get-paths");
-class CommandHandler {
-    _data;
-    constructor({ ...options }) {
-        this._data = {
-            ...options,
-            commands: [],
-        };
-        this._init();
-    }
-    _init() {
-        this._buildCommands();
-        this._registerCommands();
-        this._handleCommands();
-    }
-    _buildCommands() {
-        const commandFilePaths = (0, get_paths_1.getFilePaths)(this._data.commandsPath, true).filter((path) => path.endsWith('.js') || path.endsWith('.ts'));
-        for (const commandFilePath of commandFilePaths) {
-            const commandObj = require(commandFilePath);
-            if (!commandObj.data) {
-                console.log(`⏩ Ignoring: Command ${commandFilePath} does not export "data".`);
-                continue;
-            }
-            if (!commandObj.run) {
-                console.log(`⏩ Ignoring: Command ${commandFilePath} does not export "run".`);
-                continue;
-            }
-            this._data.commands.push(commandObj);
-        }
-    }
-    _registerCommands() {
-        const client = this._data.client;
-        const commands = this._data.commands;
-        client.once('ready', async () => {
-            const devGuilds = [];
-            for (const devGuildId of this._data.devGuildIds) {
-                const guild = client.guilds.cache.get(devGuildId);
-                if (!guild) {
-                    console.log(`⏩ Ignoring: Guild ${devGuildId} does not exist or client isn't in this guild.`);
-                    continue;
-                }
-                devGuilds.push(guild);
-            }
-            const appCommands = client.application?.commands;
-            await appCommands?.fetch();
-            const devGuildCommands = [];
-            for (const guild of devGuilds) {
-                const guildCommands = guild.commands;
-                await guildCommands?.fetch();
-                devGuildCommands.push(guildCommands);
-            }
-            for (const command of commands) {
-                // <!-- Delete command if options.deleted -->
-                if (command.options?.deleted) {
-                    const targetCommand = appCommands?.cache.find((cmd) => cmd.name === command.data.name);
-                    if (!targetCommand) {
-                        console.log(`⏩ Ignoring: Command "${command.data.name}" is globally marked as deleted.`);
-                    }
-                    else {
-                        targetCommand.delete().then(() => {
-                            console.log(`🚮 Deleted command "${command.data.name}" globally.`);
-                        });
-                    }
-                    for (const guildCommands of devGuildCommands) {
-                        const targetCommand = guildCommands.cache.find((cmd) => cmd.name === command.data.name);
-                        if (!targetCommand) {
-                            console.log(`⏩ Ignoring: Command "${command.data.name}" is marked as deleted for ${guildCommands.guild.name}.`);
-                        }
-                        else {
-                            targetCommand.delete().then(() => {
-                                console.log(`🚮 Deleted command "${command.data.name}" in ${guildCommands.guild.name}.`);
-                            });
-                        }
-                    }
-                    continue;
-                }
-                // <!-- Edit command if there's any changes -->
-                let commandData = command.data;
-                let editedCommand = false;
-                (() => {
-                    // global
-                    const appGlobalCommand = appCommands?.cache.find((cmd) => cmd.name === command.data.name);
-                    if (appGlobalCommand) {
-                        const commandsAreDifferent = this._areSlashCommandsDifferent(appGlobalCommand, commandData);
-                        if (commandsAreDifferent) {
-                            appGlobalCommand
-                                .edit(commandData)
-                                .then(() => {
-                                console.log(`✅ Edited command "${commandData.name}" globally.`);
-                            })
-                                .catch((error) => {
-                                console.log(`❌ Failed to edit command "${commandData.name}" globally.`);
-                                console.error(error);
-                            });
-                            editedCommand = true;
-                        }
-                    }
-                    // guilds
-                    for (const guildCommands of devGuildCommands) {
-                        const appGuildCommand = guildCommands.cache.find((cmd) => cmd.name === commandData.name);
-                        if (appGuildCommand) {
-                            const commandsAreDifferent = this._areSlashCommandsDifferent(appGuildCommand, commandData);
-                            if (commandsAreDifferent) {
-                                appGuildCommand
-                                    .edit(commandData)
-                                    .then(() => {
-                                    console.log(`✅ Edited command "${commandData.name}" in ${guildCommands.guild.name}.`);
-                                })
-                                    .catch((error) => {
-                                    console.log(`❌ Failed to edit command "${commandData.name}" in ${guildCommands.guild.name}.`);
-                                    console.error(error);
-                                });
-                                editedCommand = true;
-                            }
-                        }
-                    }
-                })();
-                if (editedCommand)
-                    continue;
-                // <!-- Registration -->
-                // guild-based command registration
-                if (command.options?.devOnly) {
-                    if (!devGuilds.length) {
-                        console.log(`⏩ Ignoring: Cannot register command "${command.data.name}" as no valid "devGuildIds" were provided.`);
-                        continue;
-                    }
-                    for (const guild of devGuilds) {
-                        const cmdExists = guild.commands.cache.some((cmd) => cmd.name === command.data.name);
-                        if (cmdExists)
-                            continue;
-                        guild?.commands
-                            .create(command.data)
-                            .then(() => {
-                            console.log(`✅ Registered command "${command.data.name}" in ${guild.name}.`);
-                        })
-                            .catch((error) => {
-                            console.log(`❌ Failed to register command "${command.data.name}" in ${guild.name}.`);
-                            console.error(error);
-                        });
-                    }
-                }
-                // global command registration
-                else {
-                    const cmdExists = appCommands?.cache.some((cmd) => cmd.name === command.data.name);
-                    if (cmdExists)
-                        continue;
-                    appCommands
-                        ?.create(command.data)
-                        .then(() => {
-                        console.log(`✅ Registered command "${command.data.name}" globally.`);
-                    })
-                        .catch((error) => {
-                        console.log(`❌ Failed to register command "${command.data.name}" globally.`);
-                        console.error(error);
-                    });
-                }
-            }
-        });
-    }
-    _handleCommands() {
-        const client = this._data.client;
-        client.on('interactionCreate', async (interaction) => {
-            if (!interaction.isChatInputCommand() && !interaction.isContextMenuCommand())
-                return;
-            const targetCommand = this._data.commands.find((cmd) => cmd.data.name === interaction.commandName);
-            if (!targetCommand)
-                return;
-            // Options validation
-            // options.guildOnly
-            if (targetCommand.options?.guildOnly && !interaction.inGuild()) {
-                interaction.reply({
-                    content: '❌ This command can only be used inside a server.',
-                    ephemeral: true,
-                });
-                return;
-            }
-            // options.devOnly
-            if (targetCommand.options?.devOnly) {
-                const isDevUser = this._data.devUserIds.includes(interaction.user.id);
-                if (!isDevUser) {
-                    interaction.reply({
-                        content: '❌ This command can only be used by developers.',
-                        ephemeral: true,
-                    });
-                    return;
-                }
-            }
-            // options.userPermissions
-            const memberPermissions = interaction.memberPermissions;
-            if (targetCommand.options?.userPermissions && memberPermissions) {
-                for (const permission of targetCommand.options.userPermissions) {
-                    const hasPermission = memberPermissions.has(permission);
-                    if (!hasPermission) {
-                        interaction.reply({
-                            content: `❌ You do not have enough permission to run this command. Required permission: \`${permission}\``,
-                            ephemeral: true,
-                        });
-                        return;
-                    }
-                }
-            }
-            // options.botPermissions
-            const botMember = interaction.guild?.members.me;
-            if (targetCommand.options?.botPermissions && botMember) {
-                for (const permission of targetCommand.options.botPermissions) {
-                    const hasPermission = botMember.permissions.has(permission);
-                    if (!hasPermission) {
-                        interaction.reply({
-                            content: `❌ I do not have enough permission to execute this command. Required permission: \`${permission}\``,
-                            ephemeral: true,
-                        });
-                        return;
-                    }
-                }
-            }
-            // Run user validation functions
-            const validationFunctions = this._data.validations;
-            const { data, options, run, ...rest } = targetCommand;
-            const commandObj = {
-                data: targetCommand.data,
-                options: targetCommand.options,
-                ...rest,
-            };
-            let canRun = true;
-            for (const validationFunction of validationFunctions) {
-                const stopValidationLoop = await validationFunction({ interaction, client, commandObj });
-                if (stopValidationLoop) {
-                    canRun = false;
-                    break;
-                }
-            }
-            if (canRun) {
-                targetCommand.run({ interaction, client });
-            }
-        });
-    }
-    _areSlashCommandsDifferent(appCommand, localCommand) {
-        if (!appCommand.options)
-            appCommand.options = [];
-        if (!localCommand.options)
-            localCommand.options = [];
-        if (!appCommand.description)
-            appCommand.description = '';
-        if (!localCommand.description)
-            localCommand.description = '';
-        if (localCommand.description !== appCommand.description ||
-            localCommand.options.length !== appCommand.options.length) {
-            return true;
-        }
-    }
-    getCommands() {
-        return this._data.commands;
-    }
-}
-exports.CommandHandler = CommandHandler;

package/dist/handlers/event-handler/EventHandler.d.ts

@@ -1,11 +0,0 @@
-import { EventHandlerOptions, EventHandlerData } from './typings';
-export declare class EventHandler {
-    _data: EventHandlerData;
-    constructor({ ...options }: EventHandlerOptions);
-    _buildEvents(): void;
-    _registerEvents(): void;
-    getEvents(): {
-        name: string;
-        functions: Function[];
-    }[];
-}

package/dist/handlers/event-handler/EventHandler.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventHandler = void 0;
-const get_paths_1 = require("../../utils/get-paths");
-class EventHandler {
-    _data;
-    constructor({ ...options }) {
-        this._data = {
-            ...options,
-            events: [],
-        };
-        this._buildEvents();
-        this._registerEvents();
-    }
-    _buildEvents() {
-        const eventFolderPaths = (0, get_paths_1.getFolderPaths)(this._data.eventsPath);
-        for (const eventFolderPath of eventFolderPaths) {
-            const eventName = eventFolderPath.replace(/\\/g, '/').split('/').pop();
-            const eventFilePaths = (0, get_paths_1.getFilePaths)(eventFolderPath, true).filter((path) => path.endsWith('.js') || path.endsWith('.ts'));
-            const eventObj = {
-                name: eventName,
-                functions: [],
-            };
-            this._data.events.push(eventObj);
-            for (const eventFilePath of eventFilePaths) {
-                const eventFunction = require(eventFilePath);
-                if (typeof eventFunction !== 'function') {
-                    console.log(`Ignoring: Event ${eventFilePath} does not export a function.`);
-                    continue;
-                }
-                eventObj.functions.push(eventFunction);
-            }
-        }
-    }
-    _registerEvents() {
-        const client = this._data.client;
-        for (const eventObj of this._data.events) {
-            client.on(eventObj.name, async (...params) => {
-                for (const eventFunction of eventObj.functions) {
-                    const stopEventLoop = await eventFunction(...params, client);
-                    if (stopEventLoop) {
-                        break;
-                    }
-                }
-            });
-        }
-    }
-    getEvents() {
-        return this._data.events;
-    }
-}
-exports.EventHandler = EventHandler;

package/dist/handlers/index.d.ts

@@ -1,3 +0,0 @@
-export * from './command-handler/CommandHandler';
-export * from './event-handler/EventHandler';
-export * from './validation-handler/ValidationHandler';

package/dist/handlers/index.js

@@ -1,19 +0,0 @@
-"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("./command-handler/CommandHandler"), exports);
-__exportStar(require("./event-handler/EventHandler"), exports);
-__exportStar(require("./validation-handler/ValidationHandler"), exports);

package/dist/handlers/validation-handler/ValidationHandler.d.ts

@@ -1,7 +0,0 @@
-import { ValidationHandlerData, ValidationHandlerOptions } from './typings';
-export declare class ValidationHandler {
-    _data: ValidationHandlerData;
-    constructor({ ...options }: ValidationHandlerOptions);
-    _buildValidations(): void;
-    getValidations(): Function[];
-}

package/dist/handlers/validation-handler/ValidationHandler.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValidationHandler = void 0;
-const get_paths_1 = require("../../utils/get-paths");
-class ValidationHandler {
-    _data;
-    constructor({ ...options }) {
-        this._data = {
-            ...options,
-            validations: [],
-        };
-        this._buildValidations();
-    }
-    _buildValidations() {
-        const validationFilePaths = (0, get_paths_1.getFilePaths)(this._data.validationsPath, true).filter((path) => path.endsWith('.js') || path.endsWith('.ts'));
-        for (const validationFilePath of validationFilePaths) {
-            const validationFunction = require(validationFilePath);
-            if (typeof validationFunction !== 'function') {
-                console.log(`Ignoring: Validation ${validationFilePath} does not export a function.`);
-                continue;
-            }
-            this._data.validations.push(validationFunction);
-        }
-    }
-    getValidations() {
-        return this._data.validations;
-    }
-}
-exports.ValidationHandler = ValidationHandler;

package/dist/utils/get-paths.d.ts

@@ -1,3 +0,0 @@
-declare function getFilePaths(directory: string, nesting?: boolean): string[];
-declare function getFolderPaths(directory: string, nesting?: boolean): string[];
-export { getFilePaths, getFolderPaths };

package/dist/utils/get-paths.js

@@ -1,42 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFolderPaths = exports.getFilePaths = void 0;
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-function getFilePaths(directory, nesting) {
-    let filePaths = [];
-    if (!directory)
-        return filePaths;
-    const files = fs_1.default.readdirSync(directory, { withFileTypes: true });
-    for (const file of files) {
-        const filePath = path_1.default.join(directory, file.name);
-        if (file.isFile()) {
-            filePaths.push(filePath);
-        }
-        if (nesting && file.isDirectory()) {
-            filePaths = [...filePaths, ...getFilePaths(filePath, true)];
-        }
-    }
-    return filePaths;
-}
-exports.getFilePaths = getFilePaths;
-function getFolderPaths(directory, nesting) {
-    let folderPaths = [];
-    if (!directory)
-        return folderPaths;
-    const folders = fs_1.default.readdirSync(directory, { withFileTypes: true });
-    for (const folder of folders) {
-        const folderPath = path_1.default.join(directory, folder.name);
-        if (folder.isDirectory()) {
-            folderPaths.push(folderPath);
-            if (nesting) {
-                folderPaths = [...folderPaths, ...getFolderPaths(folderPath, true)];
-            }
-        }
-    }
-    return folderPaths;
-}
-exports.getFolderPaths = getFolderPaths;

package/tsconfig.json

@@ -1,14 +0,0 @@
-{
-  "compilerOptions": {
-    "outDir": "dist",
-    "strict": true,
-    "noImplicitAny": true,
-    "esModuleInterop": true,
-    "strictNullChecks": true,
-    "target": "ES2022",
-    "moduleResolution": "Node",
-    "module": "CommonJS",
-    "declaration": true
-  },
-  "include": ["src/**/*"]
-}

package/typings.d.ts

@@ -1,61 +0,0 @@
-import {
-  Client,
-  APIApplicationCommandOption,
-  ContextMenuCommandType,
-  Interaction,
-  PermissionResolvable,
-  SlashCommandBuilder,
-  ContextMenuCommandBuilder,
-} from 'discord.js';
-
-export interface CommandKitOptions {
-  client: Client;
-  commandsPath?: string;
-  eventsPath?: string;
-  validationsPath?: string;
-  devGuildIds?: string[];
-  devUserIds?: string[];
-}
-
-export interface CommandKitData extends CommandKitOptions {
-  commands: Array<SlashCommandObject | ContextCommandObject>;
-}
-
-export interface SlashCommandObject {
-  data:
-    | SlashCommandBuilder
-    | {
-        name: string;
-        name_localizations?: any;
-        description: string;
-        dm_permission?: boolean;
-        options?: APIApplicationCommandOption[];
-      };
-  options?: {
-    guildOnly?: boolean;
-    devOnly?: boolean;
-    deleted?: boolean;
-    userPermissions?: PermissionResolvable[];
-    botPermissions?: PermissionResolvable[];
-  };
-  run: ({}: { interaction: Interaction; client: Client }) => void;
-}
-
-export interface ContextCommandObject {
-  data:
-    | ContextMenuCommandBuilder
-    | {
-        name: string;
-        name_localizations?: any;
-        type: ContextMenuCommandType;
-        dm_permission?: boolean;
-      };
-  options?: {
-    guildOnly?: boolean;
-    devOnly?: boolean;
-    deleted?: boolean;
-    userPermissions?: PermissionResolvable[];
-    botPermissions?: PermissionResolvable[];
-  };
-  run: ({}: { interaction: Interaction; client: Client }) => void;
-}