feat: add select menu handling

Author: davidabou

src/define.ts

@@ -8,11 +8,18 @@ import {
   ButtonBuilder,
   ButtonStyle,
   type AnyComponentBuilder,
-  type RestOrArray
+  type RestOrArray,
+  StringSelectMenuBuilder,
+  UserSelectMenuBuilder,
+  ChannelSelectMenuBuilder,
+  RoleSelectMenuBuilder,
+  StringSelectMenuOptionBuilder,
+  MentionableSelectMenuBuilder
 } from 'discord.js'
 import type { Stream } from 'node:stream'
 import type {
   ButtonOptions,
+  ChannelSelectMenuOptions,
   CommandConfig,
   CommandExecute,
   ContextMenuCallback,
@@ -32,10 +39,16 @@ import type {
   HarmonixContextMenu,
   HarmonixEvent,
   HarmonixEvents,
+  MentionableSelectMenuOptions,
   ModalOptions,
   OptionsDef,
-  PreconditionCallback
+  PreconditionCallback,
+  RoleSelectMenuOptions,
+  SelectMenuOptions,
+  StringSelectMenuOptions,
+  UserSelectMenuOptions
 } from './types'
+import { createError } from './harmonix'
 
 export const defineHarmonixConfig = (config: HarmonixConfig) => {
   return config
@@ -221,3 +234,134 @@ export const defineButton = (options: ButtonOptions) => {
 
   return builder
 }
+
+export const defineSelectMenu = (options: SelectMenuOptions) => {
+  const { id, placeholder, type, disabled, minValues, maxValues } = options
+
+  switch (type) {
+    case 'String': {
+      const stringOptions = options as StringSelectMenuOptions
+      const selectMenu = new StringSelectMenuBuilder()
+        .setCustomId(id)
+        .setPlaceholder(placeholder)
+
+      if (disabled) {
+        selectMenu.setDisabled(disabled)
+      }
+      if (minValues) {
+        selectMenu.setMinValues(minValues)
+      }
+      if (maxValues) {
+        selectMenu.setMaxValues(maxValues)
+      }
+      stringOptions.options.forEach((option) => {
+        const optionBuilder = new StringSelectMenuOptionBuilder()
+          .setLabel(option.label)
+          .setValue(option.value)
+
+        if (option.description) {
+          optionBuilder.setDescription(option.description)
+        }
+        if (option.emoji) {
+          optionBuilder.setEmoji(option.emoji)
+        }
+        if (option.default) {
+          optionBuilder.setDefault(true)
+        }
+
+        selectMenu.addOptions(optionBuilder)
+      })
+
+      return selectMenu
+    }
+    case 'User': {
+      const userOptions = options as UserSelectMenuOptions
+      const selectMenu = new UserSelectMenuBuilder()
+        .setCustomId(id)
+        .setPlaceholder(placeholder)
+
+      if (disabled) {
+        selectMenu.setDisabled(disabled)
+      }
+      if (minValues) {
+        selectMenu.setMinValues(minValues)
+      }
+      if (maxValues) {
+        selectMenu.setMaxValues(maxValues)
+      }
+      if (userOptions.defaultUsers) {
+        selectMenu.setDefaultUsers(userOptions.defaultUsers)
+      }
+
+      return selectMenu
+    }
+    case 'Channel': {
+      const channelOptions = options as ChannelSelectMenuOptions
+      const selectMenu = new ChannelSelectMenuBuilder()
+        .setCustomId(id)
+        .setPlaceholder(placeholder)
+
+      if (disabled) {
+        selectMenu.setDisabled(disabled)
+      }
+      if (minValues) {
+        selectMenu.setMinValues(minValues)
+      }
+      if (maxValues) {
+        selectMenu.setMaxValues(maxValues)
+      }
+      if (channelOptions.channelTypes) {
+        selectMenu.addChannelTypes(...channelOptions.channelTypes)
+      }
+      if (channelOptions.defaultChannels) {
+        selectMenu.setDefaultChannels(channelOptions.defaultChannels)
+      }
+
+      return selectMenu
+    }
+    case 'Role': {
+      const roleOptions = options as RoleSelectMenuOptions
+      const selectMenu = new RoleSelectMenuBuilder()
+        .setCustomId(id)
+        .setPlaceholder(placeholder)
+
+      if (disabled) {
+        selectMenu.setDisabled(disabled)
+      }
+      if (minValues) {
+        selectMenu.setMinValues(minValues)
+      }
+      if (maxValues) {
+        selectMenu.setMaxValues(maxValues)
+      }
+      if (roleOptions.defaultRoles) {
+        selectMenu.setDefaultRoles(roleOptions.defaultRoles)
+      }
+
+      return selectMenu
+    }
+    case 'Mentionable': {
+      const mentionableOptions = options as MentionableSelectMenuOptions
+      const selectMenu = new MentionableSelectMenuBuilder()
+        .setCustomId(id)
+        .setPlaceholder(placeholder)
+
+      if (disabled) {
+        selectMenu.setDisabled(disabled)
+      }
+      if (minValues) {
+        selectMenu.setMinValues(minValues)
+      }
+      if (maxValues) {
+        selectMenu.setMaxValues(maxValues)
+      }
+      if (mentionableOptions.defaultValues) {
+        selectMenu.setDefaultValues(mentionableOptions.defaultValues)
+      }
+
+      return selectMenu
+    }
+    default:
+      throw createError('Invalid select menu type')
+  }
+}

src/register.ts

@@ -45,6 +45,17 @@ export const registerEvents = (harmonix: Harmonix) => {
       event.callback(interaction)
     })
   })
+  harmonix.client?.on(Events.InteractionCreate, (interaction) => {
+    if (!interaction.isAnySelectMenu()) return
+    const event = harmonix.events
+      .filter((evt) => evt.options.type === 'select')
+      .find((evt) => evt.options.name === interaction.customId)
+
+    if (!event) return
+    ctx.call(harmonix, () => {
+      event.callback(interaction)
+    })
+  })
 }
 
 export const registerCommands = (harmonix: Harmonix) => {

src/resolve.ts

@@ -31,7 +31,7 @@ export const resolveEvent = (
       once: event.options.once || filename(_evtPath).endsWith('.once'),
       type:
         event.options.type ||
-        ((['modals', 'buttons'].includes(filename(dirname(_evtPath)))
+        ((['modals', 'buttons', 'selects'].includes(filename(dirname(_evtPath)))
           ? filename(dirname(_evtPath)).slice(0, -1)
           : undefined) as EventOptions['type'])
     }

src/types/events.ts

@@ -1,4 +1,5 @@
 import type {
+  AnySelectMenuInteraction,
   ButtonInteraction,
   ClientEvents,
   ModalSubmitInteraction
@@ -7,6 +8,7 @@ import type {
 export interface HarmonixEvents extends ClientEvents {
   modal: [interaction: ModalSubmitInteraction]
   button: [interaction: ButtonInteraction]
+  select: [interaction: AnySelectMenuInteraction]
 }
 
 export type EventCallback<Event extends keyof HarmonixEvents | any = any> = (
@@ -16,7 +18,7 @@ export type EventCallback<Event extends keyof HarmonixEvents | any = any> = (
 export interface EventOptions {
   name?: string
   once?: boolean
-  type?: 'modal' | 'button'
+  type?: 'modal' | 'button' | 'select'
 }
 
 export type DefineEvent = <Event extends keyof HarmonixEvents = any>(

src/types/rich.ts

@@ -5,7 +5,10 @@ import type {
   APIEmbedField,
   TextInputStyle,
   ButtonStyle,
-  ComponentEmojiResolvable
+  ComponentEmojiResolvable,
+  ChannelType,
+  APISelectMenuDefaultValue,
+  SelectMenuDefaultValueType
 } from 'discord.js'
 
 interface TextInput {
@@ -50,3 +53,54 @@ export interface ButtonOptions {
   url?: string
   disabled?: boolean
 }
+
+export interface StringSelectMenuOptions {
+  type: 'String'
+  options: {
+    label: string
+    value: string
+    description?: string
+    emoji?: ComponentEmojiResolvable
+    default?: boolean
+  }[]
+}
+
+export interface UserSelectMenuOptions {
+  type: 'User'
+  defaultUsers?: string[]
+}
+
+export interface ChannelSelectMenuOptions {
+  type: 'Channel'
+  channelTypes?: ChannelType[]
+  defaultChannels?: string[]
+}
+
+export interface RoleSelectMenuOptions {
+  type: 'Role'
+  defaultRoles?: string[]
+}
+
+export interface MentionableSelectMenuOptions {
+  type: 'Mentionable'
+  defaultValues?:
+    | APISelectMenuDefaultValue<SelectMenuDefaultValueType.Role>[]
+    | APISelectMenuDefaultValue<SelectMenuDefaultValueType.User>[]
+}
+
+export interface BaseSelectMenuOptions {
+  id: string
+  placeholder: string
+  disabled?: boolean
+  minValues?: number
+  maxValues?: number
+}
+
+export type SelectMenuOptions = BaseSelectMenuOptions &
+  (
+    | StringSelectMenuOptions
+    | UserSelectMenuOptions
+    | ChannelSelectMenuOptions
+    | RoleSelectMenuOptions
+    | MentionableSelectMenuOptions
+  )