commandkit 0.1.11-dev.20240202064607 → 0.1.11-dev.20241214134338

package/dist/CommandKit-D84HlsL0.d.mts

@@ -0,0 +1,451 @@
+import { ValidationHandler } from './handlers/validation-handler/ValidationHandler.mjs';
+import * as discord_js from 'discord.js';
+import { Client, ChatInputCommandInteraction, ContextMenuCommandInteraction, AutocompleteInteraction, Interaction, CacheType, UserContextMenuCommandInteraction, MessageContextMenuCommandInteraction, PermissionsString, RESTPostAPIApplicationCommandsJSONBody } from 'discord.js';
+import { AsyncLocalStorage } from 'async_hooks';
+
+/**
+ * Command handler options.
+ * Similar to CommandKit options in structure.
+ */
+interface CommandHandlerOptions {
+    /**
+     * The client created by the user.
+     */
+    client: Client;
+    /**
+     * Path to the user's commands.
+     */
+    commandsPath: string;
+    /**
+     * An array of developer guild IDs.
+     */
+    devGuildIds: string[];
+    /**
+     * An array of developer user IDs.
+     */
+    devUserIds: string[];
+    /**
+     * An array of developer role IDs.
+     */
+    devRoleIds: string[];
+    /**
+     * A validation handler instance to run validations before commands.
+     */
+    validationHandler?: ValidationHandler;
+    /**
+     * A boolean indicating whether to skip CommandKit's built-in validations (permission checking, etc.)
+     */
+    skipBuiltInValidations: boolean;
+    /**
+     * The CommandKit handler that instantiated this.
+     */
+    commandkitInstance: CommandKit;
+    /**
+     * A boolean indicating whether to register all commands in bulk.
+     */
+    bulkRegister: boolean;
+    /**
+     * Whether to enable hooks context.
+     */
+    enableHooks: boolean;
+}
+/**
+ * Private command handler data.
+ */
+interface CommandHandlerData extends CommandHandlerOptions {
+    /**
+     * An array of command file objects.
+     */
+    commands: CommandFileObject[];
+    /**
+     * An array of built-in validations.
+     */
+    builtInValidations: BuiltInValidation[];
+    /**
+     * A validation handler instance to run validations before commands.
+     */
+    validationHandler?: ValidationHandler;
+}
+/**
+ * Parameters for CommandKit's built-in validations.
+ */
+interface BuiltInValidationParams {
+    /**
+     * The target command to validate.
+     */
+    targetCommand: CommandFileObject;
+    /**
+     * The interaction of the target command.
+     */
+    interaction: CommandKitInteraction;
+    /**
+     * The command handler's data.
+     */
+    handlerData: CommandHandlerData;
+}
+/**
+ * Represents a command interaction.
+ */
+type CommandKitInteraction = ChatInputCommandInteraction | ContextMenuCommandInteraction | AutocompleteInteraction;
+/**
+ * A built in validation. Returns a boolean or void.
+ */
+type BuiltInValidation = ({}: BuiltInValidationParams) => boolean | void;
+
+interface hCommandContext {
+    interaction: CommandKitInteraction;
+    command: CommandData;
+}
+/**
+ * A handler for client application commands.
+ */
+declare class CommandHandler {
+    #private;
+    context: AsyncLocalStorage<hCommandContext> | null;
+    constructor({ ...options }: CommandHandlerOptions);
+    init(): Promise<void>;
+    handleCommands(): void;
+    get commands(): CommandFileObject[];
+    reloadCommands(type?: ReloadOptions): Promise<void>;
+}
+
+/**
+ * Event handler options.
+ */
+interface EventHandlerOptions {
+    client: Client;
+    eventsPath: string;
+    commandKitInstance: CommandKit;
+}
+/**
+ * Private event handler data.
+ */
+interface EventHandlerData extends EventHandlerOptions {
+    events: {
+        name: string;
+        functions: Function[];
+    }[];
+}
+
+/**
+ * A handler for client events.
+ */
+declare class EventHandler {
+    #private;
+    constructor({ ...options }: EventHandlerOptions);
+    init(): Promise<void>;
+    get events(): {
+        name: string;
+        functions: Function[];
+    }[];
+    reloadEvents(commandHandler?: CommandHandler): Promise<void>;
+}
+
+/**
+ * Options for instantiating a CommandKit handler.
+ */
+interface CommandKitOptions {
+    /**
+     * The Discord.js client object to use with CommandKit.
+     */
+    client: Client;
+    /**
+     * The path to your commands directory.
+     */
+    commandsPath?: string;
+    /**
+     * The path to your events directory.
+     */
+    eventsPath?: string;
+    /**
+     * The path to the validations directory.
+     */
+    validationsPath?: string;
+    /**
+     * List of development guild IDs to restrict devOnly commands to.
+     */
+    devGuildIds?: string[];
+    /**
+     * List of developer user IDs to restrict devOnly commands to.
+     */
+    devUserIds?: string[];
+    /**
+     * List of developer role IDs to restrict devOnly commands to.
+     */
+    devRoleIds?: string[];
+    /**
+     * Skip CommandKit's built-in validations (for devOnly commands).
+     */
+    skipBuiltInValidations?: boolean;
+    /**
+     * Bulk register application commands instead of one-by-one.
+     */
+    bulkRegister?: boolean;
+    /**
+     * Options for experimental features.
+     */
+    experimental?: {
+        /**
+         * Enable hooks. This allows you to utilize hooks such as `useInteraction()` to access the interaction object anywhere inside the command.
+         */
+        hooks?: boolean;
+    };
+}
+/**
+ * Private data for the CommandKit class.
+ */
+interface CommandKitData extends CommandKitOptions {
+    commandHandler?: CommandHandler;
+    eventHandler?: EventHandler;
+    validationHandler?: ValidationHandler;
+}
+/**
+ * Represents a command context.
+ */
+interface CommandContext<T extends Interaction, Cached extends CacheType> {
+    /**
+     * The interaction that triggered this command.
+     */
+    interaction: Interaction<CacheType>;
+    /**
+     * The client that instantiated this command.
+     */
+    client: Client;
+    /**
+     * The command data.
+     */
+    handler: CommandKit;
+}
+/**
+ * Represents a command file.
+ */
+interface CommandFileObject {
+    data: CommandData;
+    options?: CommandOptions;
+    run: <Cached extends CacheType = CacheType>(ctx: CommandContext<Interaction, Cached>) => Awaited<void>;
+    autocomplete?: <Cached extends CacheType = CacheType>(ctx: CommandContext<Interaction, Cached>) => Awaited<void>;
+    filePath: string;
+    category: string | null;
+    [key: string]: any;
+}
+/**
+ * A reload type for commands.
+ */
+type ReloadOptions = 'dev' | 'global' | ReloadType;
+/**
+ * Props for command run functions.
+ */
+interface CommandProps {
+    /**
+     * The current command interaction object.
+     */
+    interaction: ChatInputCommandInteraction | ContextMenuCommandInteraction | UserContextMenuCommandInteraction | MessageContextMenuCommandInteraction | AutocompleteInteraction;
+    /**
+     * The Discord.js client object that CommandKit is handling.
+     */
+    client: Client<true>;
+    /**
+     * The current CommandKit handler instance.
+     */
+    handler: CommandKit;
+}
+/**
+ * Props for autocomplete command run functions.
+ */
+interface AutocompleteProps extends CommandProps {
+    /**
+     * The current autocomplete command interaction object.
+     */
+    interaction: AutocompleteInteraction;
+}
+/**
+ * Props for slash (chat input) command run functions.
+ */
+interface SlashCommandProps extends CommandProps {
+    /**
+     * The current slash (chat input) command interaction object.
+     */
+    interaction: ChatInputCommandInteraction;
+}
+/**
+ * Props for context menu command run functions.
+ */
+interface ContextMenuCommandProps extends CommandProps {
+    /**
+     * The current context menu command interaction object.
+     */
+    interaction: ContextMenuCommandInteraction;
+}
+/**
+ * Props for user context menu command run functions.
+ */
+interface UserContextMenuCommandProps extends CommandProps {
+    interaction: UserContextMenuCommandInteraction;
+}
+/**
+ * Props for message context menu command run functions.
+ */
+interface MessageContextMenuCommandProps extends CommandProps {
+    interaction: MessageContextMenuCommandInteraction;
+}
+/**
+ * Props for command validation functions.
+ */
+interface ValidationProps {
+    /**
+     * The current command interaction object.
+     */
+    interaction: ChatInputCommandInteraction | ContextMenuCommandInteraction | AutocompleteInteraction;
+    /**
+     * The Discord.js client object that CommandKit is handling.
+     */
+    client: Client<true>;
+    /**
+     * The current (local) target command object.
+     */
+    commandObj: CommandObject;
+    /**
+     * The current CommandKit handler instance.
+     */
+    handler: CommandKit;
+}
+/**
+ * Additional command configuration options.
+ */
+interface CommandOptions {
+    /**
+     * A boolean indicating whether the command is guild-only.
+     * Used for built-in validation.
+     *
+     * @deprecated Use `dm_permission` in the command's `data` object instead.
+     */
+    guildOnly?: boolean;
+    /**
+     * A boolean indicating whether the command is developer-only.
+     * Used for registration and built-in validation.
+     */
+    devOnly?: boolean;
+    /**
+     * A boolean indicating whether the command is deleted/ignored on restart/reload.
+     */
+    deleted?: boolean;
+    /**
+     * A string or array of permissions that a user needs for the current command to be executed.
+     * Used for built-in validation.
+     *
+     * @example
+     * userPermissions: 'BanMembers'
+     * or
+     * userPermissions: ['BanMembers', 'KickMembers']
+     */
+    userPermissions?: PermissionsString | PermissionsString[];
+    /**
+     * A string or array of permissions that the bot needs to execute the current command.
+     * Used for built-in validation.
+     *
+     * @example
+     * botPermissions: 'BanMembers'
+     * or
+     * botPermissions: ['BanMembers', 'KickMembers']
+     */
+    botPermissions?: PermissionsString | PermissionsString[];
+    [key: string]: any;
+}
+type CommandData = RESTPostAPIApplicationCommandsJSONBody;
+type CommandObject = {
+    /**
+     * An object which defines the structure of the application command.
+     */
+    data: CommandData;
+    /**
+     * Additional command configuration options.
+     */
+    options?: CommandOptions;
+    /**
+     * The path to the command file.
+     */
+    filePath: string;
+    /**
+     * The command's category. Determined based on the command folder.
+     *
+     * @example
+     * ```txt
+     * "/src/commands/ping.js" -> null
+     * "/src/commands/Misc/ping.js" -> "Misc"
+     * ```
+     */
+    category: string | null;
+    [key: string]: any;
+};
+declare enum ReloadType {
+    /**
+     * Reload developer/guild commands.
+     */
+    Developer = "dev",
+    /**
+     * Reload global commands.
+     */
+    Global = "global"
+}
+
+declare class CommandKit {
+    #private;
+    static _instance: CommandKit | null;
+    /**
+     * Create a new command and event handler with CommandKit.
+     *
+     * @param options - The default CommandKit configuration.
+     * @see {@link https://commandkit.js.org/guide/commandkit-setup}
+     */
+    constructor(options: CommandKitOptions);
+    /**
+     * Get the client attached to this CommandKit instance.
+     */
+    get client(): discord_js.Client<boolean>;
+    /**
+     * Get command handler instance.
+     */
+    get commandHandler(): CommandHandler | undefined;
+    /**
+     * Updates application commands with the latest from "commandsPath".
+     */
+    reloadCommands(type?: ReloadOptions): Promise<void>;
+    /**
+     * Updates application events with the latest from "eventsPath".
+     */
+    reloadEvents(): Promise<void>;
+    /**
+     * Updates application command validations with the latest from "validationsPath".
+     */
+    reloadValidations(): Promise<void>;
+    /**
+     * @returns An array of objects of all the commands that CommandKit is handling.
+     */
+    get commands(): CommandObject[];
+    /**
+     * @returns The path to the commands folder which was set when instantiating CommandKit.
+     */
+    get commandsPath(): string | undefined;
+    /**
+     * @returns The path to the events folder which was set when instantiating CommandKit.
+     */
+    get eventsPath(): string | undefined;
+    /**
+     * @returns The path to the validations folder which was set when instantiating CommandKit.
+     */
+    get validationsPath(): string | undefined;
+    /**
+     * @returns An array of all the developer user IDs which was set when instantiating CommandKit.
+     */
+    get devUserIds(): string[];
+    /**
+     * @returns An array of all the developer guild IDs which was set when instantiating CommandKit.
+     */
+    get devGuildIds(): string[];
+    /**
+     * @returns An array of all the developer role IDs which was set when instantiating CommandKit.
+     */
+    get devRoleIds(): string[];
+}
+
+export { type AutocompleteProps as A, type BuiltInValidationParams as B, CommandKit as C, type EventHandlerOptions as E, type MessageContextMenuCommandProps as M, type ReloadOptions as R, type SlashCommandProps as S, type UserContextMenuCommandProps as U, type ValidationProps as V, type CommandKitOptions as a, type CommandKitData as b, type CommandContext as c, type CommandFileObject as d, type CommandProps as e, type ContextMenuCommandProps as f, type CommandOptions as g, type CommandData as h, type CommandObject as i, ReloadType as j, type CommandHandlerOptions as k, type CommandHandlerData as l, type CommandKitInteraction as m, type BuiltInValidation as n, type hCommandContext as o, CommandHandler as p, type EventHandlerData as q, EventHandler as r };

package/dist/CommandKit.d.mts

@@ -0,0 +1,5 @@
+import 'discord.js';
+export { C as CommandKit } from './CommandKit-D84HlsL0.mjs';
+import './handlers/validation-handler/ValidationHandler.mjs';
+import './handlers/validation-handler/typings.mjs';
+import 'async_hooks';

package/dist/CommandKit.d.ts

@@ -0,0 +1,5 @@
+import 'discord.js';
+export { C as CommandKit } from './CommandKit-Co5QNlps.js';
+import './handlers/validation-handler/ValidationHandler.js';
+import './handlers/validation-handler/typings.js';
+import 'async_hooks';

package/dist/CommandKit.js

@@ -0,0 +1,11 @@
+"use strict";var __create=Object.create;var __defProp=Object.defineProperty;var __getOwnPropDesc=Object.getOwnPropertyDescriptor;var __getOwnPropNames=Object.getOwnPropertyNames;var __getProtoOf=Object.getPrototypeOf,__hasOwnProp=Object.prototype.hasOwnProperty;var __name=(target,value)=>__defProp(target,"name",{value,configurable:!0});var __export=(target,all)=>{for(var name in all)__defProp(target,name,{get:all[name],enumerable:!0})},__copyProps=(to,from,except,desc)=>{if(from&&typeof from=="object"||typeof from=="function")for(let key of __getOwnPropNames(from))!__hasOwnProp.call(to,key)&&key!==except&&__defProp(to,key,{get:()=>from[key],enumerable:!(desc=__getOwnPropDesc(from,key))||desc.enumerable});return to};var __toESM=(mod,isNodeMode,target)=>(target=mod!=null?__create(__getProtoOf(mod)):{},__copyProps(isNodeMode||!mod||!mod.__esModule?__defProp(target,"default",{value:mod,enumerable:!0}):target,mod)),__toCommonJS=mod=>__copyProps(__defProp({},"__esModule",{value:!0}),mod);var CommandKit_exports={};__export(CommandKit_exports,{CommandKit:()=>CommandKit});module.exports=__toCommonJS(CommandKit_exports);var import_path=__toESM(require("path"));function toFileURL(filePath){return"file://"+import_path.default.resolve(filePath).replace(/\\\\|\\/g,"/")}__name(toFileURL,"toFileURL");var import_path2=__toESM(require("path")),import_promises=__toESM(require("fs/promises"));async function getFilePaths(directory,nesting){let filePaths=[];if(!directory)return filePaths;let files=await import_promises.default.readdir(directory,{withFileTypes:!0});for(let file of files){let filePath=import_path2.default.join(directory,file.name);file.isFile()&&filePaths.push(filePath),nesting&&file.isDirectory()&&(filePaths=[...filePaths,...await getFilePaths(filePath,!0)])}return filePaths}__name(getFilePaths,"getFilePaths");async function getFolderPaths(directory,nesting){let folderPaths=[];if(!directory)return folderPaths;let folders=await import_promises.default.readdir(directory,{withFileTypes:!0});for(let folder of folders){let folderPath=import_path2.default.join(directory,folder.name);folder.isDirectory()&&(folderPaths.push(folderPath),nesting&&(folderPaths=[...folderPaths,...await getFolderPaths(folderPath,!0)]))}return folderPaths}__name(getFolderPaths,"getFolderPaths");var import_rfdc=__toESM(require("rfdc")),clone=(0,import_rfdc.default)();var resetColor="\x1B[0m",colors_default={reset:__name(text=>`${text}${resetColor}`,"reset"),bright:__name(text=>`\x1B[1m${text}${resetColor}`,"bright"),dim:__name(text=>`\x1B[2m${text}${resetColor}`,"dim"),underscore:__name(text=>`\x1B[4m${text}${resetColor}`,"underscore"),blink:__name(text=>`\x1B[5m${text}${resetColor}`,"blink"),reverse:__name(text=>`\x1B[7m${text}${resetColor}`,"reverse"),hidden:__name(text=>`\x1B[8m${text}${resetColor}`,"hidden"),black:__name(text=>`\x1B[30m${text}${resetColor}`,"black"),red:__name(text=>`\x1B[31m${text}${resetColor}`,"red"),green:__name(text=>`\x1B[32m${text}${resetColor}`,"green"),yellow:__name(text=>`\x1B[33m${text}${resetColor}`,"yellow"),blue:__name(text=>`\x1B[34m${text}${resetColor}`,"blue"),magenta:__name(text=>`\x1B[35m${text}${resetColor}`,"magenta"),cyan:__name(text=>`\x1B[36m${text}${resetColor}`,"cyan"),white:__name(text=>`\x1B[37m${text}${resetColor}`,"white"),bgBlack:__name(text=>`\x1B[40m${text}${resetColor}`,"bgBlack"),bgRed:__name(text=>`\x1B[41m${text}${resetColor}`,"bgRed"),bgGreen:__name(text=>`\x1B[42m${text}${resetColor}`,"bgGreen"),bgYellow:__name(text=>`\x1B[43m${text}${resetColor}`,"bgYellow"),bgBlue:__name(text=>`\x1B[44m${text}${resetColor}`,"bgBlue"),bgMagenta:__name(text=>`\x1B[45m${text}${resetColor}`,"bgMagenta"),bgCyan:__name(text=>`\x1B[46m${text}${resetColor}`,"bgCyan"),bgWhite:__name(text=>`\x1B[47m${text}${resetColor}`,"bgWhite")};async function loadCommandsWithRest(props){if(props.reloading)if(props.client.isReady())await handleLoading(props.client,props.commands,props.devGuildIds,props.reloading,props.type);else throw new Error(colors_default.red("Cannot reload commands when client is not ready."));else props.client.once("ready",async c=>{await handleLoading(c,props.commands,props.devGuildIds,props.reloading,props.type)})}__name(loadCommandsWithRest,"loadCommandsWithRest");async function handleLoading(client,commands,devGuildIds,reloading,type){commands=commands.filter(cmd=>!cmd.options?.deleted);let devOnlyCommands=commands.filter(cmd=>cmd.options?.devOnly),globalCommands=commands.filter(cmd=>!cmd.options?.devOnly);type==="dev"?await loadDevCommands(client,devOnlyCommands,devGuildIds,reloading):type==="global"?await loadGlobalCommands(client,globalCommands,reloading):(await loadDevCommands(client,devOnlyCommands,devGuildIds,reloading),await loadGlobalCommands(client,globalCommands,reloading))}__name(handleLoading,"handleLoading");async function loadGlobalCommands(client,commands,reloading){let requestBody=commands.map(cmd=>cmd.data);await client.application.commands.set(requestBody).catch(error=>{throw new Error(colors_default.red(`Error ${reloading?"reloading":"loading"} global application commands.
+`),error)}),console.log(colors_default.green(`${reloading?"Reloaded":"Loaded"} ${requestBody.length} global commands.`))}__name(loadGlobalCommands,"loadGlobalCommands");async function loadDevCommands(client,commands,guildIds,reloading){let requestBody=commands.map(cmd=>cmd.data);for(let guildId of guildIds){let targetGuild=client.guilds.cache.get(guildId)||await client.guilds.fetch(guildId);if(!targetGuild){process.emitWarning(`Cannot ${reloading?"reload":"load"} commands in guild "${guildId}" - guild doesn't exist or client isn't part of the guild.`);continue}await targetGuild.commands.set(requestBody).catch(error=>{throw new Error(colors_default.red(`Error ${reloading?"reloading":"loading"} developer application commands in guild "${targetGuild?.name||guildId}".
+`),error)}),console.log(colors_default.green(`${reloading?"Reloaded":"Loaded"} ${requestBody.length} developer commands in guild "${targetGuild.name}".`))}}__name(loadDevCommands,"loadDevCommands");function areSlashCommandsDifferent(appCommand,localCommand){if(appCommand.options||(appCommand.options=[]),localCommand.options||(localCommand.options=[]),appCommand.description||(appCommand.description=""),localCommand.description||(localCommand.description=""),localCommand.description!==appCommand.description||localCommand.options.length!==appCommand.options.length)return!0}__name(areSlashCommandsDifferent,"areSlashCommandsDifferent");async function registerCommands(props){if(props.reloading)if(props.client.isReady())await handleRegistration(props.client,props.commands,props.devGuildIds,props.type);else throw new Error(colors_default.red("Cannot reload commands when client is not ready."));else props.client.once("ready",async c=>{await handleRegistration(c,props.commands,props.devGuildIds,props.type)})}__name(registerCommands,"registerCommands");async function handleRegistration(client,commands,devGuildIds,type){let devOnlyCommands=commands.filter(cmd=>cmd.options?.devOnly),globalCommands=commands.filter(cmd=>!cmd.options?.devOnly);type==="dev"?await registerDevCommands(client,devOnlyCommands,devGuildIds):type==="global"?await registerGlobalCommands(client,globalCommands):(await registerDevCommands(client,devOnlyCommands,devGuildIds),await registerGlobalCommands(client,globalCommands))}__name(handleRegistration,"handleRegistration");async function registerGlobalCommands(client,commands){let appCommandsManager=client.application.commands;await appCommandsManager.fetch();for(let command of commands){let targetCommand=appCommandsManager.cache.find(cmd=>cmd.name===command.data.name);if(command.options?.deleted){targetCommand?(await targetCommand.delete().catch(error=>{throw new Error(colors_default.red(`Failed to delete command "${command.data.name}" globally.
+`),error)}),console.log(colors_default.green(`Deleted command "${command.data.name}" globally.`))):process.emitWarning(colors_default.yellow(`Ignoring: Command "${command.data.name}" is globally marked as deleted.`));continue}if(targetCommand&&areSlashCommandsDifferent(targetCommand,command.data)){await targetCommand.edit(command.data).catch(error=>{throw new Error(colors_default.red(`Failed to edit command "${command.data.name}" globally.
+`),error)}),console.log(colors_default.green(`Edited command "${command.data.name}" globally.`));continue}targetCommand||(await appCommandsManager.create(command.data).catch(error=>{throw new Error(colors_default.red(`Failed to register command "${command.data.name}" globally.
+`),error)}),console.log(colors_default.green(`Registered command "${command.data.name}" globally.`)))}}__name(registerGlobalCommands,"registerGlobalCommands");async function registerDevCommands(client,commands,guildIds){let devGuilds=[];for(let guildId of guildIds){let guild=client.guilds.cache.get(guildId)||await client.guilds.fetch(guildId);if(!guild){process.emitWarning(colors_default.yellow(`Ignoring: Guild ${guildId} doesn't exist or client isn't part of the guild.`));continue}devGuilds.push(guild)}let guildCommandsManagers=[];for(let guild of devGuilds){let guildCommandsManager=guild.commands;await guildCommandsManager.fetch(),guildCommandsManagers.push(guildCommandsManager)}for(let command of commands)for(let guildCommands of guildCommandsManagers){let targetCommand=guildCommands.cache.find(cmd=>cmd.name===command.data.name);if(command.options?.deleted){targetCommand?(await targetCommand.delete().catch(error=>{throw new Error(colors_default.red(`Failed to delete command "${command.data.name}" in ${guildCommands.guild.name}.`),error)}),console.log(colors_default.green(`Deleted command "${command.data.name}" in ${guildCommands.guild.name}.`))):process.emitWarning(colors_default.yellow(`Ignoring: Command "${command.data.name}" is marked as deleted in ${guildCommands.guild.name}.`));continue}if(targetCommand&&areSlashCommandsDifferent(targetCommand,command.data)){await targetCommand.edit(command.data).catch(error=>{throw new Error(colors_default.red(`Failed to edit command "${command.data.name}" in ${guildCommands.guild.name}.
+`),error)}),console.log(colors_default.green(`Edited command "${command.data.name}" in ${guildCommands.guild.name}.`));continue}targetCommand||(await guildCommands.create(command.data).catch(error=>{throw new Error(colors_default.red(`Failed to register command "${command.data.name}" in ${guildCommands.guild.name}.
+`),error)}),console.log(colors_default.green(`Registered command "${command.data.name}" in ${guildCommands.guild.name}.`)))}}__name(registerDevCommands,"registerDevCommands");function devOnly_default({interaction,targetCommand,handlerData}){if(!interaction.isAutocomplete()&&targetCommand.options?.devOnly){if(interaction.inGuild()&&!handlerData.devGuildIds.includes(interaction.guildId))return interaction.reply({content:"\u274C This command can only be used inside development servers.",ephemeral:!0}),!0;let memberRoles=interaction.guild?.members.cache.get(interaction.user.id)?.roles.cache,hasDevRole=!1;if(memberRoles?.forEach(role=>{handlerData.devRoleIds.includes(role.id)&&(hasDevRole=!0)}),!(handlerData.devUserIds.includes(interaction.user.id)||hasDevRole))return interaction.reply({content:"\u274C This command can only be used by developers.",ephemeral:!0}),!0}}__name(devOnly_default,"default");var import_discord=require("discord.js");function permissions_default({interaction,targetCommand}){if(interaction.isAutocomplete())return;let userPermissions=interaction.memberPermissions,userPermissionsRequired=targetCommand.options?.userPermissions,missingUserPermissions=[];typeof userPermissionsRequired=="string"&&(userPermissionsRequired=[userPermissionsRequired]);let botPermissions=interaction.guild?.members.me?.permissions,botPermissionsRequired=targetCommand.options?.botPermissions,missingBotPermissions=[];if(typeof botPermissionsRequired=="string"&&(botPermissionsRequired=[botPermissionsRequired]),!userPermissionsRequired?.length&&!botPermissionsRequired?.length)return;if(userPermissions&&userPermissionsRequired)for(let permission of userPermissionsRequired)userPermissions.has(permission)||missingUserPermissions.push(permission);if(botPermissions&&botPermissionsRequired)for(let permission of botPermissionsRequired)botPermissions.has(permission)||missingBotPermissions.push(permission);if(!missingUserPermissions.length&&!missingBotPermissions.length)return;let pattern=/([a-z])([A-Z])|([A-Z]+)([A-Z][a-z])/g;missingUserPermissions=missingUserPermissions.map(str=>str.replace(pattern,"$1$3 $2$4")),missingBotPermissions=missingBotPermissions.map(str=>str.replace(pattern,"$1$3 $2$4"));let embedDescription="",formatter=new Intl.ListFormat("en",{style:"long",type:"conjunction"}),getPermissionWord=__name(permissions=>permissions.length===1?"permission":"permissions","getPermissionWord");if(missingUserPermissions.length){let formattedPermissions=missingUserPermissions.map(p=>`\`${p}\``),permissionsString=formatter.format(formattedPermissions);embedDescription+=`- You must have the ${permissionsString} ${getPermissionWord(missingUserPermissions)} to be able to run this command.
+`}if(missingBotPermissions.length){let formattedPermissions=missingBotPermissions.map(p=>`\`${p}\``),permissionsString=formatter.format(formattedPermissions);embedDescription+=`- I must have the ${permissionsString} ${getPermissionWord(missingBotPermissions)} to be able to execute this command.
+`}let embed=new import_discord.EmbedBuilder().setTitle(":x: Missing permissions!").setDescription(embedDescription).setColor("Red");return interaction.reply({embeds:[embed],ephemeral:!0}),!0}__name(permissions_default,"default");var validations_default=[devOnly_default,permissions_default];var import_async_hooks=require("async_hooks");var CommandHandler=class{static{__name(this,"CommandHandler")}#data;context=null;constructor({...options}){this.#data={...options,builtInValidations:[],commands:[]}}async init(){this.#data.enableHooks&&!this.context&&(this.context=new import_async_hooks.AsyncLocalStorage),await this.#buildCommands(),this.#buildBuiltInValidations();let devOnlyCommands=this.#data.commands.filter(cmd=>cmd.options?.devOnly);devOnlyCommands.length&&!this.#data.devGuildIds.length&&process.emitWarning(colors_default.yellow('You have commands marked as "devOnly", but "devGuildIds" have not been set.')),devOnlyCommands.length&&!this.#data.devUserIds.length&&!this.#data.devRoleIds.length&&process.emitWarning(colors_default.yellow('You have commands marked as "devOnly", but "devUserIds" or "devRoleIds" have not been set.')),this.#data.bulkRegister?await loadCommandsWithRest({client:this.#data.client,devGuildIds:this.#data.devGuildIds,commands:this.#data.commands}):await registerCommands({client:this.#data.client,devGuildIds:this.#data.devGuildIds,commands:this.#data.commands}),this.handleCommands()}async#buildCommands(){let allowedExtensions=/\.(js|mjs|cjs|ts)$/i,commandFilePaths=(await getFilePaths(this.#data.commandsPath,!0)).filter(path3=>allowedExtensions.test(path3));for(let commandFilePath of commandFilePaths){let importedObj=await import(`${toFileURL(commandFilePath)}?t=${Date.now()}`),commandObj=clone(importedObj);typeof module<"u"&&typeof require<"u"&&delete require.cache[require.resolve(commandFilePath)];let compactFilePath=commandFilePath.split(process.cwd())[1]||commandFilePath;if(commandObj.default&&(commandObj=commandObj.default),importedObj.default?commandObj.data=importedObj.default.data:commandObj.data=importedObj.data,!commandObj.data){process.emitWarning(colors_default.yellow(`Ignoring: Command file ${compactFilePath} does not export "data".`));continue}if(!commandObj.data.name){process.emitWarning(colors_default.yellow(`Ignoring: Command file ${compactFilePath} does not export "data.name".`));continue}if(!commandObj.run){process.emitWarning(colors_default.yellow(`Ignoring: Command file ${commandObj.data.name} does not export "run".`));continue}if(typeof commandObj.run!="function"){process.emitWarning(colors_default.yellow(`Ignoring: Command file ${commandObj.data.name} does not export "run" as a function.`));continue}commandObj.filePath=commandFilePath;let commandCategory=commandFilePath.split(this.#data.commandsPath)[1]?.replace(/\\\\|\\/g,"/").split("/")[1]||null;commandCategory&&allowedExtensions.test(commandCategory)?commandObj.category=null:commandObj.category=commandCategory,this.#data.commands.push(commandObj)}}#buildBuiltInValidations(){for(let builtInValidationFunction of validations_default)this.#data.builtInValidations.push(builtInValidationFunction)}handleCommands(){let areHooksEnabled=this.#data.enableHooks;this.#data.client.on("interactionCreate",async interaction=>{if(!interaction.isChatInputCommand()&&!interaction.isContextMenuCommand()&&!interaction.isAutocomplete())return;let isAutocomplete=interaction.isAutocomplete(),targetCommand=this.#data.commands.find(cmd=>cmd.data.name===interaction.commandName);if(!targetCommand)return;let{data,options,run,autocomplete,...rest}=targetCommand;if(isAutocomplete&&!autocomplete)return;let executor=__name(async()=>{let commandObj={data:targetCommand.data,options:targetCommand.options,...rest};if(this.#data.validationHandler){let canRun2=!0;for(let validationFunction of this.#data.validationHandler.validations)if(await validationFunction({interaction,commandObj,client:this.#data.client,handler:this.#data.commandkitInstance})){canRun2=!1;break}if(!canRun2)return}let canRun=!0;if(!this.#data.skipBuiltInValidations){for(let validation of this.#data.builtInValidations)if(validation({targetCommand,interaction,handlerData:this.#data})){canRun=!1;break}}if(!canRun)return;let command=targetCommand[isAutocomplete?"autocomplete":"run"];if(!areHooksEnabled){let context={interaction,client:this.#data.client,handler:this.#data.commandkitInstance};return await command(context)}return command()},"executor");return this.context?this.context.run({command:targetCommand.data,interaction},executor):executor()})}get commands(){return this.#data.commands}async reloadCommands(type){if(!this.#data.commandsPath)throw new Error(colors_default.red('Cannot reload commands as "commandsPath" was not provided when instantiating CommandKit.'));this.#data.commands=[],await this.#buildCommands(),this.#data.bulkRegister?await loadCommandsWithRest({client:this.#data.client,devGuildIds:this.#data.devGuildIds,commands:this.#data.commands,reloading:!0,type}):await registerCommands({client:this.#data.client,devGuildIds:this.#data.devGuildIds,commands:this.#data.commands,reloading:!0,type})}};var EventHandler=class{static{__name(this,"EventHandler")}#data;constructor({...options}){this.#data={...options,events:[]}}async init(){await this.#buildEvents(),this.#registerEvents()}async#buildEvents(){let eventFolderPaths=await getFolderPaths(this.#data.eventsPath);for(let eventFolderPath of eventFolderPaths){let eventName=eventFolderPath.replace(/\\\\|\\/g,"/").split("/").pop(),allowedExtensions=/\.(js|mjs|cjs|ts)$/i,eventFilePaths=(await getFilePaths(eventFolderPath,!0)).filter(path3=>allowedExtensions.test(path3)),eventObj={name:eventName,functions:[]};this.#data.events.push(eventObj);for(let eventFilePath of eventFilePaths){let importedFunction=(await import(`${toFileURL(eventFilePath)}?t=${Date.now()}`)).default,eventFunction=clone(importedFunction);typeof module<"u"&&typeof require<"u"&&delete require.cache[require.resolve(eventFilePath)],eventFunction?.default&&(eventFunction=eventFunction.default);let compactFilePath=eventFilePath.split(process.cwd())[1]||eventFilePath;if(typeof eventFunction!="function"){process.emitWarning(colors_default.yellow(`Ignoring: Event file ${compactFilePath} does not export a function.`));continue}eventObj.functions.push(eventFunction)}}}#registerEvents(){let client=this.#data.client,handler=this.#data.commandKitInstance;for(let eventObj of this.#data.events)client.on(eventObj.name,async(...params)=>{for(let eventFunction of eventObj.functions)if(await eventFunction(...params,client,handler))break})}get events(){return this.#data.events}async reloadEvents(commandHandler){if(!this.#data.eventsPath)throw new Error(colors_default.red('Cannot reload events as "eventsPath" was not provided when instantiating CommandKit.'));this.#data.events=[],await this.#buildEvents(),this.#data.client.removeAllListeners(),this.#registerEvents(),commandHandler?.handleCommands()}};var ValidationHandler=class{static{__name(this,"ValidationHandler")}#data;constructor({...options}){this.#data={...options,validations:[]}}async init(){this.#data.validations=await this.#buildValidations()}async#buildValidations(){let allowedExtensions=/\.(js|mjs|cjs|ts)$/i,validationFilePaths=(await getFilePaths(this.#data.validationsPath,!0)).filter(path3=>allowedExtensions.test(path3)),validationFunctions=[];for(let validationFilePath of validationFilePaths){let importedFunction=(await import(`${toFileURL(validationFilePath)}?t=${Date.now()}`)).default,validationFunction=clone(importedFunction);typeof module<"u"&&typeof require<"u"&&delete require.cache[require.resolve(validationFilePath)],validationFunction?.default&&(validationFunction=validationFunction.default);let compactFilePath=validationFilePath.split(process.cwd())[1]||validationFilePath;if(typeof validationFunction!="function"){process.emitWarning(colors_default.yellow(`Ignoring: Validation file ${compactFilePath} does not export a function.`));continue}validationFunctions.push(validationFunction)}return validationFunctions}get validations(){return this.#data.validations}async reloadValidations(){if(!this.#data.validationsPath)throw new Error(colors_default.red('Cannot reload validations as "validationsPath" was not provided when instantiating CommandKit.'));let newValidations=await this.#buildValidations();this.#data.validations=newValidations}};var CommandKit=class _CommandKit{static{__name(this,"CommandKit")}#data;static _instance=null;constructor(options){if(!options.client)throw new Error(colors_default.red('"client" is required when instantiating CommandKit.'));if(options.validationsPath&&!options.commandsPath)throw new Error(colors_default.red('"commandsPath" is required when "validationsPath" is set.'));this.#data=options,_CommandKit._instance=this,this.#init()}get client(){return this.#data.client}get commandHandler(){return this.#data.commandHandler}async#init(){if(this.#data.eventsPath){let eventHandler=new EventHandler({client:this.#data.client,eventsPath:this.#data.eventsPath,commandKitInstance:this});await eventHandler.init(),this.#data.eventHandler=eventHandler}if(this.#data.validationsPath){let validationHandler=new ValidationHandler({validationsPath:this.#data.validationsPath});await validationHandler.init(),this.#data.validationHandler=validationHandler}if(this.#data.commandsPath){let commandHandler=new CommandHandler({client:this.#data.client,commandsPath:this.#data.commandsPath,devGuildIds:this.#data.devGuildIds||[],devUserIds:this.#data.devUserIds||[],devRoleIds:this.#data.devRoleIds||[],validationHandler:this.#data.validationHandler,skipBuiltInValidations:this.#data.skipBuiltInValidations||!1,commandkitInstance:this,bulkRegister:this.#data.bulkRegister||!1,enableHooks:this.#data.experimental?.hooks??!1});await commandHandler.init(),this.#data.commandHandler=commandHandler}}async reloadCommands(type){this.#data.commandHandler&&await this.#data.commandHandler.reloadCommands(type)}async reloadEvents(){this.#data.eventHandler&&await this.#data.eventHandler.reloadEvents(this.#data.commandHandler)}async reloadValidations(){this.#data.validationHandler&&await this.#data.validationHandler.reloadValidations()}get commands(){return this.#data.commandHandler?this.#data.commandHandler.commands.map(cmd=>{let{run,autocomplete,...command}=cmd;return command}):[]}get commandsPath(){return this.#data.commandsPath}get eventsPath(){return this.#data.eventsPath}get validationsPath(){return this.#data.validationsPath}get devUserIds(){return this.#data.devUserIds||[]}get devGuildIds(){return this.#data.devGuildIds||[]}get devRoleIds(){return this.#data.devRoleIds||[]}};0&&(module.exports={CommandKit});
+//# sourceMappingURL=CommandKit.js.map