Merge branch 'main' of https://github.com/discordjs/builders into feat/components

Author: suneettipirneni

__tests__/SlashCommands.test.ts

@@ -207,8 +207,22 @@ describe('Slash Commands', () => {
 
 				expect(() => {
 					const option = getStringOption();
-					option.autocomplete = true;
-					option.choices = [{ name: 'Fancy Pants', value: 'fp_1' }];
+					Reflect.set(option, 'autocomplete', true);
+					Reflect.set(option, 'choices', [{ name: 'Fancy Pants', value: 'fp_1' }]);
+					return option.toJSON();
+				}).toThrowError();
+
+				expect(() => {
+					const option = getNumberOption();
+					Reflect.set(option, 'autocomplete', true);
+					Reflect.set(option, 'choices', [{ name: 'Fancy Pants', value: 'fp_1' }]);
+					return option.toJSON();
+				}).toThrowError();
+
+				expect(() => {
+					const option = getIntegerOption();
+					Reflect.set(option, 'autocomplete', true);
+					Reflect.set(option, 'choices', [{ name: 'Fancy Pants', value: 'fp_1' }]);
 					return option.toJSON();
 				}).toThrowError();
 			});
@@ -229,14 +243,6 @@ describe('Slash Commands', () => {
 				expect(() => getBuilder().addChannelOption(getChannelOption().addChannelType(100))).toThrowError();
 
 				expect(() => getBuilder().addChannelOption(getChannelOption().addChannelTypes([100, 200]))).toThrowError();
-
-				expect(() => getBuilder().addChannelOption(getChannelOption().addChannelType(100))).toThrowError();
-
-				expect(() => getBuilder().addChannelOption(getChannelOption().addChannelType(1))).toThrowError();
-
-				expect(() => getBuilder().addChannelOption(getChannelOption().addChannelType(1))).toThrowError();
-
-				expect(() => getBuilder().addChannelOption(getChannelOption().addChannelTypes([1, 2, 3]))).toThrowError();
 			});
 
 			test('GIVEN a builder with invalid number min/max options THEN does throw an error', () => {
@@ -324,6 +330,22 @@ describe('Slash Commands', () => {
 			test('GIVEN valid builder with defaultPermission false THEN does not throw error', () => {
 				expect(() => getBuilder().setName('foo').setDescription('foo').setDefaultPermission(false)).not.toThrowError();
 			});
+
+			test('GIVEN an option that is autocompletable and has choices, THEN setting choices to an empty array should not throw an error', () => {
+				expect(() =>
+					getBuilder().addStringOption(getStringOption().setAutocomplete(true).setChoices([])),
+				).not.toThrowError();
+			});
+
+			test('GIVEN an option that is autocompletable and has choices, THEN setting choices should throw an error', () => {
+				expect(() =>
+					getBuilder().addStringOption(
+						getStringOption()
+							.setAutocomplete(true)
+							.setChoices([['owo', 'uwu']]),
+					),
+				).toThrowError();
+			});
 		});
 
 		describe('Builder with subcommand (group) options', () => {

src/interactions/slashCommands/Assertions.ts

@@ -1,7 +1,7 @@
 import is from '@sindresorhus/is';
 import type { APIApplicationCommandOptionChoice } from 'discord-api-types/v9';
 import { z } from 'zod';
-import type { SlashCommandOptionBase } from './mixins/CommandOptionBase';
+import type { ApplicationCommandOptionBase } from './mixins/ApplicationCommandOptionBase';
 import type { ToAPIApplicationCommandOptions } from './SlashCommandBuilder';
 import type { SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder } from './SlashCommandSubcommands';
 
@@ -57,7 +57,7 @@ export function validateMaxChoicesLength(choices: APIApplicationCommandOptionCho
 }
 
 export function assertReturnOfBuilder<
-	T extends SlashCommandOptionBase | SlashCommandSubcommandBuilder | SlashCommandSubcommandGroupBuilder,
+	T extends ApplicationCommandOptionBase | SlashCommandSubcommandBuilder | SlashCommandSubcommandGroupBuilder,
 >(input: unknown, ExpectedInstanceOf: new () => T): asserts input is T {
 	const instanceName = ExpectedInstanceOf.name;
 

src/interactions/slashCommands/SlashCommandBuilder.ts

@@ -6,7 +6,7 @@ import {
 	validateMaxOptionsLength,
 	validateRequiredParameters,
 } from './Assertions';
-import { SharedSlashCommandOptions } from './mixins/CommandOptions';
+import { SharedSlashCommandOptions } from './mixins/SharedSlashCommandOptions';
 import { SharedNameAndDescription } from './mixins/NameAndDescription';
 import { SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder } from './SlashCommandSubcommands';
 
@@ -41,6 +41,7 @@ export class SlashCommandBuilder {
 	 */
 	public toJSON(): RESTPostAPIApplicationCommandsJSONBody {
 		validateRequiredParameters(this.name, this.description, this.options);
+
 		return {
 			name: this.name,
 			description: this.description,

src/interactions/slashCommands/SlashCommandSubcommands.ts

@@ -1,8 +1,13 @@
-import { APIApplicationCommandSubCommandOptions, ApplicationCommandOptionType } from 'discord-api-types/v9';
+import {
+	APIApplicationCommandSubcommandGroupOption,
+	APIApplicationCommandSubcommandOption,
+	ApplicationCommandOptionType,
+} from 'discord-api-types/v9';
 import { mix } from 'ts-mixer';
 import { assertReturnOfBuilder, validateMaxOptionsLength, validateRequiredParameters } from './Assertions';
-import { SharedSlashCommandOptions } from './mixins/CommandOptions';
+import type { ApplicationCommandOptionBase } from './mixins/ApplicationCommandOptionBase';
 import { SharedNameAndDescription } from './mixins/NameAndDescription';
+import { SharedSlashCommandOptions } from './mixins/SharedSlashCommandOptions';
 import type { ToAPIApplicationCommandOptions } from './SlashCommandBuilder';
 
 /**
@@ -25,7 +30,7 @@ export class SlashCommandSubcommandGroupBuilder implements ToAPIApplicationComma
 	/**
 	 * The subcommands part of this subcommand group
 	 */
-	public readonly options: ToAPIApplicationCommandOptions[] = [];
+	public readonly options: SlashCommandSubcommandBuilder[] = [];
 
 	/**
 	 * Adds a new subcommand to this group
@@ -53,8 +58,9 @@ export class SlashCommandSubcommandGroupBuilder implements ToAPIApplicationComma
 		return this;
 	}
 
-	public toJSON(): APIApplicationCommandSubCommandOptions {
+	public toJSON(): APIApplicationCommandSubcommandGroupOption {
 		validateRequiredParameters(this.name, this.description, this.options);
+
 		return {
 			type: ApplicationCommandOptionType.SubcommandGroup,
 			name: this.name,
@@ -86,10 +92,11 @@ export class SlashCommandSubcommandBuilder implements ToAPIApplicationCommandOpt
 	/**
 	 * The options of this subcommand
 	 */
-	public readonly options: ToAPIApplicationCommandOptions[] = [];
+	public readonly options: ApplicationCommandOptionBase[] = [];
 
-	public toJSON(): APIApplicationCommandSubCommandOptions {
+	public toJSON(): APIApplicationCommandSubcommandOption {
 		validateRequiredParameters(this.name, this.description, this.options);
+
 		return {
 			type: ApplicationCommandOptionType.Subcommand,
 			name: this.name,

src/interactions/slashCommands/mixins/ApplicationCommandNumericOptionMinMaxValueMixin.ts

@@ -0,0 +1,16 @@
+export abstract class ApplicationCommandNumericOptionMinMaxValueMixin {
+	protected readonly maxValue?: number;
+	protected readonly minValue?: number;
+
+	/**
+	 * Sets the maximum number value of this option
+	 * @param max The maximum value this option can be
+	 */
+	public abstract setMaxValue(max: number): this;
+
+	/**
+	 * Sets the minimum number value of this option
+	 * @param min The minimum value this option can be
+	 */
+	public abstract setMinValue(min: number): this;
+}

src/interactions/slashCommands/mixins/ApplicationCommandOptionBase.ts

@@ -0,0 +1,32 @@
+import type { APIApplicationCommandBasicOption, ApplicationCommandOptionType } from 'discord-api-types/v9';
+import { validateRequiredParameters, validateRequired } from '../Assertions';
+import { SharedNameAndDescription } from './NameAndDescription';
+
+export abstract class ApplicationCommandOptionBase extends SharedNameAndDescription {
+	public abstract readonly type: ApplicationCommandOptionType;
+
+	public readonly required = false;
+
+	/**
+	 * Marks the option as required
+	 *
+	 * @param required If this option should be required
+	 */
+	public setRequired(required: boolean) {
+		// Assert that you actually passed a boolean
+		validateRequired(required);
+
+		Reflect.set(this, 'required', required);
+
+		return this;
+	}
+
+	public abstract toJSON(): APIApplicationCommandBasicOption;
+
+	protected runRequiredValidations() {
+		validateRequiredParameters(this.name, this.description, []);
+
+		// Assert that you actually passed a boolean
+		validateRequired(this.required);
+	}
+}

src/interactions/slashCommands/mixins/ApplicationCommandOptionChannelTypesMixin.ts

@@ -0,0 +1,55 @@
+import { ChannelType } from 'discord-api-types/v9';
+import { z, ZodLiteral } from 'zod';
+
+// Only allow valid channel types to be used. (This can't be dynamic because const enums are erased at runtime)
+const allowedChannelTypes = [
+	ChannelType.GuildText,
+	ChannelType.GuildVoice,
+	ChannelType.GuildCategory,
+	ChannelType.GuildNews,
+	ChannelType.GuildStore,
+	ChannelType.GuildNewsThread,
+	ChannelType.GuildPublicThread,
+	ChannelType.GuildPrivateThread,
+	ChannelType.GuildStageVoice,
+] as const;
+
+export type ApplicationCommandOptionAllowedChannelTypes = typeof allowedChannelTypes[number];
+
+const channelTypePredicate = z.union(
+	allowedChannelTypes.map((type) => z.literal(type)) as [
+		ZodLiteral<ChannelType>,
+		ZodLiteral<ChannelType>,
+		...ZodLiteral<ChannelType>[]
+	],
+);
+
+export class ApplicationCommandOptionChannelTypesMixin {
+	public readonly channel_types?: ApplicationCommandOptionAllowedChannelTypes[];
+
+	/**
+	 * Adds a channel type to this option
+	 *
+	 * @param channelType The type of channel to allow
+	 */
+	public addChannelType(channelType: ApplicationCommandOptionAllowedChannelTypes) {
+		if (this.channel_types === undefined) {
+			Reflect.set(this, 'channel_types', []);
+		}
+
+		channelTypePredicate.parse(channelType);
+		this.channel_types!.push(channelType);
+
+		return this;
+	}
+
+	/**
+	 * Adds channel types to this option
+	 *
+	 * @param channelTypes The channel types to add
+	 */
+	public addChannelTypes(channelTypes: ApplicationCommandOptionAllowedChannelTypes[]) {
+		channelTypes.forEach((channelType) => this.addChannelType(channelType));
+		return this;
+	}
+}

src/interactions/slashCommands/mixins/CommandOptionWithChoices.ts renamed to src/interactions/slashCommands/mixins/ApplicationCommandOptionWithChoicesAndAutocompleteMixin.ts

@@ -1,27 +1,19 @@
-import {
-	APIApplicationCommandOption,
-	APIApplicationCommandOptionChoice,
-	ApplicationCommandOptionType,
-} from 'discord-api-types/v9';
+import { APIApplicationCommandOptionChoice, ApplicationCommandOptionType } from 'discord-api-types/v9';
 import { z } from 'zod';
 import { validateMaxChoicesLength } from '../Assertions';
-import type { ToAPIApplicationCommandOptions } from '../SlashCommandBuilder';
-import { SlashCommandOptionBase } from './CommandOptionBase';
 
 const stringPredicate = z.string().min(1).max(100);
 const numberPredicate = z.number().gt(-Infinity).lt(Infinity);
 const choicesPredicate = z.tuple([stringPredicate, z.union([stringPredicate, numberPredicate])]).array();
 const booleanPredicate = z.boolean();
 
-export abstract class ApplicationCommandOptionWithChoicesBase<T extends string | number>
-	extends SlashCommandOptionBase<
-		ApplicationCommandOptionType.String | ApplicationCommandOptionType.Number | ApplicationCommandOptionType.Integer
-	>
-	implements ToAPIApplicationCommandOptions
-{
-	public choices?: APIApplicationCommandOptionChoice[];
+export class ApplicationCommandOptionWithChoicesAndAutocompleteMixin<T extends string | number> {
+	public readonly choices?: APIApplicationCommandOptionChoice<T>[];
 	public readonly autocomplete?: boolean;
 
+	// Since this is present and this is a mixin, this is needed
+	public readonly type!: ApplicationCommandOptionType;
+
 	/**
 	 * Adds a choice for this option
 	 *
@@ -33,18 +25,23 @@ export abstract class ApplicationCommandOptionWithChoicesBase<T extends string |
 			throw new RangeError('Autocomplete and choices are mutually exclusive to each other.');
 		}
 
-		this.choices ??= [];
+		if (this.choices === undefined) {
+			Reflect.set(this, 'choices', []);
+		}
 
-		validateMaxChoicesLength(this.choices);
+		validateMaxChoicesLength(this.choices!);
 
 		// Validate name
 		stringPredicate.parse(name);
 
 		// Validate the value
-		if (this.type === ApplicationCommandOptionType.String) stringPredicate.parse(value);
-		else numberPredicate.parse(value);
+		if (this.type === ApplicationCommandOptionType.String) {
+			stringPredicate.parse(value);
+		} else {
+			numberPredicate.parse(value);
+		}
 
-		this.choices.push({ name, value });
+		this.choices!.push({ name, value });
 
 		return this;
 	}
@@ -65,6 +62,23 @@ export abstract class ApplicationCommandOptionWithChoicesBase<T extends string |
 		return this;
 	}
 
+	public setChoices<Input extends [name: string, value: T][]>(
+		choices: Input,
+	): Input extends []
+		? this & Pick<ApplicationCommandOptionWithChoicesAndAutocompleteMixin<T>, 'setAutocomplete'>
+		: Omit<this, 'setAutocomplete'> {
+		if (choices.length > 0 && this.autocomplete) {
+			throw new RangeError('Autocomplete and choices are mutually exclusive to each other.');
+		}
+
+		choicesPredicate.parse(choices);
+
+		Reflect.set(this, 'choices', []);
+		for (const [label, value] of choices) this.addChoice(label, value);
+
+		return this;
+	}
+
 	/**
 	 * Marks the option as autocompletable
 	 * @param autocomplete If this option should be autocompletable
@@ -73,7 +87,7 @@ export abstract class ApplicationCommandOptionWithChoicesBase<T extends string |
 		autocomplete: U,
 	): U extends true
 		? Omit<this, 'addChoice' | 'addChoices'>
-		: this & Pick<ApplicationCommandOptionWithChoicesBase<T>, 'addChoice' | 'addChoices'> {
+		: this & Pick<ApplicationCommandOptionWithChoicesAndAutocompleteMixin<T>, 'addChoice' | 'addChoices'> {
 		// Assert that you actually passed a boolean
 		booleanPredicate.parse(autocomplete);
 
@@ -85,18 +99,4 @@ export abstract class ApplicationCommandOptionWithChoicesBase<T extends string |
 
 		return this;
 	}
-
-	public override toJSON() {
-		if (this.autocomplete && Array.isArray(this.choices) && this.choices.length > 0) {
-			throw new RangeError('Autocomplete and choices are mutually exclusive to each other.');
-		}
-
-		// TODO: Fix types
-		// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-		return {
-			...super.toJSON(),
-			choices: this.choices,
-			autocomplete: this.autocomplete,
-		} as APIApplicationCommandOption;
-	}
 }