@buape/carbon 0.2.0 → 0.3.1

package/src/abstracts/BaseCommand.ts

@@ -1,89 +0,0 @@
-import {
-	ApplicationCommandType,
-	type RESTPostAPIApplicationCommandsJSONBody
-} from "discord-api-types/v10"
-import { ApplicationIntegrationType, InteractionContextType } from "../index.js"
-
-/**
- * Represents the base data of a command that the user creates
- */
-export abstract class BaseCommand {
-	/**
-	 * The name of the command (e.g. "ping" for /ping)
-	 */
-	abstract name: string
-	/**
-	 * A description of the command
-	 */
-	abstract description: string
-	/**
-	 * Whether the command response should be automatically deferred
-	 */
-	defer = false
-	/**
-	 * Whether the command response should be ephemeral
-	 */
-	ephemeral = false
-	/**
-	 * The type of the command
-	 */
-	abstract type: ApplicationCommandType
-	/**
-	 * The places this command can be used in
-	 * @beta API types are not finalized
-	 */
-	integrationTypes: ApplicationIntegrationType[] = [
-		ApplicationIntegrationType.GuildInstall,
-		ApplicationIntegrationType.UserInstall
-	]
-	/**
-	 * The contexts this command can be used in
-	 * @beta API types are not finalized
-	 */
-	contexts: InteractionContextType[] = [
-		InteractionContextType.Guild,
-		InteractionContextType.BotDM,
-		InteractionContextType.PrivateChannel
-	]
-
-	/**
-	 * All the paginators that the command is able to use.
-	 * You mount these here so the handler can access them
-	 */
-	// paginators?: Paginator[] = []
-
-	/**
-	 * Serializes the command into a JSON object that can be sent to Discord
-	 * @internal
-	 */
-	serialize() {
-		// Only chat input commands can have descriptions
-		if (this.type === ApplicationCommandType.ChatInput) {
-			const data: RESTPostAPIApplicationCommandsJSONBody = {
-				name: this.name,
-				type: this.type,
-				description: this.description,
-				options: this.serializeOptions(),
-				integration_types: this.integrationTypes,
-				contexts: this.contexts
-			}
-
-			return data
-		}
-		const data: RESTPostAPIApplicationCommandsJSONBody = {
-			name: this.name,
-			type: this.type,
-			options: this.serializeOptions(),
-			integration_types: this.integrationTypes,
-			contexts: this.contexts
-		}
-
-		return data
-	}
-
-	/**
-	 * Serializes the options of the command into a JSON object that can be sent to Discord
-	 * @internal
-	 */
-	abstract serializeOptions(): RESTPostAPIApplicationCommandsJSONBody["options"]
-}

package/src/abstracts/BaseComponent.ts

@@ -1,49 +0,0 @@
-import type { APIBaseComponent, ComponentType } from "discord-api-types/v10"
-
-export type ComponentAdditionalData = {
-	[key: string]: string | number | boolean
-}
-
-export abstract class BaseComponent {
-	constructor(data?: {
-		additionalData?: ComponentAdditionalData
-	}) {
-		if (data?.additionalData) this.additionalData = data.additionalData
-	}
-
-	/**
-	 * Whether the component response should be automatically deferred
-	 */
-	defer = false
-	/**
-	 * Whether the component response should be ephemeral
-	 */
-	ephemeral = false
-
-	/**
-	 * The type of the component
-	 */
-	abstract type: ComponentType
-	/**
-	 * The custom ID of the component
-	 */
-	abstract customId: string
-
-	additionalData: ComponentAdditionalData | null = null
-
-	/**
-	 * Create a custom ID to use for this component that embeds additional data that you want to be handed
-	 * @param additionalData The additional data that you want to be passed in this component's custom ID
-	 * @returns The custom ID to use
-	 */
-	public createId = (additionalData: typeof this.additionalData) => {
-		if (!additionalData) return this.customId
-		// id:arg1=1;arg2=2
-		const id = `${this.customId}:${Object.entries(additionalData)
-			.map(([key, value]) => `${key}=${value}`)
-			.join(";")}`
-		return id
-	}
-
-	abstract serialize: () => APIBaseComponent<typeof this.type>
-}

package/src/abstracts/BaseComponentInteraction.ts

@@ -1,19 +0,0 @@
-import type {
-	APIMessageComponentInteraction,
-	ComponentType
-} from "discord-api-types/v10"
-import type { Client } from "../classes/Client.js"
-import { splitCustomId } from "../utils.js"
-import { BaseInteraction } from "./BaseInteraction.js"
-
-export class BaseComponentInteraction extends BaseInteraction<APIMessageComponentInteraction> {
-	customId: string
-	componentType: ComponentType
-	constructor(client: Client, data: APIMessageComponentInteraction) {
-		super(client, data)
-		if (!data.data)
-			throw new Error("Invalid interaction data was used to create this class")
-		this.customId = splitCustomId(data.data.custom_id)[0]
-		this.componentType = data.data.component_type
-	}
-}

package/src/abstracts/BaseGuildChannel.ts

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

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

@@ -1,209 +0,0 @@
-import {
-	type APIChannel,
-	type APIInteraction,
-	InteractionResponseType,
-	type InteractionType,
-	Routes
-} from "discord-api-types/v10"
-import {
-	Base,
-	type Client,
-	Guild,
-	Message,
-	type Modal,
-	type Row,
-	User,
-	channelFactory
-} from "../index.js"
-import { GuildMember } from "../structures/GuildMember.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[]
-	/**
-	 * Whether the interaction should be ephemeral
-	 */
-	ephemeral?: boolean
-}
-
-/**
- * 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
-
-	private defaultEphemeral = false
-
-	constructor(client: Client, data: T, defaults: { ephemeral?: boolean } = {}) {
-		super(client)
-		this.rawData = data
-		this.type = data.type
-		this.userId =
-			this.rawData.user?.id || this.rawData.member?.user.id || undefined
-		if (defaults.ephemeral) this.defaultEphemeral = defaults.ephemeral
-	}
-
-	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)
-	}
-
-	get member() {
-		if (!this.rawData.member) return null
-		if (!this.guild) return null
-		return new GuildMember(this.client, this.rawData.member, this.guild)
-	}
-
-	/**
-	 * 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 = {}
-	) {
-		data.components?.map((row) => {
-			row.components.map((component) => {
-				this.client.componentHandler.registerComponent(component)
-			})
-		})
-		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()),
-							ephemeral: options.ephemeral ?? this.defaultEphemeral
-						}
-					},
-					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,
-					ephemeral: this.defaultEphemeral
-				}
-			}
-		)
-	}
-
-	async showModal(modal: Modal) {
-		if (this._deferred)
-			throw new Error("You cannot defer an interaction that shows a modal")
-		this.client.modalHandler.registerModal(modal)
-		await this.client.rest.post(
-			Routes.interactionCallback(this.rawData.id, this.rawData.token),
-			{
-				body: {
-					type: InteractionResponseType.Modal,
-					data: modal.serialize()
-				}
-			}
-		)
-	}
-}

package/src/abstracts/GuildThreadOnlyChannel.ts

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