discord-bot-shared 0.13.0 → 0.14.0

package/README.md

@@ -1,171 +1,287 @@
 # discord-bot-shared
 
-**This readme is currently out of date.**
+A small package that makes creating [discord.js](https://github.com/discordjs/discord.js) bots a bit easier. It allows you easily create and register bot commands/events, handle runtime errors, and more.
 
-A module that makes creating discord.js bots a bit easier.
-
-## Installation/Usage
+---
 
-```
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Creating a `Bot` instance](#creating-a-bot-instance)
+- [Commands](#commands)
+  - [Creating a slash command](#creating-a-slash-command)
+  - [Adding and registering commands](#adding-and-registering-commands)
+  - [Unregistering commands](#unregistering-commands)
+  - [Global Command Hook](#global-command-hook)
+- [Events](#events)
+  - [Listening for event](#listening-for-event)
+  - [Adding and registering events](#adding-and-registering-events)
+- [Error Handling](#error-handling)
+  - [Commands](#commands-1)
+  - [Events](#events-1)
+- [Utilities](#utilities)
+  - [getChannel](#getchannel)
+
+## Installation
+
+```sh
 npm install discord-bot-shared
 ```
 
-- This module expects a `BOT_TOKEN` and `CLIENT_ID` environment variable to login.
-  - By default, commands are registered globally. To register commands to a specific guild, you can optionally provide `GUILD_ID`.
+## Quick Start
 
-```
-// index.ts
-import login from 'discord-bot-shared'
-import { ClientOptions, GatewayIntentBits as Intents, Partials } from 'discord.js'
+Let's create a simple bot with one slash command.
 
-const botIntents: ClientOptions = {
-  intents: [Intents.Guilds],
-  partials: [Partials.Reaction],
-}
+In **`ping.ts`:**
 
-const bot = await login(botIntents, import.meta.url)
+```ts
+import { Command } from "discord-bot-shared"
+import { SlashCommandBuilder } from "discord.js"
 
-export default bot
+const ping: Command = {
+  command: new SlashCommandBuilder().setName("ping").setDescription("I'll respond with pong!").toJSON(),
+  async run(interaction) {
+    await interaction.reply("Pong!")
+  },
+}
+
+export default ping
 ```
 
-**You must have a directory names `events` and `commands` next to your `index.ts` (or wherever you are importing `login()` from).**
+In **`index.ts`:**
 
-```
-.
-└── src/
-    ├── events/
-    │   └── someEvent.ts
-    ├── commands/
-    │   └── someCommand.ts
-    └── index.ts
+```ts
+import Bot from "discord-bot-shared"
+import { ClientOptions, GatewayIntentBits } from "discord.js"
+import ping from "./ping"
+
+// Get applicationId and token from environment variables
+const applicationId = process.env.APPLICATION_ID ?? ""
+const token = process.env.BOT_TOKEN ?? ""
+
+const clientOptions: ClientOptions = {
+  intents: [GatewayIntentBits.Guilds],
+}
+
+const bot = new Bot({ applicationId, token, clientOptions })
+
+bot.commands.add(ping)
+
+await bot.commands.register()
+await bot.login()
 ```
 
-### Events
+That's it! You now have bot that will respond to the slash command `/ping` with "Pong!".
 
-This module registers your bot's events by `import`ing each file under your `events` directory. Events are registered as a side-effect of the import.
+## Creating a `Bot` instance
 
+The `Bot` constructor takes an object that contains your bot's `applicationId`, secret `token`, and Discord `clientOptions`. See this [discord.js guide page](https://discordjs.guide/popular-topics/intents.html) for more info on setting up bot intents.
+
+```ts
+const bot = new Bot({ applicationId, token, clientOptions })
 ```
-// guildMemberAdd.ts
-import bot from '../index.js'
 
-bot.on('guildMemberAdd', (member) => {
-  // do stuff
-})
+Once you have your bot setup and are ready for it to start listening for the commands and events you've added:
+
+```ts
+await bot.login()
 ```
 
-### Commands
+## Commands
 
-Your commands are registered by `import`ing the default export of each command file.
+### Creating a slash command
 
-```
-// myCommand.ts
-import { Command } from 'discord-bot-shared'
-import { SlashCommandBuilder } from 'discord.js'
+Commands can be created by constructing `Command` objects that will be added to the bot later.
+
+```ts
+import { Command } from "discord-bot-shared"
+import { SlashCommandBuilder } from "discord.js"
 
-const myCommand: Command = {
-  command: new SlashCommandBuilder()
-    .setName('my-command')
-    .setDescription('This command does stuff.') as SlashCommandBuilder,
-  run: (interaction) => {
-    // do stuff
+const ping: Command = {
+  command: new SlashCommandBuilder().setName("ping").setDescription("I'll respond with pong!").toJSON(),
+  async run(interaction) {
+    await interaction.reply("Pong!")
   },
 }
 
-export default myCommand
+export default ping
 ```
 
-Your `run` function is passed the command interaction that initiated the command.
+Make sure to call `.toJSON()` on `SlashCommandBuilder`.
 
-### Exports
+You can optionally provide a `requiredRoles` string array. If the member initiating the command has _any_ of the roles provided in this array, they will be allowed to run the command.
 
-The following functions and interfaces/types are exported by this module:
+```ts
+const ping: Command = {
+  requiredRoles: ["cool guy", "cooler guy"], // Only members that have a role with the name "cool guy" OR "cooler guy" can run this command.
+  command: // ...
+  run: // ...
+}
+```
 
----
+### Adding and registering commands
 
-#### `function login`
+You can add commands to the bot like so:
 
-```
-async function login(
-  botIntents: ClientOptions,
-  projectMetaURL: string,
-  interactionCheck?: InteractionCheck,
-): Promise<Client>
+```ts
+bot.commands.add(ping)
 ```
 
-- `botIntents` is a discord.js `ClientOptions` object.
-- `projectMetaURL` should always be passed `import.meta.url`. This is used to find and register your events and commands.
-- Optionally provide an `interactionCheck` function that returns a boolean. This function is called right before trying to run a command. The command will only run if `interactionCheck` returns true.
-  - The `InteractionCheck` type is also exported by this module.
+Commands must be registered before they will appear in Discord.
 
----
+```ts
+await bot.commands.register()
+```
 
-#### `function getGuildCache`
+This registers commands globally (for all servers). It's not really recommended to register commands every time your bot starts up as you may get rate-limited by Discord.
 
-Returns an object that contains the guild and the following freshly fetched guild collections: `channels, emojis, members, roles`.
+### Unregistering commands
 
+```ts
+await bot.commands.unregisterApplicationCommands()
 ```
-async function getGuildCache()
+
+This will unregister all commands globally.
+
+### Global Command Hook
+
+You can optionally add a global command hook to your bot. This is a function that will be called before your command's `run` function.
+
+- The global command hook function must return a `boolean`.
+- If `true` is returned, the initiated command will run.
+
+```ts
+bot.commands.setGlobalCommandHook(commandHook)
 ```
 
-- For example, a common pattern I use is something like this:
+This allows you to perform certain actions or make checks before _any_ command runs. For example, you could do something like this:
 
+```ts
+function commandHook(interaction: ChatInputCommandInteraction<"cached">) {
+  if (interaction.channelId === "123456789") {
+    return true
+  } else {
+    throwUserError("This command was not initiated in the right channel.")
+  }
+}
+
+bot.commands.setGlobalCommandHook(commandHook)
 ```
-const { members } = await getGuildCache()
-// do stuff with members
+
+It's intended that you throw an error in the case you don't want the command to run rather than returning `false`. Otherwise, a generic error message will be displayed: `The global command hook returned false.`
+
+`throwUserError` is a special helper function. See [Error Handling](#error-handling) for more info.
+
+## Events
+
+### Listening for event
+
+You can create an `Event` object that will be added to the bot later.
+
+```ts
+import { Event } from "discord-bot-shared"
+import { Events } from "discord.js"
+
+const logNewMember: Event = {
+  event: Events.GuildMemberAdd,
+  handler(client, member) {
+    console.log(`${member.user.username} joined the server.`)
+  },
+}
+
+export default logNewMember
 ```
 
----
+The `Client` instance is always passed as the first argument to the `handler`. The rest of the arguments will be correctly typed based on the event you specify. Also, the `handler` can be `async` if needed.
 
-#### `interface Command`
+### Adding and registering events
 
-This interface defines the structure of your bot's commands. See above for an example of a command.
+You can add events to the bot like so:
 
+```ts
+bot.events.add(logNewMember)
 ```
-interface Command {
-  requiredRoles?: string[]
-  command: SlashCommandBuilder
-  run: (interaction: ChatInputCommandInteraction) => void | Promise<void>
+
+Unlike commands, events do not need to be registered separately. They will be listened for once the bot is logged in.
+
+## Error Handling
+
+This package makes it much easier to handle errors that are thrown during a command or event.
+
+There are two helper functions you can import for throwing errors: `throwError` and `throwUserError`. (These also conveniently allow you to throw an error as an expression.)
+
+- `throwError(message: string)`: Throw a `new Error` with `message`.
+- `throwUserError(message: string)`: Throw a `new UserError` with `message`.
+
+The usage of these is explained below.
+
+### Commands
+
+**TLDR:** Use `throwError` to display an error **with the stack trace** in the interaction reply. Use `throwUserError` to display the error message **only** in the interaction reply. That means by default, any instance of `Error` thrown (say by some function you don't own), will be displayed in the interaction reply with its stack trace (which is probably what you want).
+
+When an error is thrown during a command, the interaction is replied to with the error message. For example:
+
+```ts
+import { Command, throwError } from "discord-bot-shared"
+import { SlashCommandBuilder } from "discord.js"
+
+const ping: Command = {
+  command: new SlashCommandBuilder().setName("ping").setDescription("I'll respond with pong!").toJSON(),
+  async run(interaction) {
+    if (interaction.member.id === "12345") {
+      await interaction.reply("Pong!")
+    } else {
+      throwError("Expected member with ID: 12345")
+    }
+  },
 }
 ```
 
-- Optionally provide `requiredRoles` string array. If the member initiating the command has _any_ of the roles provided in this array, they will be allowed to run the command.
-- **You may have to type cast your command `as SlashCommandBuilder` due to the way discord.js' `SlashCommandBuilder` works.**
-- `run` is the final function that will be called to run your command.
+If a member with an ID of `12345` does not initiate this command, the bot will respond with `There was an error while running this command.` along with the error **and stack trace**.
 
----
+In most cases, you probably want to display a clean (i.e. without the stack trace) error message. That's where `throwUserError` comes in. If this type of error is thrown, only the provided error message is displayed.
 
-#### `function getChannel`
+As a more complete example, let's say we have some command that allows a member to level up when they have enough XP:
 
-Returns the guild channel of the given name/ID and type, otherwise returns `undefined`.
+```ts
+import { Command, throwUserError } from "discord-bot-shared"
+import { SlashCommandBuilder } from "discord.js"
 
-```
-async function getChannel<T extends NonThreadGuildBasedChannel>(
-  channelNameOrId: string,
-  channelType: NonThreadGuildBasedChannelType,
-): Promise<T | undefined>
+const levelUp: Command = {
+  command: new SlashCommandBuilder().setName("level-up").setDescription("Level up if you have enough XP.").toJSON(),
+  async run(interaction) {
+    const memberXP = getMemberXP(interaction.member.id) // This might throw!
+
+    if (memberXP >= 100) {
+      levelUpMember(interaction.member.id)
+      await interaction.reply("Level up!")
+    } else {
+      throwUserError("You don't have enough XP to level up!")
+    }
+  },
+}
 ```
 
-- `T` can be one of `TextChannel | VoiceChannel | NewsChannel | StageChannel | CategoryChannel`.
-- `channelType` is a discord.js `ChannelType`. Can be one of `GuildText | GuildVoice | GuildNews | GuildStageVoice | GuildCategory` (prepended with `ChannelType`).
-- It is intended that you pass in a type for `T` that matches `channelType`. The returned channel is cast as whatever type is passed in.
-- For example:
+- Say `getMemberXP` throws because the underlying database call fails. The member that initiated the command will get a response with the error message and stack trace (which they can then send to you so you can debug the error).
+- If the member doesn't have enough XP, they will receive the message about not having enough XP (no stack trace).
 
-```
-const someTextChannel = await getChannel<TextChannel>('some-text-channel', ChannelType.GuildText)
-```
+**This means that you should generally _not_ try to catch/handle errors in your commands and let it be handled by the bot.**
 
----
+### Events
 
-#### Channel Type Guards
+For events, all errors are caught and logged with `console.error`.
 
-These are channel type guards that you may need to use.
+## Utilities
 
-```
-function isTextChannel(channel: BaseChannel | APIPartialChannel): channel is TextChannel
-```
+### getChannel
 
-```
-function isCategoryChannel(channel: BaseChannel): channel is CategoryChannel
+Returns the guild channel of the given name/ID and type, otherwise throws.
+
+```ts
+import { getChannel } from "discord-bot-shared"
+import { ChannelType } from "discord.js"
+
+// guild is of type Guild from discord.js
+const someTextChannel = await getChannel(guild, "some-text-channel", ChannelType.GuildText)
 ```
 
-- Almost every channel type in discord.js extends `BaseChannel`, so you should be able to pass in whatever channel you need to here.
+Getting a properly typed channel with discord.js can be a bit of a pain, so this is an alternative.

package/dist/command-manager.js

@@ -1,8 +1,8 @@
 import { Collection, Events, Routes, } from "discord.js";
-import { UserError } from "./util.js";
+import { UserError, throwUserError } from "./util.js";
 class CommandManager {
     #commands = new Collection();
-    #globalPreRunHook;
+    #globalCommandHook;
     #discord;
     constructor(discord) {
         this.#discord = discord;
@@ -13,8 +13,8 @@ class CommandManager {
     add(command) {
         this.#commands.set(command.command.name, command);
     }
-    setGlobalPreRunHook(hook) {
-        this.#globalPreRunHook = hook;
+    setGlobalCommandHook(commandHook) {
+        this.#globalCommandHook = commandHook;
     }
     async register() {
         const payload = this.#commands.map((c) => c.command);
@@ -74,9 +74,9 @@ class CommandManager {
                 return;
             }
             try {
-                const shouldContinue = this.#globalPreRunHook ? await this.#globalPreRunHook(interaction) : true;
+                const shouldContinue = this.#globalCommandHook ? await this.#globalCommandHook(interaction) : true;
                 if (!shouldContinue)
-                    return;
+                    throwUserError("The global command hook returned false.");
                 await command.run(interaction);
             }
             catch (error) {
@@ -111,4 +111,4 @@ class CommandManager {
     }
 }
 export default CommandManager;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/event-manager.js

@@ -13,11 +13,16 @@ class EventManager {
     _listen() {
         for (const event of this.#events) {
             this.#discord.client.on(event.event, async (...args) => {
-                await event.handler(this.#discord.client, ...args).catch(console.error);
+                try {
+                    await event.handler(this.#discord.client, ...args);
+                }
+                catch (error) {
+                    console.error(error);
+                }
             });
         }
         console.log(`Listening for (${this.#events.length}) events.`);
     }
 }
 export default EventManager;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnQtbWFuYWdlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9ldmVudC1tYW5hZ2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQWdCQSxNQUFNLFlBQVk7SUFDaEIsT0FBTyxHQUFrQixFQUFFLENBQUE7SUFDM0IsUUFBUSxDQUFnQjtJQUV4QixZQUFZLE9BQXVCO1FBQ2pDLElBQUksQ0FBQyxRQUFRLEdBQUcsT0FBTyxDQUFBO0lBQ3pCLENBQUM7SUFFRDs7T0FFRztJQUNILEdBQUcsQ0FBd0IsS0FBcUI7UUFDOUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUE7SUFDMUIsQ0FBQztJQUVELE9BQU87UUFDTCxLQUFLLE1BQU0sS0FBSyxJQUFJLElBQUksQ0FBQyxPQUFPLEVBQUU7WUFDaEMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLEtBQUssQ0FBQyxLQUFLLEVBQUUsS0FBSyxFQUFFLEdBQUcsSUFBSSxFQUFFLEVBQUU7Z0JBQ3JELE1BQU8sS0FBSyxDQUFDLE9BQXdCLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxNQUFNLEVBQUUsR0FBRyxJQUFJLENBQUMsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFBO1lBQzNGLENBQUMsQ0FBQyxDQUFBO1NBQ0g7UUFDRCxPQUFPLENBQUMsR0FBRyxDQUFDLGtCQUFrQixJQUFJLENBQUMsT0FBTyxDQUFDLE1BQU0sV0FBVyxDQUFDLENBQUE7SUFDL0QsQ0FBQztDQUNGO0FBTUQsZUFBZSxZQUFZLENBQUEifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnQtbWFuYWdlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9ldmVudC1tYW5hZ2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQW1CQSxNQUFNLFlBQVk7SUFDaEIsT0FBTyxHQUFrQixFQUFFLENBQUE7SUFDM0IsUUFBUSxDQUFnQjtJQUV4QixZQUFZLE9BQXVCO1FBQ2pDLElBQUksQ0FBQyxRQUFRLEdBQUcsT0FBTyxDQUFBO0lBQ3pCLENBQUM7SUFFRDs7T0FFRztJQUNILEdBQUcsQ0FBd0IsS0FBcUI7UUFDOUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUE7SUFDMUIsQ0FBQztJQUVELE9BQU87UUFDTCxLQUFLLE1BQU0sS0FBSyxJQUFJLElBQUksQ0FBQyxPQUFPLEVBQUU7WUFDaEMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLEtBQUssQ0FBQyxLQUFLLEVBQUUsS0FBSyxFQUFFLEdBQUcsSUFBSSxFQUFFLEVBQUU7Z0JBQ3JELElBQUk7b0JBQ0YsTUFBTyxLQUFLLENBQUMsT0FBd0IsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLE1BQU0sRUFBRSxHQUFHLElBQUksQ0FBQyxDQUFBO2lCQUNyRTtnQkFBQyxPQUFPLEtBQUssRUFBRTtvQkFDZCxPQUFPLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxDQUFBO2lCQUNyQjtZQUNILENBQUMsQ0FBQyxDQUFBO1NBQ0g7UUFDRCxPQUFPLENBQUMsR0FBRyxDQUFDLGtCQUFrQixJQUFJLENBQUMsT0FBTyxDQUFDLE1BQU0sV0FBVyxDQUFDLENBQUE7SUFDL0QsQ0FBQztDQUNGO0FBTUQsZUFBZSxZQUFZLENBQUEifQ==

package/dist/types/command-manager.d.ts

@@ -5,12 +5,12 @@ interface Command {
     command: RESTPostAPIChatInputApplicationCommandsJSONBody;
     run: (interaction: ChatInputCommandInteraction<"cached">) => void | Promise<void>;
 }
-type CommandHook = (interaction: ChatInputCommandInteraction<"cached">) => Promise<boolean>;
+type CommandHook = (interaction: ChatInputCommandInteraction<"cached">) => boolean | Promise<boolean>;
 declare class CommandManager {
     #private;
     constructor(discord: DiscordContext);
     add(command: Command): void;
-    setGlobalPreRunHook(hook: CommandHook): void;
+    setGlobalCommandHook(commandHook: CommandHook): void;
     register(): Promise<void>;
     unregisterGuildCommands(): Promise<void>;
     private _unregisterGuildCommands;

package/dist/types/event-manager.d.ts

@@ -1,7 +1,7 @@
 import { Client, ClientEvents, Events } from "discord.js";
 import { DiscordContext } from "./bot.js";
 type ValidEvents = Exclude<Events, Events.VoiceServerUpdate | Events.Raw>;
-type EventHandler<E extends ValidEvents = ValidEvents> = (client: Client, ...args: ClientEvents[E]) => Promise<void>;
+type EventHandler<E extends ValidEvents = ValidEvents> = (client: Client, ...args: ClientEvents[E]) => void | Promise<void>;
 type EventHandlerMap = {
     [E in ValidEvents]: EventHandler<E>;
 };

package/dist/types/util.d.ts

@@ -8,8 +8,8 @@ interface ChannelTypeToChannelMap {
     [ChannelType.GuildForum]: ForumChannel;
 }
 declare function getChannel<T extends keyof ChannelTypeToChannelMap>(guild: Guild, channelNameOrId: string, channelType: T): Promise<ChannelTypeToChannelMap[T]>;
-declare function throwError(error: string): never;
-declare function throwUserError(error: string): never;
+declare function throwError(message: string): never;
+declare function throwUserError(message: string): never;
 declare class UserError extends Error {
     constructor(message: string);
 }

package/dist/util.js

@@ -10,11 +10,11 @@ async function getChannel(guild, channelNameOrId, channelType) {
         return channel;
     throwError(`Failed to get channel: ${channelNameOrId}`);
 }
-function throwError(error) {
-    throw new Error(error);
+function throwError(message) {
+    throw new Error(message);
 }
-function throwUserError(error) {
-    throw new UserError(error);
+function throwUserError(message) {
+    throw new UserError(message);
 }
 class UserError extends Error {
     constructor(message) {
@@ -24,4 +24,4 @@ class UserError extends Error {
     }
 }
 export { UserError, getChannel, throwError, throwUserError };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy91dGlsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFFTCxXQUFXLEdBUVosTUFBTSxZQUFZLENBQUE7QUFXbkIsS0FBSyxVQUFVLFVBQVUsQ0FDdkIsS0FBWSxFQUNaLGVBQXVCLEVBQ3ZCLFdBQWM7SUFFZCxNQUFNLFFBQVEsR0FBRyxNQUFNLEtBQUssQ0FBQyxRQUFRLENBQUMsS0FBSyxFQUFFLENBQUE7SUFFN0MsSUFBSSxPQUFzRCxDQUFBO0lBQzFELE9BQU8sR0FBRyxRQUFRLENBQUMsSUFBSSxDQUFDLENBQUMsT0FBTyxFQUFFLEVBQUUsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLElBQUksS0FBSyxlQUFlLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUE7SUFDMUYsSUFBSSxPQUFPLElBQUksT0FBTyxDQUFDLElBQUksS0FBSyxXQUFXO1FBQUUsT0FBTyxPQUFxQyxDQUFBO0lBRXpGLE9BQU8sR0FBRyxRQUFRLENBQUMsR0FBRyxDQUFDLGVBQWUsQ0FBQyxDQUFBO0lBQ3ZDLElBQUksT0FBTyxJQUFJLE9BQU8sQ0FBQyxJQUFJLEtBQUssV0FBVztRQUFFLE9BQU8sT0FBcUMsQ0FBQTtJQUV6RixVQUFVLENBQUMsMEJBQTBCLGVBQWUsRUFBRSxDQUFDLENBQUE7QUFDekQsQ0FBQztBQUVELFNBQVMsVUFBVSxDQUFDLEtBQWE7SUFDL0IsTUFBTSxJQUFJLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQTtBQUN4QixDQUFDO0FBRUQsU0FBUyxjQUFjLENBQUMsS0FBYTtJQUNuQyxNQUFNLElBQUksU0FBUyxDQUFDLEtBQUssQ0FBQyxDQUFBO0FBQzVCLENBQUM7QUFFRCxNQUFNLFNBQVUsU0FBUSxLQUFLO0lBQzNCLFlBQVksT0FBZTtRQUN6QixLQUFLLENBQUMsT0FBTyxDQUFDLENBQUE7UUFDZCxJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUFBO1FBRWpDLE1BQU0sQ0FBQyxjQUFjLENBQUMsSUFBSSxFQUFFLEdBQUcsQ0FBQyxNQUFNLENBQUMsU0FBUyxDQUFDLENBQUE7SUFDbkQsQ0FBQztDQUNGO0FBRUQsT0FBTyxFQUFFLFNBQVMsRUFBRSxVQUFVLEVBQUUsVUFBVSxFQUFFLGNBQWMsRUFBRSxDQUFBIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy91dGlsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFFTCxXQUFXLEdBUVosTUFBTSxZQUFZLENBQUE7QUFXbkIsS0FBSyxVQUFVLFVBQVUsQ0FDdkIsS0FBWSxFQUNaLGVBQXVCLEVBQ3ZCLFdBQWM7SUFFZCxNQUFNLFFBQVEsR0FBRyxNQUFNLEtBQUssQ0FBQyxRQUFRLENBQUMsS0FBSyxFQUFFLENBQUE7SUFFN0MsSUFBSSxPQUFzRCxDQUFBO0lBQzFELE9BQU8sR0FBRyxRQUFRLENBQUMsSUFBSSxDQUFDLENBQUMsT0FBTyxFQUFFLEVBQUUsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLElBQUksS0FBSyxlQUFlLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUE7SUFDMUYsSUFBSSxPQUFPLElBQUksT0FBTyxDQUFDLElBQUksS0FBSyxXQUFXO1FBQUUsT0FBTyxPQUFxQyxDQUFBO0lBRXpGLE9BQU8sR0FBRyxRQUFRLENBQUMsR0FBRyxDQUFDLGVBQWUsQ0FBQyxDQUFBO0lBQ3ZDLElBQUksT0FBTyxJQUFJLE9BQU8sQ0FBQyxJQUFJLEtBQUssV0FBVztRQUFFLE9BQU8sT0FBcUMsQ0FBQTtJQUV6RixVQUFVLENBQUMsMEJBQTBCLGVBQWUsRUFBRSxDQUFDLENBQUE7QUFDekQsQ0FBQztBQUVELFNBQVMsVUFBVSxDQUFDLE9BQWU7SUFDakMsTUFBTSxJQUFJLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQTtBQUMxQixDQUFDO0FBRUQsU0FBUyxjQUFjLENBQUMsT0FBZTtJQUNyQyxNQUFNLElBQUksU0FBUyxDQUFDLE9BQU8sQ0FBQyxDQUFBO0FBQzlCLENBQUM7QUFFRCxNQUFNLFNBQVUsU0FBUSxLQUFLO0lBQzNCLFlBQVksT0FBZTtRQUN6QixLQUFLLENBQUMsT0FBTyxDQUFDLENBQUE7UUFDZCxJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUFBO1FBRWpDLE1BQU0sQ0FBQyxjQUFjLENBQUMsSUFBSSxFQUFFLEdBQUcsQ0FBQyxNQUFNLENBQUMsU0FBUyxDQUFDLENBQUE7SUFDbkQsQ0FBQztDQUNGO0FBRUQsT0FBTyxFQUFFLFNBQVMsRUFBRSxVQUFVLEVBQUUsVUFBVSxFQUFFLGNBQWMsRUFBRSxDQUFBIn0=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discord-bot-shared",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "type": "module",
   "description": "Modules for creating discord bots.",
   "repository": "github:adamhl8/discord-bot-shared",
@@ -34,7 +34,7 @@
   "scripts": {
     "build": "rm -rf dist && tsc",
     "format": "prettier --write .",
-    "lint": "eslint ./src/",
+    "lint": "tsc --noEmit && eslint ./src/",
     "prepublish": "pnpm build"
   }
 }