@buape/carbon 0.1.0

package/src/abstracts/BaseGuildChannel.ts

@@ -0,0 +1,152 @@
+import {
+	type APIChannel,
+	type APIGuildChannel,
+	type APIMessage,
+	type GuildChannelType,
+	type RESTGetAPIGuildInvitesResult,
+	type RESTPostAPIChannelInviteJSONBody,
+	type RESTPostAPIChannelInviteResult,
+	Routes
+} from "discord-api-types/v10"
+import { Guild } from "../structures/Guild.js"
+import type { GuildCategoryChannel } from "../structures/GuildCategoryChannel.js"
+import { BaseChannel } from "./BaseChannel.js"
+
+export abstract class BaseGuildChannel<
+	Type extends GuildChannelType
+> extends BaseChannel<Type> {
+	/**
+	 * The name of the channel.
+	 */
+	name?: string
+	/**
+	 * The ID of the guild this channel is in
+	 */
+	guildId?: string
+	/**
+	 * The position of the channel in the channel list.
+	 */
+	position?: number
+	/**
+	 * The ID of the parent category for the channel.
+	 */
+	parentId?: string | null
+	/**
+	 * Whether the channel is marked as nsfw.
+	 */
+	nsfw?: boolean
+
+	/**
+	 * The guild this channel is in
+	 */
+	get guild() {
+		if (!this.guildId) throw new Error("Cannot get guild without guild ID")
+		return new Guild(this.client, this.guildId)
+	}
+
+	protected override setData(data: APIGuildChannel<Type>): void {
+		this.rawData = data as Extract<APIChannel, { type: Type }> | null
+		this.partial = false
+		this.name = data.name
+		this.guildId = data.guild_id
+		this.position = data.position
+		this.parentId = data.parent_id
+		this.nsfw = data.nsfw
+		this.setSpecificData(data as Extract<APIChannel, { type: Type }>)
+	}
+
+	/**
+	 * Set the name of the channel
+	 * @param name The new name of the channel
+	 */
+	async setName(name: string) {
+		await this.client.rest.patch(Routes.channel(this.id), {
+			body: {
+				name
+			}
+		})
+		this.name = name
+	}
+
+	/**
+	 * Set the position of the channel
+	 * @param position The new position of the channel
+	 */
+	async setPosition(position: number) {
+		await this.client.rest.patch(Routes.channel(this.id), {
+			body: {
+				position
+			}
+		})
+		this.position = position
+	}
+
+	/**
+	 * Set the parent ID of the channel
+	 * @param parent The new category channel or ID to set
+	 */
+	async setParent(parent: GuildCategoryChannel | string) {
+		if (typeof parent === "string") {
+			await this.client.rest.patch(Routes.channel(this.id), {
+				body: {
+					parent_id: parent
+				}
+			})
+			this.parentId = parent
+		} else {
+			await this.client.rest.patch(Routes.channel(this.id), {
+				body: {
+					parent_id: parent.id
+				}
+			})
+			this.parentId = parent.id
+		}
+	}
+
+	/**
+	 * Set whether the channel is nsfw
+	 * @param nsfw The new nsfw status of the channel
+	 */
+	async setNsfw(nsfw: boolean) {
+		await this.client.rest.patch(Routes.channel(this.id), {
+			body: {
+				nsfw
+			}
+		})
+		this.nsfw = nsfw
+	}
+
+	/**
+	 * Send a message to the channel
+	 */
+	async send(message: APIMessage) {
+		this.client.rest.post(Routes.channelMessages(this.id), {
+			body: { ...message }
+		})
+	}
+
+	/**
+	 * Get the invites for the channel
+	 */
+	async getInvites() {
+		return (await this.client.rest.get(
+			Routes.channelInvites(this.id)
+		)) as RESTGetAPIGuildInvitesResult
+	}
+
+	/**
+	 * Create an invite for the channel
+	 */
+	async createInvite(options?: RESTPostAPIChannelInviteJSONBody) {
+		return (await this.client.rest.post(Routes.channelInvites(this.id), {
+			body: { ...options }
+		})) as RESTPostAPIChannelInviteResult
+	}
+
+	/**
+	 * Trigger a typing indicator in the channel (this will expire after 10 seconds)
+	 */
+	async triggerTyping() {
+		await this.client.rest.post(Routes.channelTyping(this.id))
+	}
+}

package/src/abstracts/BaseGuildTextChannel.ts

@@ -0,0 +1,77 @@
+import {
+	type APIGuildTextChannel,
+	type APIThreadChannel,
+	type GuildTextChannelType,
+	type RESTGetAPIChannelPinsResult,
+	type RESTPostAPIChannelThreadsJSONBody,
+	Routes
+} from "discord-api-types/v10"
+import { GuildThreadChannel } from "../structures/GuildThreadChannel.js"
+import { Message } from "../structures/Message.js"
+import { BaseGuildChannel } from "./BaseGuildChannel.js"
+
+export abstract class BaseGuildTextChannel<
+	Type extends GuildTextChannelType
+> extends BaseGuildChannel<Type> {
+	/**
+	 * The ID of the last message sent in the channel.
+	 *
+	 * @remarks
+	 * This might not always resolve to a message. The ID still stays a part of the channel's data, even if the message is deleted.
+	 */
+	lastMessageId?: string | null
+	/**
+	 * The timestamp of the last pin in the channel.
+	 */
+	lastPinTimestamp?: string | null
+	/**
+	 * The rate limit per user for the channel, in seconds.
+	 */
+	rateLimitPerUser?: number | null
+
+	protected setSpecificData(data: APIGuildTextChannel<Type>): void {
+		this.lastMessageId = data.last_message_id
+		this.lastPinTimestamp = data.last_pin_timestamp
+		this.rateLimitPerUser = data.rate_limit_per_user
+		this.setMoreSpecificData(data)
+	}
+
+	protected abstract setMoreSpecificData(data: APIGuildTextChannel<Type>): void
+
+	/**
+	 * The last message sent in the channel.
+	 *
+	 * @remarks
+	 * This might not always resolve to a message. The ID still stays a part of the channel's data, even if the message is deleted.
+	 * This will always return a partial message, so you can use {@link Message.fetch} to get the full message data.
+	 *
+	 */
+	get lastMessage() {
+		if (!this.lastMessageId) return null
+		return new Message(this.client, {
+			id: this.lastMessageId,
+			channel_id: this.id
+		})
+	}
+
+	/**
+	 * Get the pinned messages in the channel
+	 */
+	async getPinnedMessages() {
+		const msgs = (await this.client.rest.get(
+			Routes.channelPins(this.id)
+		)) as RESTGetAPIChannelPinsResult
+		return msgs.map((x) => new Message(this.client, x))
+	}
+
+	/**
+	 * Start a thread without an associated start message.
+	 * If you want to start a thread with a start message, use {@link Message.startThread}
+	 */
+	async startThread(data: RESTPostAPIChannelThreadsJSONBody) {
+		const thread = (await this.client.rest.post(Routes.threads(this.id), {
+			body: { ...data }
+		})) as APIThreadChannel
+		return new GuildThreadChannel(this.client, thread)
+	}
+}

package/src/abstracts/BaseInteraction.ts

@@ -0,0 +1,170 @@
+import {
+	type APIChannel,
+	type APIInteraction,
+	InteractionResponseType,
+	type InteractionType,
+	Routes
+} from "discord-api-types/v10"
+import type { Client } from "../classes/Client.js"
+import type { Row } from "../classes/Row.js"
+import { channelFactory } from "../factories/channelFactory.js"
+import { Guild } from "../structures/Guild.js"
+import { Message } from "../structures/Message.js"
+import { User } from "../structures/User.js"
+import { Base } from "./Base.js"
+
+/**
+ * The data to reply to an interaction
+ */
+export type InteractionReplyData = {
+	/**
+	 * The content of the message
+	 */
+	content?: string
+	/**
+	 * The components to send in the message, listed in rows
+	 */
+	components?: Row[]
+}
+
+/**
+ * Additional options for replying to an interaction
+ */
+export type InteractionReplyOptions = {
+	/**
+	 * The files to send in the interaction
+	 */
+	files?: InteractionFileData[]
+}
+
+/**
+ * The data for a file to send in an interaction
+ */
+export type InteractionFileData = {
+	/**
+	 * The name of the file that will be given to Discord
+	 */
+	name: string
+	/**
+	 * The data of the file in a Blob
+	 */
+	data: Blob
+	/**
+	 * The alt text of the file, shown for accessibility
+	 * @alpha This isn't implemented yet
+	 */
+	description?: string
+}
+
+/**
+ * This is the base type interaction, all interaction types extend from this
+ */
+export abstract class BaseInteraction<T extends APIInteraction> extends Base {
+	/**
+	 * The type of interaction
+	 */
+	type: InteractionType
+	/**
+	 * The raw data of the interaction
+	 */
+	rawData: T
+	/**
+	 * The user who sent the interaction
+	 */
+	userId: string | undefined
+
+	/**
+	 * Whether the interaction is deferred already
+	 * @internal
+	 */
+	_deferred = false
+
+	constructor(client: Client, data: T) {
+		super(client)
+		this.rawData = data
+		this.type = data.type
+		this.userId =
+			this.rawData.user?.id || this.rawData.member?.user.id || undefined
+	}
+
+	get message(): Message | null {
+		if (!this.rawData.message) return null
+		return new Message(this.client, this.rawData.message)
+	}
+
+	get guild(): Guild | null {
+		if (!this.rawData.guild_id) return null
+		return new Guild(this.client, this.rawData.guild_id)
+	}
+
+	get user(): User | null {
+		if (this.rawData.user) return new User(this.client, this.rawData.user)
+		if (this.rawData.member)
+			return new User(this.client, this.rawData.member.user)
+		return null
+	}
+
+	get channel() {
+		if (!this.rawData.channel) return null
+		return channelFactory(this.client, this.rawData.channel as APIChannel)
+	}
+
+	/**
+	 * Reply to an interaction.
+	 * If the interaction is deferred, this will edit the original response.
+	 * @param data The response data
+	 */
+	async reply(
+		data: InteractionReplyData,
+		options: InteractionReplyOptions = {}
+	) {
+		if (this._deferred) {
+			await this.client.rest.patch(
+				Routes.webhookMessage(
+					this.client.options.clientId,
+					this.rawData.token,
+					"@original"
+				),
+				{
+					body: {
+						...data,
+						components: data.components?.map((row) => row.serialize())
+					},
+					files: options.files
+				}
+			)
+		} else {
+			await this.client.rest.post(
+				Routes.interactionCallback(this.rawData.id, this.rawData.token),
+				{
+					body: {
+						type: InteractionResponseType.ChannelMessageWithSource,
+						data: {
+							...data,
+							components: data.components?.map((row) => row.serialize())
+						}
+					},
+					files: options.files
+				}
+			)
+		}
+	}
+
+	/**
+	 * Defer the interaction response. This is used automatically by commands that are set to defer.
+	 * If the interaction is already deferred, this will do nothing.
+	 * @internal
+	 */
+	async defer() {
+		if (this._deferred) return
+		this._deferred = true
+		await this.client.rest.post(
+			Routes.interactionCallback(this.rawData.id, this.rawData.token),
+			{
+				body: {
+					type: InteractionResponseType.DeferredChannelMessageWithSource
+				}
+			}
+		)
+	}
+}

package/src/abstracts/GuildThreadOnlyChannel.ts

@@ -0,0 +1,71 @@
+import type {
+	APIGuildForumDefaultReactionEmoji,
+	APIGuildForumTag,
+	APIMessage,
+	APIThreadOnlyChannel,
+	ChannelType,
+	SortOrderType
+} from "discord-api-types/v10"
+import { GuildThreadChannel } from "../structures/GuildThreadChannel.js"
+import { BaseGuildChannel } from "./BaseGuildChannel.js"
+
+export abstract class GuildThreadOnlyChannel<
+	Type extends ChannelType.GuildForum | ChannelType.GuildMedia
+> extends BaseGuildChannel<Type> {
+	/**
+	 * The topic of the channel.
+	 */
+	topic?: string | null
+	/**
+	 * The default auto archive duration of the channel.
+	 */
+	defaultAutoArchiveDuration?: number | null
+	/**
+	 * The available tags to set on posts in the channel.
+	 */
+	availableTags?: APIGuildForumTag[]
+	/**
+	 * The default thread rate limit per user for the channel.
+	 */
+	defaultThreadRateLimitPerUser?: number | null
+	/**
+	 * The default reaction emoji for the channel.
+	 */
+	defaultReactionEmoji?: APIGuildForumDefaultReactionEmoji | null
+	/**
+	 * The default sort order for the channel, by latest activity or by creation date.
+	 */
+	defaultSortOrder?: SortOrderType | null
+
+	protected setSpecificData(data: APIThreadOnlyChannel<Type>): void {
+		this.topic = data.topic
+		this.defaultAutoArchiveDuration = data.default_auto_archive_duration
+		this.availableTags = data.available_tags
+		this.defaultThreadRateLimitPerUser = data.default_thread_rate_limit_per_user
+		this.defaultReactionEmoji = data.default_reaction_emoji
+		this.defaultSortOrder = data.default_sort_order
+		this.setMoreSpecificData(data)
+	}
+
+	protected abstract setMoreSpecificData(data: APIThreadOnlyChannel<Type>): void
+
+	/**
+	 * You cannot send a message directly to a forum or media channel, so this method throws an error.
+	 * Use {@link GuildThreadChannel.send} instead, or the alias {@link GuildThreadOnlyChannel.sendToPost} instead, to send a message to the channel's posts.
+	 */
+	override async send(): Promise<void> {
+		throw new Error(
+			"You cannot send a message directly to a forum or media channel. Use GuildThreadChannel.send instead, or the alias GuildThreadOnlyChannel.sendToPost instead, to send a message to the channel's posts."
+		)
+	}
+
+	/**
+	 * Send a message to a post in the channel
+	 * @remarks
+	 * This is an alias for {@link GuildThreadChannel.send} that will fetch the channel, but if you already have the channel, you can use {@link GuildThreadChannel.send} instead.
+	 */
+	async sendToPost(message: APIMessage, postId: string): Promise<void> {
+		const channel = new GuildThreadChannel(this.client, postId)
+		await channel.send(message)
+	}
+}

package/src/classes/Button.ts

@@ -0,0 +1,95 @@
+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

@@ -0,0 +1,21 @@
+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
+		}
+	}
+}