@buape/carbon 0.1.0

package/src/internals/AutocompleteInteraction.ts

@@ -0,0 +1,107 @@
+import type { BaseCommand } from "../abstracts/BaseCommand.js"
+import { BaseInteraction } from "../abstracts/BaseInteraction.js"
+import {
+	type APIApplicationCommandInteractionDataBasicOption,
+	ApplicationCommandOptionType,
+	ApplicationCommandType,
+	InteractionType,
+	type APIApplicationCommandAutocompleteInteraction,
+	Routes,
+	InteractionResponseType
+} from "discord-api-types/v10"
+import type { Client } from "../classes/Client.js"
+import { Command } from "../classes/Command.js"
+import { OptionsHandler } from "./OptionsHandler.js"
+
+export class AutocompleteInteraction extends BaseInteraction<APIApplicationCommandAutocompleteInteraction> {
+	/**
+	 * This is the options of the commands, parsed from the interaction data.
+	 */
+	options?: AutocompleteOptionsHandler
+	constructor(
+		client: Client,
+		data: APIApplicationCommandAutocompleteInteraction,
+		command?: BaseCommand
+	) {
+		super(client, data)
+		if (data.type !== InteractionType.ApplicationCommandAutocomplete) {
+			throw new Error("Invalid interaction type was used to create this class")
+		}
+		if (data.data.type !== ApplicationCommandType.ChatInput) {
+			throw new Error("Invalid command type was used to create this class")
+		}
+		if (
+			command instanceof Command &&
+			!data.data.options?.find(
+				(x) =>
+					x.type === ApplicationCommandOptionType.Subcommand ||
+					x.type === ApplicationCommandOptionType.SubcommandGroup
+			)
+		) {
+			this.options = new AutocompleteOptionsHandler(
+				client,
+				(data.data.options ??
+					[]) as APIApplicationCommandInteractionDataBasicOption[]
+			)
+		}
+	}
+
+	override async defer() {
+		throw new Error("Defer is not available for autocomplete interactions")
+	}
+
+	override async reply() {
+		throw new Error("Reply is not available for autocomplete interactions")
+	}
+
+	/**
+	 * Respond with the choices for an autocomplete interaction
+	 */
+	async respond(
+		choices: {
+			/**
+			 * The name of the choice, this is what the user will see
+			 */
+			name: string
+			/**
+			 * The value of the choice, this is what the bot will receive from Discord as the value
+			 */
+			value: string
+		}[]
+	) {
+		console.log(choices)
+		await this.client.rest.post(
+			Routes.interactionCallback(this.rawData.id, this.rawData.token),
+			{
+				body: {
+					type: InteractionResponseType.ApplicationCommandAutocompleteResult,
+					data: {
+						choices
+					}
+				}
+			}
+		)
+	}
+}
+
+export class AutocompleteOptionsHandler extends OptionsHandler {
+	/**
+	 * Get the focused option (the one that is being autocompleted)
+	 */
+	getFocused() {
+		const focused = this.raw.find((x) => "focused" in x && x.focused)
+		if (!focused) return null
+		switch (focused.type) {
+			case ApplicationCommandOptionType.String:
+				return this.getString(focused.name)
+			case ApplicationCommandOptionType.Integer:
+				return this.getInteger(focused.name)
+			case ApplicationCommandOptionType.Number:
+				return this.getNumber(focused.name)
+			case ApplicationCommandOptionType.Boolean:
+				return this.getBoolean(focused.name)
+			default:
+				return null
+		}
+	}
+}

package/src/internals/ButtonInteraction.ts

@@ -0,0 +1,26 @@
+import {
+	type APIMessageButtonInteractionData,
+	type APIMessageComponentButtonInteraction,
+	ComponentType,
+	InteractionType
+} from "discord-api-types/v10"
+import { BaseComponentInteraction } from "../abstracts/BaseComponentInteraction.js"
+import type { Client } from "../classes/Client.js"
+import { splitCustomId } from "../utils.js"
+
+export class ButtonInteraction extends BaseComponentInteraction {
+	customId: string = splitCustomId(
+		(this.rawData.data as APIMessageButtonInteractionData).custom_id
+	)[0]
+	constructor(client: Client, data: APIMessageComponentButtonInteraction) {
+		super(client, data)
+		if (!data.data)
+			throw new Error("Invalid interaction data was used to create this class")
+		if (data.type !== InteractionType.MessageComponent) {
+			throw new Error("Invalid interaction type was used to create this class")
+		}
+		if (data.data.component_type !== ComponentType.Button) {
+			throw new Error("Invalid component type was used to create this class")
+		}
+	}
+}

package/src/internals/ChannelSelectMenuInteraction.ts

@@ -0,0 +1,15 @@
+import {
+	type APIMessageComponentSelectMenuInteraction,
+	ComponentType
+} from "discord-api-types/v10"
+import { AnySelectMenuInteraction } from "../abstracts/AnySelectMenuInteraction.js"
+import type { Client } from "../classes/Client.js"
+
+export class ChannelSelectMenuInteraction extends AnySelectMenuInteraction {
+	constructor(client: Client, data: APIMessageComponentSelectMenuInteraction) {
+		super(client, data)
+		if (data.data.component_type !== ComponentType.ChannelSelect) {
+			throw new Error("Invalid component type was used to create this class")
+		}
+	}
+}

package/src/internals/CommandHandler.ts

@@ -0,0 +1,123 @@
+import {
+	type APIApplicationCommandAutocompleteInteraction,
+	type APIApplicationCommandInteraction,
+	type APIApplicationCommandSubcommandGroupOption,
+	ApplicationCommandOptionType,
+	ApplicationCommandType
+} from "discord-api-types/v10"
+import { Base } from "../abstracts/Base.js"
+import { Command } from "../classes/Command.js"
+import { CommandWithSubcommandGroups } from "../classes/CommandWithSubcommandGroups.js"
+import { CommandWithSubcommands } from "../classes/CommandWithSubcommands.js"
+import { CommandInteraction } from "./CommandInteraction.js"
+import { AutocompleteInteraction } from "./AutocompleteInteraction.js"
+
+export class CommandHandler extends Base {
+	private getCommand(
+		rawInteraction:
+			| APIApplicationCommandAutocompleteInteraction
+			| APIApplicationCommandInteraction
+	): Command {
+		const command = this.client.commands.find(
+			(x) => x.name === rawInteraction.data.name
+		)
+		if (!command) throw new Error("Command not found")
+
+		if (command instanceof CommandWithSubcommandGroups) {
+			if (rawInteraction.data.type !== ApplicationCommandType.ChatInput) {
+				throw new Error("Subcommand groups must be used with ChatInput")
+			}
+			const data = rawInteraction.data
+			const subcommandGroupName = data.options?.find(
+				(x) => x.type === ApplicationCommandOptionType.SubcommandGroup
+			)?.name
+			if (!subcommandGroupName) throw new Error("No subcommand group name")
+
+			const subcommandGroup = command.subcommandGroups.find(
+				(x) => x.name === subcommandGroupName
+			)
+
+			if (!subcommandGroup) throw new Error("Subcommand group not found")
+
+			const subcommandName = (
+				data.options?.find(
+					(x) => x.type === ApplicationCommandOptionType.SubcommandGroup
+				) as APIApplicationCommandSubcommandGroupOption
+			).options?.find(
+				(x) => x.type === ApplicationCommandOptionType.Subcommand
+			)?.name
+			if (!subcommandName) throw new Error("No subcommand name")
+
+			const subcommand = subcommandGroup.subcommands.find(
+				(x) => x.name === subcommandName
+			)
+
+			if (!subcommand) throw new Error("Subcommand not found")
+
+			return subcommand
+		}
+
+		if (command instanceof CommandWithSubcommands) {
+			if (rawInteraction.data.type !== ApplicationCommandType.ChatInput) {
+				throw new Error("Subcommands must be used with ChatInput")
+			}
+			const data = rawInteraction.data
+			const subcommand = command.subcommands.find(
+				(x) => x.name === data.options?.[0]?.name
+			)
+			if (!subcommand) throw new Error("Subcommand not found")
+
+			return subcommand
+		}
+
+		if (command instanceof Command) {
+			return command
+		}
+
+		throw new Error("Command is not a valid command type")
+	}
+	async handleCommandInteraction(
+		rawInteraction: APIApplicationCommandInteraction
+	) {
+		const command = this.getCommand(rawInteraction)
+		if (!command) return false
+
+		const interaction = new CommandInteraction(
+			this.client,
+			rawInteraction,
+			command
+		)
+
+		try {
+			const command = this.getCommand(rawInteraction)
+
+			if (command.defer) {
+				await interaction.defer()
+			}
+			return await command.run(interaction)
+		} catch (e: unknown) {
+			if (e instanceof Error) console.error(e.message)
+			console.error(e)
+		}
+	}
+	async handleAutocompleteInteraction(
+		rawInteraction: APIApplicationCommandAutocompleteInteraction
+	) {
+		const command = this.getCommand(rawInteraction)
+		if (!command) return false
+
+		const interaction = new AutocompleteInteraction(
+			this.client,
+			rawInteraction,
+			command
+		)
+
+		try {
+			const command = this.getCommand(rawInteraction)
+			return await command.autocomplete(interaction)
+		} catch (e: unknown) {
+			if (e instanceof Error) console.error(e.message)
+			console.error(e)
+		}
+	}
+}

package/src/internals/CommandInteraction.ts

@@ -0,0 +1,49 @@
+import {
+	type APIApplicationCommandInteraction,
+	type APIApplicationCommandInteractionDataBasicOption,
+	ApplicationCommandOptionType,
+	ApplicationCommandType,
+	InteractionType
+} from "discord-api-types/v10"
+import type { BaseCommand } from "../abstracts/BaseCommand.js"
+import { BaseInteraction } from "../abstracts/BaseInteraction.js"
+import type { Client } from "../classes/Client.js"
+import { Command } from "../classes/Command.js"
+import { OptionsHandler } from "./OptionsHandler.js"
+// import type { RawOptions } from "./OptionsHandler.js"
+
+/**
+ * Represents a command interaction
+ */
+export class CommandInteraction extends BaseInteraction<APIApplicationCommandInteraction> {
+	/**
+	 * This is the options of the commands, parsed from the interaction data.
+	 * It is only available if the command is a {@link Command} class, and the command is a ChatInput command.
+	 */
+	options?: OptionsHandler
+	constructor(
+		client: Client,
+		data: APIApplicationCommandInteraction,
+		command?: BaseCommand
+	) {
+		super(client, data)
+		if (data.type !== InteractionType.ApplicationCommand) {
+			throw new Error("Invalid interaction type was used to create this class")
+		}
+		if (
+			command instanceof Command &&
+			data.data.type === ApplicationCommandType.ChatInput &&
+			!data.data.options?.find(
+				(x) =>
+					x.type === ApplicationCommandOptionType.Subcommand ||
+					x.type === ApplicationCommandOptionType.SubcommandGroup
+			)
+		) {
+			this.options = new OptionsHandler(
+				client,
+				(data.data.options ??
+					[]) as APIApplicationCommandInteractionDataBasicOption[]
+			)
+		}
+	}
+}

package/src/internals/ComponentHandler.ts

@@ -0,0 +1,81 @@
+import type {
+	APIMessageComponentButtonInteraction,
+	APIMessageComponentInteraction,
+	APIMessageComponentSelectMenuInteraction
+} from "discord-api-types/v10"
+import { Base } from "../abstracts/Base.js"
+import type { BaseComponent } from "../abstracts/BaseComponent.js"
+import { Button } from "../classes/Button.js"
+import { ChannelSelectMenu } from "../classes/ChannelSelectMenu.js"
+import { MentionableSelectMenu } from "../classes/MentionableSelectMenu.js"
+import { RoleSelectMenu } from "../classes/RoleSelectMenu.js"
+import { StringSelectMenu } from "../classes/StringSelectMenu.js"
+import { UserSelectMenu } from "../classes/UserSelectMenu.js"
+import { ButtonInteraction } from "./ButtonInteraction.js"
+import { ChannelSelectMenuInteraction } from "./ChannelSelectMenuInteraction.js"
+import { MentionableSelectMenuInteraction } from "./MentionableSelectMenuInteraction.js"
+import { RoleSelectMenuInteraction } from "./RoleSelectMenuInteraction.js"
+import { StringSelectMenuInteraction } from "./StringSelectMenuInteraction.js"
+import { UserSelectMenuInteraction } from "./UserSelectMenuInteraction.js"
+
+export class ComponentHandler extends Base {
+	async handleInteraction(data: APIMessageComponentInteraction) {
+		const allComponents = this.client.commands
+			.filter((x) => x.components && x.components.length > 0)
+			.flatMap((x) => x.components) as BaseComponent[]
+		const component = allComponents.find(
+			(x) =>
+				x.customId === data.data.custom_id &&
+				x.type === data.data.component_type
+		)
+		if (!component) return false
+
+		if (component instanceof Button) {
+			const interaction = new ButtonInteraction(
+				this.client,
+				data as APIMessageComponentButtonInteraction
+			)
+			if (component.defer) await interaction.defer()
+			await component.run(interaction)
+		} else if (component instanceof RoleSelectMenu) {
+			const interaction = new RoleSelectMenuInteraction(
+				this.client,
+				data as APIMessageComponentSelectMenuInteraction
+			)
+			if (component.defer) await interaction.defer()
+			await component.run(interaction)
+		} else if (component instanceof ChannelSelectMenu) {
+			const interaction = new ChannelSelectMenuInteraction(
+				this.client,
+				data as APIMessageComponentSelectMenuInteraction
+			)
+			if (component.defer) await interaction.defer()
+			await component.run(interaction)
+		} else if (component instanceof MentionableSelectMenu) {
+			const interaction = new MentionableSelectMenuInteraction(
+				this.client,
+				data as APIMessageComponentSelectMenuInteraction
+			)
+			if (component.defer) await interaction.defer()
+			await component.run(interaction)
+		} else if (component instanceof StringSelectMenu) {
+			const interaction = new StringSelectMenuInteraction(
+				this.client,
+				data as APIMessageComponentSelectMenuInteraction
+			)
+			if (component.defer) await interaction.defer()
+			await component.run(interaction)
+		} else if (component instanceof UserSelectMenu) {
+			const interaction = new UserSelectMenuInteraction(
+				this.client,
+				data as APIMessageComponentSelectMenuInteraction
+			)
+			if (component.defer) await interaction.defer()
+			await component.run(interaction)
+		} else {
+			throw new Error(
+				`Unknown component with type ${data.data.component_type} and custom ID ${data.data.custom_id}`
+			)
+		}
+	}
+}

package/src/internals/MentionableSelectMenuInteraction.ts

@@ -0,0 +1,21 @@
+import {
+	type APIMessageComponentSelectMenuInteraction,
+	type APIMessageMentionableSelectInteractionData,
+	ComponentType
+} from "discord-api-types/v10"
+import { AnySelectMenuInteraction } from "../abstracts/AnySelectMenuInteraction.js"
+import type { Client } from "../classes/Client.js"
+
+export class MentionableSelectMenuInteraction extends AnySelectMenuInteraction {
+	constructor(client: Client, data: APIMessageComponentSelectMenuInteraction) {
+		super(client, data)
+		if (data.data.component_type !== ComponentType.MentionableSelect) {
+			throw new Error("Invalid component type was used to create this class")
+		}
+	}
+
+	get values(): string[] {
+		return (this.rawData.data as APIMessageMentionableSelectInteractionData)
+			.values
+	}
+}

package/src/internals/OptionsHandler.ts

@@ -0,0 +1,147 @@
+import {
+	type APIApplicationCommandInteractionDataBasicOption,
+	type APIChannel,
+	ApplicationCommandOptionType,
+	Routes
+} from "discord-api-types/v10"
+import { Base } from "../abstracts/Base.js"
+import { type Client, Role, User, channelFactory } from "../index.js"
+
+export type RawOptions = {
+	[key: string]:
+		| APIApplicationCommandInteractionDataBasicOption["value"]
+		| undefined
+}
+
+/**
+ * This class is used to parse the options of a command, and provide errors for any missing or invalid options.
+ * It is used internally by the Command class.
+ */
+export class OptionsHandler extends Base {
+	/**
+	 * The raw options that were in the interaction data, before they were parsed.
+	 */
+	readonly raw: APIApplicationCommandInteractionDataBasicOption[]
+	/**
+	 * The errors that were encountered while parsing the options.
+	 */
+	readonly errors: Array<string> = []
+
+	constructor(
+		client: Client,
+		options: APIApplicationCommandInteractionDataBasicOption[]
+	) {
+		super(client)
+		this.raw = options
+	}
+
+	/**
+	 * Get the value of a string option.
+	 * @param key The name of the option to get the value of.
+	 * @returns The value of the option, or undefined if the option was not provided.
+	 */
+	public getString(key: string) {
+		const value = this.raw.find(
+			(x) => x.name === key && x.type === ApplicationCommandOptionType.String
+		)?.value
+		if (!value || typeof value !== "string") return undefined
+		return value
+	}
+
+	/**
+	 * Get the value of an integer option.
+	 * @param key The name of the option to get the value of.
+	 * @returns The value of the option, or undefined if the option was not provided.
+	 */
+	public getInteger(key: string) {
+		const num = this.raw.find(
+			(x) => x.name === key && x.type === ApplicationCommandOptionType.Integer
+		)?.value
+		if (!num || !Number.isSafeInteger(num)) return undefined
+		return num
+	}
+
+	/**
+	 * Get the value of a number option.
+	 * @param key The name of the option to get the value of.
+	 * @returns The value of the option, or undefined if the option was not provided.
+	 */
+	public getNumber(key: string) {
+		const value = this.raw.find(
+			(x) => x.name === key && x.type === ApplicationCommandOptionType.Number
+		)?.value
+		if (!value || typeof value !== "number") return undefined
+		return value
+	}
+
+	/**
+	 * Get the value of a boolean option.
+	 * @param key The name of the option to get the value of.
+	 * @returns The value of the option, or undefined if the option was not provided.
+	 */
+	public getBoolean(key: string) {
+		const value = this.raw.find(
+			(x) => x.name === key && x.type === ApplicationCommandOptionType.Boolean
+		)?.value
+		if (!value || typeof value !== "boolean") return undefined
+		return value
+	}
+
+	/**
+	 * Get the value of a user option.
+	 * @param key The name of the option to get the value of.
+	 * @returns The value of the option, or undefined if the option was not provided.
+	 */
+	public getUser(key: string) {
+		const id = this.raw.find(
+			(x) => x.name === key && x.type === ApplicationCommandOptionType.User
+		)?.value
+		if (!id || typeof id !== "string") return undefined
+		return new User(this.client, id)
+	}
+
+	/**
+	 * Get the value of a channel option.
+	 * @param key The name of the option to get the value of.
+	 * @returns The value of the option, or undefined if the option was not provided.
+	 */
+	public async getChannel(key: string) {
+		const id = this.raw.find(
+			(x) => x.name === key && x.type === ApplicationCommandOptionType.Channel
+		)?.value
+		if (!id || typeof id !== "string") return undefined
+		const data = (await this.client.rest.get(Routes.channel(id))) as APIChannel
+		return channelFactory(this.client, data)
+	}
+
+	/**
+	 * Get the value of a role option.
+	 * @param key The name of the option to get the value of.
+	 * @returns The value of the option, or undefined if the option was not provided.
+	 */
+	public getRole(key: string): Role | undefined {
+		const id = this.raw.find(
+			(x) => x.name === key && x.type === ApplicationCommandOptionType.Role
+		)?.value
+		if (!id || typeof id !== "string") return undefined
+		return new Role(this.client, id)
+	}
+
+	/**
+	 * Get the value of a mentionable option.
+	 * @param key The name of the option to get the value of.
+	 * @returns The value of the option, or undefined if the option was not provided.
+	 */
+	public async getMentionable(key: string): Promise<User | Role | undefined> {
+		const id = this.raw.find(
+			(x) =>
+				x.name === key && x.type === ApplicationCommandOptionType.Mentionable
+		)?.value
+		if (!id || typeof id !== "string") return undefined
+		const user = new User(this.client, id)
+		await user.fetch().catch(() => {
+			return new Role(this.client, id)
+		})
+		return user
+	}
+}

package/src/internals/RoleSelectMenuInteraction.ts

@@ -0,0 +1,20 @@
+import {
+	type APIMessageComponentSelectMenuInteraction,
+	type APIMessageRoleSelectInteractionData,
+	ComponentType
+} from "discord-api-types/v10"
+import { AnySelectMenuInteraction } from "../abstracts/AnySelectMenuInteraction.js"
+import type { Client } from "../classes/Client.js"
+
+export class RoleSelectMenuInteraction extends AnySelectMenuInteraction {
+	constructor(client: Client, data: APIMessageComponentSelectMenuInteraction) {
+		super(client, data)
+		if (data.data.component_type !== ComponentType.RoleSelect) {
+			throw new Error("Invalid component type was used to create this class")
+		}
+	}
+
+	get values(): string[] {
+		return (this.rawData.data as APIMessageRoleSelectInteractionData).values
+	}
+}

package/src/internals/StringSelectMenuInteraction.ts

@@ -0,0 +1,20 @@
+import {
+	type APIMessageComponentSelectMenuInteraction,
+	type APIMessageStringSelectInteractionData,
+	ComponentType
+} from "discord-api-types/v10"
+import { AnySelectMenuInteraction } from "../abstracts/AnySelectMenuInteraction.js"
+import type { Client } from "../classes/Client.js"
+
+export class StringSelectMenuInteraction extends AnySelectMenuInteraction {
+	constructor(client: Client, data: APIMessageComponentSelectMenuInteraction) {
+		super(client, data)
+		if (data.data.component_type !== ComponentType.StringSelect) {
+			throw new Error("Invalid component type was used to create this class")
+		}
+	}
+
+	get values(): string[] {
+		return (this.rawData.data as APIMessageStringSelectInteractionData).values
+	}
+}

package/src/internals/UserSelectMenuInteraction.ts

@@ -0,0 +1,20 @@
+import {
+	type APIMessageComponentSelectMenuInteraction,
+	type APIMessageUserSelectInteractionData,
+	ComponentType
+} from "discord-api-types/v10"
+import { AnySelectMenuInteraction } from "../abstracts/AnySelectMenuInteraction.js"
+import type { Client } from "../classes/Client.js"
+
+export class UserSelectMenuInteraction extends AnySelectMenuInteraction {
+	constructor(client: Client, data: APIMessageComponentSelectMenuInteraction) {
+		super(client, data)
+		if (data.data.component_type !== ComponentType.UserSelect) {
+			throw new Error("Invalid component type was used to create this class")
+		}
+	}
+
+	get values(): string[] {
+		return (this.rawData.data as APIMessageUserSelectInteractionData).values
+	}
+}

package/src/structures/DmChannel.ts

@@ -0,0 +1,31 @@
+import {
+	type APIDMChannel,
+	type APIMessage,
+	ChannelType,
+	Routes
+} from "discord-api-types/v10"
+import { BaseChannel } from "../abstracts/BaseChannel.js"
+
+/**
+ * Represents a DM between two users.
+ */
+export class DmChannel extends BaseChannel<ChannelType.DM> {
+	/**
+	 * The name of the channel. This is always null for DM channels.
+	 */
+	name?: null = null
+	type: ChannelType.DM = ChannelType.DM
+
+	protected setSpecificData(data: APIDMChannel) {
+		this.name = data.name
+	}
+
+	/**
+	 * Send a message to the channel
+	 */
+	async send(message: APIMessage) {
+		this.client.rest.post(Routes.channelMessages(this.id), {
+			body: { ...message }
+		})
+	}
+}