fix(ApplicationCommandOptions): clean up code for builder options

__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', () => {

package.json

@@ -56,7 +56,7 @@
 	"homepage": "https://github.com/discordjs/builders",
 	"dependencies": {
 		"@sindresorhus/is": "^4.2.0",
-		"discord-api-types": "^0.25.2",
+		"discord-api-types": "^0.26.0",
 		"ts-mixer": "^6.0.0",
 		"tslib": "^2.3.1",
 		"zod": "^3.11.6"

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;
+	}
+}