@buape/carbon 0.1.3 → 0.3.0

package/src/classes/Button.ts

@@ -1,95 +0,0 @@
-import {
-	type APIButtonComponent,
-	type APIButtonComponentWithSKUId,
-	type APIButtonComponentWithURL,
-	ButtonStyle,
-	ComponentType
-} from "discord-api-types/v10"
-import { BaseComponent } from "../abstracts/BaseComponent.js"
-import type { ButtonInteraction } from "../internals/ButtonInteraction.js"
-
-abstract class BaseButton extends BaseComponent {
-	type = ComponentType.Button
-
-	/**
-	 * The label of the button
-	 */
-	abstract label: string
-
-	/**
-	 * The emoji of the button
-	 */
-	emoji?: {
-		name: string
-		id?: string
-		animated?: boolean
-	}
-
-	/**
-	 * The style of the button
-	 */
-	style: ButtonStyle = ButtonStyle.Primary
-
-	/**
-	 * The disabled state of the button
-	 */
-	disabled = false
-}
-
-export abstract class Button extends BaseButton {
-	/**
-	 * The style of the button
-	 */
-	abstract style: Exclude<ButtonStyle, ButtonStyle.Link | ButtonStyle.Premium>
-
-	abstract run(interaction: ButtonInteraction): Promise<void>
-
-	serialize = (): APIButtonComponent => {
-		return {
-			type: ComponentType.Button,
-			style: this.style,
-			label: this.label,
-			custom_id: this.customId,
-			disabled: this.disabled,
-			emoji: this.emoji
-		}
-	}
-}
-
-export abstract class LinkButton extends BaseButton {
-	customId = ""
-	/**
-	 * The URL that the button links to
-	 */
-	abstract url: string
-	style: ButtonStyle.Link = ButtonStyle.Link
-
-	serialize = (): APIButtonComponentWithURL => {
-		return {
-			type: ComponentType.Button,
-			url: this.url,
-			style: this.style,
-			label: this.label,
-			disabled: this.disabled,
-			emoji: this.emoji
-		}
-	}
-}
-
-export abstract class PremiumButton extends BaseButton {
-	style: ButtonStyle.Premium = ButtonStyle.Premium
-
-	/**
-	 * The SKU ID of the button
-	 */
-	abstract sku_id: string
-
-	serialize = (): APIButtonComponentWithSKUId => {
-		return {
-			style: this.style,
-			type: ComponentType.Button,
-			disabled: this.disabled,
-			sku_id: this.sku_id
-		}
-	}
-}

package/src/classes/ChannelSelectMenu.ts

@@ -1,21 +0,0 @@
-import {
-	type APIChannelSelectComponent,
-	ComponentType
-} from "discord-api-types/v10"
-import { AnySelectMenu } from "../abstracts/AnySelectMenu.js"
-import type { ChannelSelectMenuInteraction } from "../internals/ChannelSelectMenuInteraction.js"
-
-export abstract class ChannelSelectMenu extends AnySelectMenu {
-	type: ComponentType.ChannelSelect = ComponentType.ChannelSelect
-	channelTypes?: APIChannelSelectComponent["channel_types"]
-	defaultValues?: APIChannelSelectComponent["default_values"]
-	abstract run(interaction: ChannelSelectMenuInteraction): Promise<void>
-
-	serializeOptions() {
-		return {
-			type: this.type,
-			default_values: this.defaultValues,
-			channel_types: this.channelTypes
-		}
-	}
-}

package/src/classes/Client.ts

@@ -1,254 +0,0 @@
-import { RequestClient, type RequestClientOptions } from "@buape/carbon-request"
-import {
-	type APIInteraction,
-	InteractionResponseType,
-	InteractionType,
-	Routes
-} from "discord-api-types/v10"
-import { PlatformAlgorithm, isValidRequest } from "discord-verify"
-import { AutoRouter, type IRequestStrict, StatusError, json } from "itty-router"
-import type { BaseCommand } from "../abstracts/BaseCommand.js"
-import { CommandHandler } from "../internals/CommandHandler.js"
-import { ComponentHandler } from "../internals/ComponentHandler.js"
-
-/**
- * The mode that the client is running in.
- * Different platforms have different requirements for how processes are handled.
- */
-export enum ClientMode {
-	NodeJS = "node",
-	CloudflareWorkers = "cloudflare",
-	Bun = "bun",
-	Vercel = "vercel",
-	Web = "web"
-}
-
-/**
- * The options used for initializing the client
- */
-export type ClientOptions = {
-	/**
-	 * If you want to have the root route for the interaction handler redirect to a different URL, you can set this.
-	 */
-	redirectUrl?: string
-	/**
-	 * The client ID of the bot
-	 */
-	clientId: string
-	/**
-	 * The public key of the bot, used for interaction verification
-	 */
-	publicKey: string
-	/**
-	 * The token of the bot
-	 */
-	token: string
-	/**
-	 * The mode of the client, generally where you are hosting the bot. If you have a different mode for your local development, make sure to set it to the local one.
-	 * @example
-	 * ```ts
-	 * import { Client, ClientMode } from "@buape/carbon"
-	 *
-	 * const client = new Client({
-	 * 	clientId: "12345678901234567890",
-	 * 	publicKey: "c1a2f941ae8ce6d776f7704d0bb3d46b863e21fda491cdb2bdba6b8bc5fe7269",
-	 * 	token: "MTA4NjEwNTYxMDUxMDE1NTg1Nw.GNt-U8.OSHy-g-5FlfESnu3Z9MEEMJLHiRthXajiXNwiE",
-	 * 	mode: process.env.NODE_ENV === "development" ? ClientMode.NodeJS : ClientMode.CloudflareWorkers
-	 * })
-	 * ```
-	 */
-	mode: ClientMode
-	/**
-	 * The route to use for interactions on your server.
-	 * @default "/interaction"
-	 */
-	interactionRoute?: string
-	/**
-	 * The options used to initialize the request client, if you want to customize it.
-	 */
-	requestOptions?: RequestClientOptions
-	/**
-	 * The port to run the server on, if you are using {@link ClientMode.Bun} mode.
-	 */
-	port?: number
-	/**
-	 * Whether the commands should be deployed to Discord automatically.
-	 */
-	autoDeploy?: boolean
-}
-
-/**
- * The main client used to interact with Discord
- */
-export class Client {
-	/**
-	 * The options used to initialize the client
-	 */
-	options: ClientOptions
-	/**
-	 * The commands that the client has registered
-	 */
-	commands: BaseCommand[]
-	/**
-	 * The router used to handle requests
-	 */
-	router: ReturnType<typeof AutoRouter<IRequestStrict>>
-	/**
-	 * The rest client used to interact with the Discord API
-	 */
-	rest: RequestClient
-	/**
-	 * The handler for the component interactions sent from Discord
-	 */
-	componentHandler: ComponentHandler
-	commandHandler: CommandHandler
-
-	/**
-	 * Creates a new client
-	 * @param options The options used to initialize the client
-	 * @param commands The commands that the client has registered
-	 */
-	constructor(options: ClientOptions, commands: BaseCommand[]) {
-		if (!options.clientId) throw new Error("Missing client ID")
-		if (!options.publicKey) throw new Error("Missing public key")
-		if (!options.token) throw new Error("Missing token")
-		this.options = options
-		this.commands = commands
-		const routerData =
-			this.options.mode === ClientMode.Bun && this.options.port
-				? { port: this.options.port }
-				: {}
-		// biome-ignore lint/suspicious/noExplicitAny: <explanation>
-		this.router = AutoRouter<IRequestStrict, any[], Response>(routerData)
-		this.rest = new RequestClient(options.token, options.requestOptions)
-		this.componentHandler = new ComponentHandler(this)
-		this.commandHandler = new CommandHandler(this)
-		this.setupRoutes()
-		if (this.options.autoDeploy) this.deployCommands()
-	}
-
-	/**
-	 * Deploy the commands registered to Discord.
-	 * This is automatically called when running in NodeJS mode.
-	 */
-	async deployCommands() {
-		try {
-			const commands = this.commands.map((command) => {
-				return command.serialize()
-			})
-			await this.rest.put(Routes.applicationCommands(this.options.clientId), {
-				body: commands
-			})
-			console.log(`Deployed ${commands.length} commands to Discord`)
-		} catch (err) {
-			console.error("Failed to deploy commands")
-			console.error(err)
-		}
-	}
-
-	/**
-	 * Setup the routes for the client
-	 */
-	private setupRoutes() {
-		this.router.get("/", () => {
-			if (this.options.redirectUrl)
-				return Response.redirect(this.options.redirectUrl, 302)
-			throw new StatusError(404)
-		})
-		this.router.post(
-			this.options.interactionRoute || "/interaction",
-			async (req, ctx?: ExecutionContext) => {
-				return await this.handle(req, ctx)
-			}
-		)
-	}
-
-	/**
-	 * If you want use a custom handler for HTTP requests instead of Carbon's router, you can use this method.
-	 * @param req The request to handle
-	 * @param ctx Cloudflare Workers only. The execution context of the request, provided in the fetch handler from CF.
-	 * @returns A response to send back to the client.
-	 */
-	public async handle(req: Request, ctx?: ExecutionContext) {
-		const isValid = await this.validateInteraction(req)
-		if (!isValid) {
-			return new Response("Invalid request signature", { status: 401 })
-		}
-
-		const rawInteraction = (await req.json()) as unknown as APIInteraction
-		if (rawInteraction.type === InteractionType.Ping) {
-			return json({
-				type: InteractionResponseType.Pong
-			})
-		}
-
-		if (rawInteraction.type === InteractionType.ApplicationCommand) {
-			if (ctx?.waitUntil) {
-				ctx.waitUntil(
-					(async () => {
-						await this.commandHandler.handleCommandInteraction(rawInteraction)
-					})()
-				)
-			} else {
-				await this.commandHandler.handleCommandInteraction(rawInteraction)
-			}
-		}
-		if (
-			rawInteraction.type === InteractionType.ApplicationCommandAutocomplete
-		) {
-			if (ctx?.waitUntil) {
-				ctx.waitUntil(
-					(async () => {
-						await this.commandHandler.handleAutocompleteInteraction(
-							rawInteraction
-						)
-					})()
-				)
-			} else {
-				await this.commandHandler.handleAutocompleteInteraction(rawInteraction)
-			}
-		}
-		if (rawInteraction.type === InteractionType.MessageComponent) {
-			if (ctx?.waitUntil) {
-				ctx.waitUntil(
-					(async () => {
-						await this.componentHandler.handleInteraction(rawInteraction)
-					})()
-				)
-			} else {
-				await this.componentHandler.handleInteraction(rawInteraction)
-			}
-		}
-		return new Response(null, { status: 202 })
-	}
-
-	/**
-	 * Validate the interaction request
-	 * @param req The request to validate
-	 */
-	private async validateInteraction(req: Request) {
-		if (req.method !== "POST") {
-			throw new StatusError(405)
-		}
-		const isValid = await isValidRequest(
-			req,
-			this.options.publicKey,
-			this.options.mode === ClientMode.CloudflareWorkers
-				? PlatformAlgorithm.Cloudflare
-				: this.options.mode === ClientMode.Vercel
-					? PlatformAlgorithm.VercelProd
-					: this.options.mode === ClientMode.Web
-						? PlatformAlgorithm.Web
-						: PlatformAlgorithm.NewNode
-		)
-		return isValid
-	}
-}
-
-/**
- * @hidden
- */
-export interface ExecutionContext {
-	// biome-ignore lint/suspicious/noExplicitAny: true any
-	waitUntil(promise: Promise<any>): void
-}

package/src/classes/Command.ts

@@ -1,53 +0,0 @@
-import {
-	type APIApplicationCommandBasicOption,
-	ApplicationCommandType
-} from "discord-api-types/v10"
-import {
-	type AutocompleteInteraction,
-	BaseCommand,
-	type CommandInteraction
-} from "../index.js"
-
-export type CommandOptions = APIApplicationCommandBasicOption[]
-
-/**
- * Represents a standard command that the user creates
- */
-export abstract class Command extends BaseCommand {
-	/**
-	 * The options that the user passes along with the command in Discord
-	 */
-	options?: CommandOptions
-
-	/**
-	 * The type of command, either ChatInput, User, or Message. User and Message are context menu commands.
-	 * @default ChatInput
-	 */
-	type: ApplicationCommandType = ApplicationCommandType.ChatInput
-
-	/**
-	 * The function that is called when the command is ran
-	 * @param interaction The interaction that triggered the command
-	 */
-	abstract run(interaction: CommandInteraction): Promise<void>
-
-	/**
-	 * The function that is called when the command's autocomplete is triggered.
-	 * @param interaction The interaction that triggered the autocomplete
-	 * @remarks You are expected to `override` this function to provide your own autocomplete functionality.
-	 */
-	public async autocomplete(
-		interaction: AutocompleteInteraction
-	): Promise<void> {
-		throw new Error(
-			`The ${interaction.rawData.data.name} command does not support autocomplete`
-		)
-	}
-
-	/**
-	 * @internal
-	 */
-	serializeOptions() {
-		return this.options
-	}
-}

package/src/classes/CommandWithSubcommandGroups.ts

@@ -1,47 +0,0 @@
-import {
-	type APIApplicationCommandBasicOption,
-	type APIApplicationCommandSubcommandGroupOption,
-	type APIApplicationCommandSubcommandOption,
-	ApplicationCommandOptionType
-} from "discord-api-types/v10"
-import type { Command } from "./Command.js"
-import { CommandWithSubcommands } from "./CommandWithSubcommands.js"
-
-/**
- * Represents a subcommand group command that the user creates.
- * You make this instead of a {@link Command} class when you want to have subcommand groups in your options.
- */
-export abstract class CommandWithSubcommandGroups extends CommandWithSubcommands {
-	/**
-	 * The subcommands that the user can use
-	 */
-	subcommands: Command[] = []
-
-	/**
-	 * The subcommands that the user can use
-	 */
-	abstract subcommandGroups: CommandWithSubcommands[]
-
-	/**
-	 * @internal
-	 */
-	serializeOptions() {
-		const subcommands = this.subcommands.map((subcommand) => ({
-			name: subcommand.name,
-			description: subcommand.description,
-			type: ApplicationCommandOptionType.Subcommand,
-			options:
-				subcommand.serializeOptions() as APIApplicationCommandBasicOption[]
-		})) as APIApplicationCommandSubcommandOption[]
-
-		const subcommandGroups = this.subcommandGroups.map((subcommandGroup) => ({
-			name: subcommandGroup.name,
-			description: subcommandGroup.description,
-			type: ApplicationCommandOptionType.SubcommandGroup,
-			options:
-				subcommandGroup.serializeOptions() as APIApplicationCommandSubcommandOption[]
-		})) as APIApplicationCommandSubcommandGroupOption[]
-
-		return [...subcommands, ...subcommandGroups]
-	}
-}

package/src/classes/CommandWithSubcommands.ts

@@ -1,35 +0,0 @@
-import {
-	type APIApplicationCommandBasicOption,
-	type APIApplicationCommandSubcommandOption,
-	ApplicationCommandOptionType,
-	ApplicationCommandType,
-	type RESTPostAPIApplicationCommandsJSONBody
-} from "discord-api-types/v10"
-import { BaseCommand } from "../abstracts/BaseCommand.js"
-import type { Command } from "./Command.js"
-
-/**
- * Represents a subcommand command that the user creates.
- * You make this instead of a {@link Command} class when you want to have subcommands in your options.
- */
-export abstract class CommandWithSubcommands extends BaseCommand {
-	type = ApplicationCommandType.ChatInput
-
-	/**
-	 * The subcommands that the user can use
-	 */
-	abstract subcommands: Command[]
-
-	/**
-	 * @internal
-	 */
-	serializeOptions(): RESTPostAPIApplicationCommandsJSONBody["options"] {
-		return this.subcommands.map((subcommand) => ({
-			name: subcommand.name,
-			description: subcommand.description,
-			type: ApplicationCommandOptionType.Subcommand,
-			options:
-				subcommand.serializeOptions() as APIApplicationCommandBasicOption[]
-		})) as APIApplicationCommandSubcommandOption[]
-	}
-}

package/src/classes/MentionableSelectMenu.ts

@@ -1,19 +0,0 @@
-import {
-	type APIMentionableSelectComponent,
-	ComponentType
-} from "discord-api-types/v10"
-import { AnySelectMenu } from "../abstracts/AnySelectMenu.js"
-import type { MentionableSelectMenuInteraction } from "../internals/MentionableSelectMenuInteraction.js"
-
-export abstract class MentionableSelectMenu extends AnySelectMenu {
-	type: ComponentType.MentionableSelect = ComponentType.MentionableSelect
-	defaultValues?: APIMentionableSelectComponent["default_values"]
-	abstract run(interaction: MentionableSelectMenuInteraction): Promise<void>
-
-	serializeOptions() {
-		return {
-			type: this.type,
-			default_values: this.defaultValues
-		}
-	}
-}

package/src/classes/RoleSelectMenu.ts

@@ -1,19 +0,0 @@
-import {
-	type APIRoleSelectComponent,
-	ComponentType
-} from "discord-api-types/v10"
-import { AnySelectMenu } from "../abstracts/AnySelectMenu.js"
-import type { RoleSelectMenuInteraction } from "../internals/RoleSelectMenuInteraction.js"
-
-export abstract class RoleSelectMenu extends AnySelectMenu {
-	type: ComponentType.RoleSelect = ComponentType.RoleSelect
-	defaultValues?: APIRoleSelectComponent["default_values"]
-	abstract run(interaction: RoleSelectMenuInteraction): Promise<void>
-
-	serializeOptions() {
-		return {
-			type: this.type,
-			default_values: this.defaultValues
-		}
-	}
-}

package/src/classes/Row.ts

@@ -1,44 +0,0 @@
-import type { BaseComponent } from "../abstracts/BaseComponent.js"
-
-export class Row {
-	/**
-	 * The components in the action row
-	 */
-	components: BaseComponent[]
-
-	constructor(components: BaseComponent[]) {
-		this.components = components
-	}
-
-	/**
-	 * Add a component to the action row
-	 * @param component The component to add
-	 */
-	addComponent(component: BaseComponent) {
-		this.components.push(component)
-	}
-
-	/**
-	 * Remove a component from the action row
-	 * @param component The component to remove
-	 */
-	removeComponent(component: BaseComponent) {
-		const index = this.components.indexOf(component)
-		if (index === -1) return
-		this.components.splice(index, 1)
-	}
-
-	/**
-	 * Remove all components from the action row
-	 */
-	removeAllComponents() {
-		this.components = []
-	}
-
-	serialize() {
-		return {
-			type: 1,
-			components: this.components.map((component) => component.serialize())
-		}
-	}
-}

package/src/classes/StringSelectMenu.ts

@@ -1,19 +0,0 @@
-import {
-	type APIStringSelectComponent,
-	ComponentType
-} from "discord-api-types/v10"
-import { AnySelectMenu } from "../abstracts/AnySelectMenu.js"
-import type { StringSelectMenuInteraction } from "../internals/StringSelectMenuInteraction.js"
-
-export abstract class StringSelectMenu extends AnySelectMenu {
-	type: ComponentType.StringSelect = ComponentType.StringSelect
-	abstract options: APIStringSelectComponent["options"]
-	abstract run(interaction: StringSelectMenuInteraction): Promise<void>
-
-	serializeOptions() {
-		return {
-			type: this.type,
-			options: this.options
-		}
-	}
-}

package/src/classes/UserSelectMenu.ts

@@ -1,19 +0,0 @@
-import {
-	type APIUserSelectComponent,
-	ComponentType
-} from "discord-api-types/v10"
-import { AnySelectMenu } from "../abstracts/AnySelectMenu.js"
-import type { UserSelectMenuInteraction } from "../internals/UserSelectMenuInteraction.js"
-
-export abstract class UserSelectMenu extends AnySelectMenu {
-	type: ComponentType.UserSelect = ComponentType.UserSelect
-	defaultValues?: APIUserSelectComponent["default_values"]
-	abstract run(interaction: UserSelectMenuInteraction): Promise<void>
-
-	serializeOptions() {
-		return {
-			type: this.type,
-			default_values: this.defaultValues
-		}
-	}
-}

package/src/factories/channelFactory.ts

@@ -1,43 +0,0 @@
-import { type APIChannel, ChannelType } from "discord-api-types/v10"
-import type { Client } from "../classes/Client.js"
-import { DmChannel } from "../structures/DmChannel.js"
-import { GroupDmChannel } from "../structures/GroupDmChannel.js"
-import { GuildAnnouncementChannel } from "../structures/GuildAnnouncementChannel.js"
-import { GuildCategoryChannel } from "../structures/GuildCategoryChannel.js"
-import { GuildForumChannel } from "../structures/GuildForumChannel.js"
-import { GuildMediaChannel } from "../structures/GuildMediaChannel.js"
-import {
-	GuildStageChannel,
-	GuildVoiceChannel
-} from "../structures/GuildStageOrVoiceChannel.js"
-import { GuildTextChannel } from "../structures/GuildTextChannel.js"
-import { GuildThreadChannel } from "../structures/GuildThreadChannel.js"
-
-export const channelFactory = (client: Client, channelData: APIChannel) => {
-	switch (channelData.type) {
-		case ChannelType.DM:
-			return new DmChannel(client, channelData)
-		case ChannelType.GroupDM:
-			return new GroupDmChannel(client, channelData)
-		case ChannelType.GuildText:
-			return new GuildTextChannel(client, channelData)
-		case ChannelType.GuildVoice:
-			return new GuildVoiceChannel(client, channelData)
-		case ChannelType.GuildCategory:
-			return new GuildCategoryChannel(client, channelData)
-		case ChannelType.GuildAnnouncement:
-			return new GuildAnnouncementChannel(client, channelData)
-		case ChannelType.AnnouncementThread:
-		case ChannelType.PublicThread:
-		case ChannelType.PrivateThread:
-			return new GuildThreadChannel(client, channelData)
-		case ChannelType.GuildStageVoice:
-			return new GuildStageChannel(client, channelData)
-		case ChannelType.GuildForum:
-			return new GuildForumChannel(client, channelData)
-		case ChannelType.GuildMedia:
-			return new GuildMediaChannel(client, channelData)
-		default:
-			return null
-	}
-}