discord-bot-shared 0.5.0 → 0.5.1

package/dist/commands.d.ts

@@ -1,10 +1,10 @@
-import { ChatInputCommandInteraction, Collection, SlashCommandBuilder } from 'discord.js'
+import { ChatInputCommandInteraction, Collection, SlashCommandBuilder } from 'discord.js';
 interface Command {
-  requiredRoles?: string[]
-  command: SlashCommandBuilder
-  run: (interaction: ChatInputCommandInteraction) => void | Promise<void>
+    requiredRoles?: string[];
+    command: SlashCommandBuilder;
+    run: (interaction: ChatInputCommandInteraction) => void | Promise<void>;
 }
-declare type CommandsCollection = Collection<string, Command>
-declare function registerCommands(botToken: string, clientId: string, projectMetaURL: string, guildId?: string): Promise<CommandsCollection>
-export default registerCommands
-export { Command, CommandsCollection }
+declare type CommandsCollection = Collection<string, Command>;
+declare function registerCommands(botToken: string, clientId: string, projectMetaURL: string, guildId?: string): Promise<CommandsCollection>;
+export default registerCommands;
+export { Command, CommandsCollection };

package/dist/commands.js

@@ -1,25 +1,26 @@
-import { REST } from '@discordjs/rest'
-import { Routes } from 'discord-api-types/v10'
-import { Collection } from 'discord.js'
-import { readdir } from 'node:fs/promises'
-import { fileURLToPath } from 'node:url'
+import { REST } from '@discordjs/rest';
+import { Routes } from 'discord-api-types/v10';
+import { Collection } from 'discord.js';
+import { readdir } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
 async function registerCommands(botToken, clientId, projectMetaURL, guildId) {
-  const commands = new Collection()
-  const commandData = []
-  const commandsDirectory = fileURLToPath(new URL('commands', projectMetaURL))
-  const commandFiles = await readdir(commandsDirectory)
-  if (!commandFiles) return commands
-  for (const file of commandFiles) {
-    const { default: command } = await import(`${commandsDirectory}/${file}`)
-    commands.set(command.command.name, command)
-    commandData.push(command.command.toJSON())
-  }
-  const rest = new REST().setToken(botToken)
-  guildId
-    ? await rest.put(Routes.applicationGuildCommands(clientId, guildId), { body: commandData })
-    : await rest.put(Routes.applicationCommands(clientId), { body: commandData })
-  console.log('Registered application (/) commands.')
-  return commands
+    const commands = new Collection();
+    const commandData = [];
+    const commandsDirectory = fileURLToPath(new URL('commands', projectMetaURL));
+    const commandFiles = await readdir(commandsDirectory);
+    if (!commandFiles)
+        return commands;
+    for (const file of commandFiles) {
+        const { default: command } = (await import(`${commandsDirectory}/${file}`));
+        commands.set(command.command.name, command);
+        commandData.push(command.command.toJSON());
+    }
+    const rest = new REST().setToken(botToken);
+    guildId
+        ? await rest.put(Routes.applicationGuildCommands(clientId, guildId), { body: commandData })
+        : await rest.put(Routes.applicationCommands(clientId), { body: commandData });
+    console.log('Registered application (/) commands.');
+    return commands;
 }
-export default registerCommands
-//# sourceMappingURL=commands.js.map
+export default registerCommands;
+//# sourceMappingURL=commands.js.map

package/dist/events.d.ts

@@ -1,2 +1,2 @@
-declare function registerEvents(projectMetaURL: string): Promise<void>
-export default registerEvents
+declare function registerEvents(projectMetaURL: string): Promise<void>;
+export default registerEvents;

package/dist/events.js

@@ -1,12 +1,13 @@
-import { readdir } from 'node:fs/promises'
-import { fileURLToPath } from 'node:url'
+import { readdir } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
 async function registerEvents(projectMetaURL) {
-  const eventsDirectory = fileURLToPath(new URL('events', projectMetaURL))
-  const eventFiles = await readdir(eventsDirectory).catch(console.error)
-  if (!eventFiles) return
-  for (const file of eventFiles) {
-    await import(`${eventsDirectory}/${file}`)
-  }
+    const eventsDirectory = fileURLToPath(new URL('events', projectMetaURL));
+    const eventFiles = await readdir(eventsDirectory).catch(console.error);
+    if (!eventFiles)
+        return;
+    for (const file of eventFiles) {
+        await import(`${eventsDirectory}/${file}`);
+    }
 }
-export default registerEvents
-//# sourceMappingURL=events.js.map
+export default registerEvents;
+//# sourceMappingURL=events.js.map

package/dist/guildCache.d.ts

@@ -1,14 +1,11 @@
-import { Client } from 'discord.js'
-declare function setBot(botClient: Client): void
-declare function getGuildCache(): Promise<
-  | {
-      guild: import('discord.js').Guild
-      channels: import('discord.js').Collection<string, import('discord.js').NonThreadGuildBasedChannel>
-      emojis: import('discord.js').Collection<string, import('discord.js').GuildEmoji>
-      members: import('discord.js').Collection<string, import('discord.js').GuildMember>
-      roles: import('discord.js').Collection<string, import('discord.js').Role>
-    }
-  | undefined
->
-export default getGuildCache
-export { setBot }
+import { Client } from 'discord.js';
+declare function setBot(botClient: Client): void;
+declare function getGuildCache(): Promise<{
+    guild: import("discord.js").Guild;
+    channels: import("discord.js").Collection<string, import("discord.js").NonThreadGuildBasedChannel>;
+    emojis: import("discord.js").Collection<string, import("discord.js").GuildEmoji>;
+    members: import("discord.js").Collection<string, import("discord.js").GuildMember>;
+    roles: import("discord.js").Collection<string, import("discord.js").Role>;
+} | undefined>;
+export default getGuildCache;
+export { setBot };

package/dist/guildCache.js

@@ -1,29 +1,36 @@
-let bot
+let bot;
 function setBot(botClient) {
-  bot = botClient
+    bot = botClient;
 }
 async function getGuildCache() {
-  if (!bot) return
-  const guilds = await bot.guilds.fetch()
-  if (!guilds) return
-  const guild = await guilds.first()?.fetch()
-  if (!guild) return
-  const channels = await guild.channels.fetch()
-  if (!channels) return
-  const emojis = await guild.emojis.fetch()
-  if (!emojis) return
-  const members = await guild.members.fetch()
-  if (!members) return
-  const roles = await guild.roles.fetch()
-  if (!roles) return
-  return {
-    guild,
-    channels,
-    emojis,
-    members,
-    roles,
-  }
+    if (!bot)
+        return;
+    const guilds = await bot.guilds.fetch();
+    if (!guilds)
+        return;
+    const guild = await guilds.first()?.fetch();
+    if (!guild)
+        return;
+    const channels = await guild.channels.fetch();
+    if (!channels)
+        return;
+    const emojis = await guild.emojis.fetch();
+    if (!emojis)
+        return;
+    const members = await guild.members.fetch();
+    if (!members)
+        return;
+    const roles = await guild.roles.fetch();
+    if (!roles)
+        return;
+    return {
+        guild,
+        channels,
+        emojis,
+        members,
+        roles,
+    };
 }
-export default getGuildCache
-export { setBot }
-//# sourceMappingURL=guildCache.js.map
+export default getGuildCache;
+export { setBot };
+//# sourceMappingURL=guildCache.js.map

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-import { Client, ClientOptions } from 'discord.js'
-import { InteractionCheck } from './interactionCreate.js'
-declare function login(botIntents: ClientOptions, projectMetaURL: string, interactionCheck?: InteractionCheck): Promise<Client>
-export default login
-export { Command } from './commands.js'
-export { default as getGuildCache } from './guildCache.js'
-export { InteractionCheck } from './interactionCreate.js'
-export { getChannel, isCategoryChannel, isTextChannel, throwError } from './util.js'
+import { Client, ClientOptions } from 'discord.js';
+import { InteractionCheck } from './interactionCreate.js';
+declare function login(botIntents: ClientOptions, projectMetaURL: string, interactionCheck?: InteractionCheck): Promise<Client>;
+export default login;
+export { Command } from './commands.js';
+export { default as getGuildCache } from './guildCache.js';
+export { InteractionCheck } from './interactionCreate.js';
+export { getChannel, isCategoryChannel, isTextChannel, throwError } from './util.js';

package/dist/index.js

@@ -1,23 +1,23 @@
-import { Client } from 'discord.js'
-import registerCommands from './commands.js'
-import registerEvents from './events.js'
-import { setBot } from './guildCache.js'
-import registerInteractionCreate from './interactionCreate.js'
-import registerReady from './ready.js'
-const botToken = process.env.BOT_TOKEN || ''
-const clientId = process.env.CLIENT_ID || ''
-const guildId = process.env.GUILD_ID || ''
+import { Client } from 'discord.js';
+import registerCommands from './commands.js';
+import registerEvents from './events.js';
+import { setBot } from './guildCache.js';
+import registerInteractionCreate from './interactionCreate.js';
+import registerReady from './ready.js';
+const botToken = process.env.BOT_TOKEN || '';
+const clientId = process.env.CLIENT_ID || '';
+const guildId = process.env.GUILD_ID || '';
 async function login(botIntents, projectMetaURL, interactionCheck) {
-  const bot = new Client(botIntents)
-  const commands = await registerCommands(botToken, clientId, projectMetaURL, guildId)
-  registerReady(bot)
-  registerInteractionCreate(bot, commands, interactionCheck)
-  void registerEvents(projectMetaURL)
-  setBot(bot)
-  void bot.login(botToken)
-  return bot
+    const bot = new Client(botIntents);
+    const commands = await registerCommands(botToken, clientId, projectMetaURL, guildId);
+    registerReady(bot);
+    registerInteractionCreate(bot, commands, interactionCheck);
+    void registerEvents(projectMetaURL);
+    setBot(bot);
+    void bot.login(botToken);
+    return bot;
 }
-export default login
-export { default as getGuildCache } from './guildCache.js'
-export { getChannel, isCategoryChannel, isTextChannel, throwError } from './util.js'
-//# sourceMappingURL=index.js.map
+export default login;
+export { default as getGuildCache } from './guildCache.js';
+export { getChannel, isCategoryChannel, isTextChannel, throwError } from './util.js';
+//# sourceMappingURL=index.js.map

package/dist/interactionCreate.d.ts

@@ -1,6 +1,6 @@
-import { ChatInputCommandInteraction, Client } from 'discord.js'
-import { CommandsCollection } from './commands.js'
-declare type InteractionCheck = (interaction: ChatInputCommandInteraction) => Promise<boolean | void>
-declare function registerInteractionCreate(bot: Client, commands: CommandsCollection, interactionCheck?: InteractionCheck): void
-export default registerInteractionCreate
-export { InteractionCheck }
+import { ChatInputCommandInteraction, Client } from 'discord.js';
+import { CommandsCollection } from './commands.js';
+declare type InteractionCheck = (interaction: ChatInputCommandInteraction) => Promise<boolean | void>;
+declare function registerInteractionCreate(bot: Client, commands: CommandsCollection, interactionCheck?: InteractionCheck): void;
+export default registerInteractionCreate;
+export { InteractionCheck };

package/dist/interactionCreate.js

@@ -1,33 +1,39 @@
 function registerInteractionCreate(bot, commands, interactionCheck) {
-  bot.on('interactionCreate', async (interaction) => {
-    if (!interaction.isChatInputCommand()) return
-    const command = commands.get(interaction.commandName)
-    if (!command) return interactionReply(interaction, 'Unable to get command.')
-    if (!(await checkRoles(command, interaction)))
-      return interactionReply(interaction, 'You do not have one of the required roles to run this command.')
-    try {
-      const interactionCheckPassed = interactionCheck ? await interactionCheck(interaction) : true
-      if (!interactionCheckPassed) return
-      await command.run(interaction)
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : ''
-      interactionReply(interaction, `There was an error while running this command.\n${errorMessage}`)
-    }
-  })
+    bot.on('interactionCreate', async (interaction) => {
+        if (!interaction.isChatInputCommand())
+            return;
+        const command = commands.get(interaction.commandName);
+        if (!command)
+            return interactionReply(interaction, 'Unable to get command.');
+        if (!(await checkRoles(command, interaction)))
+            return interactionReply(interaction, 'You do not have one of the required roles to run this command.');
+        try {
+            const interactionCheckPassed = interactionCheck ? await interactionCheck(interaction) : true;
+            if (!interactionCheckPassed)
+                return;
+            await command.run(interaction);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : '';
+            interactionReply(interaction, `There was an error while running this command.\n${errorMessage}`);
+        }
+    });
 }
 async function checkRoles(command, interaction) {
-  if (!command.requiredRoles) return true
-  if (command.requiredRoles.length > 0) {
-    const member = await interaction.guild?.members.fetch(interaction.user).catch(console.error)
-    if (!member) return
-    return member.roles.cache.some((role) => (command.requiredRoles ? command.requiredRoles.includes(role.name) : false))
-  }
-  return false
+    if (!command.requiredRoles)
+        return true;
+    if (command.requiredRoles.length > 0) {
+        const member = await interaction.guild?.members.fetch(interaction.user).catch(console.error);
+        if (!member)
+            return;
+        return member.roles.cache.some((role) => (command.requiredRoles ? command.requiredRoles.includes(role.name) : false));
+    }
+    return false;
 }
 function interactionReply(interaction, message) {
-  interaction.deferred
-    ? void interaction.editReply(message).catch(console.error)
-    : void interaction.reply({ content: message, ephemeral: true }).catch(console.error)
+    interaction.deferred
+        ? void interaction.editReply(message).catch(console.error)
+        : void interaction.reply({ content: message, ephemeral: true }).catch(console.error);
 }
-export default registerInteractionCreate
-//# sourceMappingURL=interactionCreate.js.map
+export default registerInteractionCreate;
+//# sourceMappingURL=interactionCreate.js.map

package/dist/ready.d.ts

@@ -1,3 +1,3 @@
-import { Client } from 'discord.js'
-declare function registerReady(bot: Client): void
-export default registerReady
+import { Client } from 'discord.js';
+declare function registerReady(bot: Client): void;
+export default registerReady;

package/dist/ready.js

@@ -1,7 +1,7 @@
 function registerReady(bot) {
-  bot.once('ready', () => {
-    console.log('I am ready!')
-  })
+    bot.once('ready', () => {
+        console.log('I am ready!');
+    });
 }
-export default registerReady
-//# sourceMappingURL=ready.js.map
+export default registerReady;
+//# sourceMappingURL=ready.js.map

package/dist/util.d.ts

@@ -1,15 +1,7 @@
-import { APIPartialChannel, BaseChannel, CategoryChannel, ChannelType, NonThreadGuildBasedChannel, TextChannel } from 'discord.js'
-declare type NonThreadGuildBasedChannelType =
-  | ChannelType.GuildText
-  | ChannelType.GuildVoice
-  | ChannelType.GuildNews
-  | ChannelType.GuildStageVoice
-  | ChannelType.GuildCategory
-declare function getChannel<T extends NonThreadGuildBasedChannel>(
-  channelNameOrId: string,
-  channelType: NonThreadGuildBasedChannelType,
-): Promise<T | undefined>
-declare function isTextChannel(channel: BaseChannel | APIPartialChannel): channel is TextChannel
-declare function isCategoryChannel(channel: BaseChannel): channel is CategoryChannel
-declare function throwError(error: string): never
-export { getChannel, isTextChannel, isCategoryChannel, throwError }
+import { APIPartialChannel, BaseChannel, CategoryChannel, ChannelType, NonThreadGuildBasedChannel, TextChannel } from 'discord.js';
+declare type NonThreadGuildBasedChannelType = ChannelType.GuildText | ChannelType.GuildVoice | ChannelType.GuildNews | ChannelType.GuildStageVoice | ChannelType.GuildCategory;
+declare function getChannel<T extends NonThreadGuildBasedChannel>(channelNameOrId: string, channelType: NonThreadGuildBasedChannelType): Promise<T | undefined>;
+declare function isTextChannel(channel: BaseChannel | APIPartialChannel): channel is TextChannel;
+declare function isCategoryChannel(channel: BaseChannel): channel is CategoryChannel;
+declare function throwError(error: string): never;
+export { getChannel, isTextChannel, isCategoryChannel, throwError };

package/dist/util.js

@@ -1,21 +1,23 @@
-import { ChannelType } from 'discord.js'
-import getGuildCache from './guildCache.js'
+import { ChannelType } from 'discord.js';
+import getGuildCache from './guildCache.js';
 async function getChannel(channelNameOrId, channelType) {
-  const { channels } = (await getGuildCache()) || throwError('Unable to get guild cache.')
-  let channel
-  channel = channels.find((channel) => channel.name === channelNameOrId)
-  if (channel) return channel.type === channelType ? channel : undefined
-  channel = channels.get(channelNameOrId)
-  if (channel) return channel.type === channelType ? channel : undefined
+    const { channels } = (await getGuildCache()) || throwError('Unable to get guild cache.');
+    let channel;
+    channel = channels.find((channel) => channel.name === channelNameOrId);
+    if (channel)
+        return channel.type === channelType ? channel : undefined;
+    channel = channels.get(channelNameOrId);
+    if (channel)
+        return channel.type === channelType ? channel : undefined;
 }
 function isTextChannel(channel) {
-  return channel.type === ChannelType.GuildText
+    return channel.type === ChannelType.GuildText;
 }
 function isCategoryChannel(channel) {
-  return channel.type === ChannelType.GuildCategory
+    return channel.type === ChannelType.GuildCategory;
 }
 function throwError(error) {
-  throw new Error(error)
+    throw new Error(error);
 }
-export { getChannel, isTextChannel, isCategoryChannel, throwError }
-//# sourceMappingURL=util.js.map
+export { getChannel, isTextChannel, isCategoryChannel, throwError };
+//# sourceMappingURL=util.js.map

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "discord-bot-shared",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "type": "module",
   "description": "Modules for creating discord bots.",
   "repository": "github:adamhl8/discord-bot-shared",
   "author": "adamhl8",
   "license": "MIT",
-  "main": "dist/index",
+  "main": "dist/index.js",
   "files": [
     "dist/",
     "README.md",
@@ -15,29 +15,29 @@
   "scripts": {
     "build": "tsc",
     "format": "prettier --write .",
-    "lint": "eslint -f pretty --fix ."
+    "lint": "eslint -f pretty"
   },
   "dependencies": {
-    "@discordjs/rest": "^1.0.1",
-    "discord-api-types": "^0.37.3",
-    "discord.js": "^14.2.0"
+    "@discordjs/rest": "^1.1.0",
+    "discord-api-types": "^0.37.9",
+    "discord.js": "^14.3.0"
   },
   "devDependencies": {
     "@types/eslint": "^8.4.6",
-    "@types/node": "^18.7.9",
+    "@types/node": "^18.7.16",
     "@types/prettier": "^2.7.0",
-    "@typescript-eslint/eslint-plugin": "^5.33.1",
-    "@typescript-eslint/parser": "^5.33.1",
-    "eslint": "^8.22.0",
+    "@typescript-eslint/eslint-plugin": "^5.37.0",
+    "@typescript-eslint/parser": "^5.37.0",
+    "eslint": "^8.23.1",
     "eslint-config-prettier": "^8.5.0",
     "eslint-formatter-pretty": "^4.1.0",
     "eslint-plugin-eslint-comments": "^3.2.0",
     "eslint-plugin-sonarjs": "^0.15.0",
     "eslint-plugin-unicorn": "^43.0.2",
     "prettier": "^2.7.1",
-    "prettier-plugin-organize-imports": "^3.1.0",
-    "prettier-plugin-pkg": "^0.17.0",
+    "prettier-plugin-organize-imports": "^3.1.1",
+    "prettier-plugin-pkg": "^0.17.1",
     "prettier-plugin-sh": "^0.12.8",
-    "typescript": "^4.7.4"
+    "typescript": "^4.8.3"
   }
 }