meocord 2.1.1 → 3.1.0

package/dist/esm/bin/builder-template/builder/primary-entry-point.builder.template

@@ -0,0 +1,26 @@
+import {
+  ApplicationCommandType,
+  ApplicationIntegrationType,
+  EntryPointCommandHandlerType,
+  InteractionContextType,
+} from 'discord.js'
+import { CommandBuilder } from 'meocord/decorator'
+import { CommandType } from 'meocord/enum'
+
+// Entry point commands have no builder class in @discordjs/builders, so the raw REST
+// body is returned instead — MeoCord registers it as-is. `AppHandler` is what makes
+// Discord send the interaction here; `DiscordLaunchActivity` opens the activity without
+// ever reaching the bot.
+@CommandBuilder(CommandType.PRIMARY_ENTRY_POINT)
+export class SampleCommandBuilder {
+  build() {
+    return {
+      type: ApplicationCommandType.PrimaryEntryPoint as const,
+      name: 'sample-entry-point',
+      description: 'Launch the activity',
+      handler: EntryPointCommandHandlerType.AppHandler,
+      integration_types: [ApplicationIntegrationType.GuildInstall],
+      contexts: [InteractionContextType.Guild],
+    }
+  }
+}

package/dist/esm/bin/builder-template/controller/autocomplete.controller.template

@@ -0,0 +1,16 @@
+import { AutocompleteInteraction } from 'discord.js'
+import { Controller, Autocomplete } from 'meocord/decorator'
+
+@Controller()
+export class {{className}}AutocompleteController {
+
+  // The option this completes must be declared with `.setAutocomplete(true)` on the
+  // slash command builder, otherwise Discord never sends the interaction.
+  @Autocomplete('sample-slash', 'query')
+  async completeQuery(interaction: AutocompleteInteraction) {
+    const { value } = interaction.options.getFocused(true)
+    const choices = ['alpha', 'beta', 'gamma'].filter(choice => choice.startsWith(value))
+
+    await interaction.respond(choices.map(choice => ({ name: choice, value: choice })))
+  }
+}

package/dist/esm/bin/builder-template/controller/channel-select-menu.controller.template

@@ -0,0 +1,12 @@
+import { ChannelSelectMenuInteraction } from 'discord.js'
+import { Controller, Command } from 'meocord/decorator'
+import { CommandType } from 'meocord/enum'
+
+@Controller()
+export class {{className}}ChannelSelectMenuController {
+
+  @Command('channel-select-menu', CommandType.CHANNEL_SELECT_MENU)
+  async handleChannelSelectMenu(interaction: ChannelSelectMenuInteraction) {
+    await interaction.reply(`Selected: ${interaction.channels.map(channel => channel.toString()).join(', ')}`)
+  }
+}

package/dist/esm/bin/builder-template/controller/context-menu.controller.template

@@ -1,6 +1,6 @@
 import { UserContextMenuCommandInteraction, MessageContextMenuCommandInteraction } from 'discord.js'
-import { Controller, Command, CommandType } from 'meocord/decorator'
-import { SampleCommandBuilder } from '@src/controllers/context-menu/builders/sample.builder'
+import { Controller, Command } from 'meocord/decorator'
+import { SampleCommandBuilder } from '{{builderImportPath}}'
 
 @Controller()
 export class {{className}}ContextMenuController {

package/dist/esm/bin/builder-template/controller/mentionable-select-menu.controller.template

@@ -0,0 +1,12 @@
+import { MentionableSelectMenuInteraction } from 'discord.js'
+import { Controller, Command } from 'meocord/decorator'
+import { CommandType } from 'meocord/enum'
+
+@Controller()
+export class {{className}}MentionableSelectMenuController {
+
+  @Command('mentionable-select-menu', CommandType.MENTIONABLE_SELECT_MENU)
+  async handleMentionableSelectMenu(interaction: MentionableSelectMenuInteraction) {
+    await interaction.reply(`Selected ${interaction.users.size} user(s) and ${interaction.roles.size} role(s).`)
+  }
+}

package/dist/esm/bin/builder-template/controller/modal-submit.controller.template

@@ -3,7 +3,7 @@ import { Controller, Command } from 'meocord/decorator'
 import { CommandType } from 'meocord/enum'
 
 @Controller()
-export class {{className}}ModalController {
+export class {{className}}ModalSubmitController {
 
   @Command('submit-modal', CommandType.MODAL_SUBMIT)
   async handleModal(interaction: ModalSubmitInteraction) {

package/dist/esm/bin/builder-template/controller/primary-entry-point.controller.template

@@ -0,0 +1,12 @@
+import { PrimaryEntryPointCommandInteraction } from 'discord.js'
+import { Controller, Command } from 'meocord/decorator'
+import { SampleCommandBuilder } from '{{builderImportPath}}'
+
+@Controller()
+export class {{className}}PrimaryEntryPointController {
+
+  @Command('sample-entry-point', SampleCommandBuilder)
+  async handleEntryPoint(interaction: PrimaryEntryPointCommandInteraction) {
+    await interaction.reply('Launching the activity.')
+  }
+}

package/dist/esm/bin/builder-template/controller/role-select-menu.controller.template

@@ -0,0 +1,12 @@
+import { RoleSelectMenuInteraction } from 'discord.js'
+import { Controller, Command } from 'meocord/decorator'
+import { CommandType } from 'meocord/enum'
+
+@Controller()
+export class {{className}}RoleSelectMenuController {
+
+  @Command('role-select-menu', CommandType.ROLE_SELECT_MENU)
+  async handleRoleSelectMenu(interaction: RoleSelectMenuInteraction) {
+    await interaction.reply(`Selected: ${interaction.roles.map(role => role.name).join(', ')}`)
+  }
+}

package/dist/esm/bin/builder-template/controller/slash.controller.template

@@ -1,6 +1,6 @@
 import { ChatInputCommandInteraction } from 'discord.js'
 import { Controller, Command } from 'meocord/decorator'
-import { SampleCommandBuilder } from '@src/controllers/slash/builders/sample.builder'
+import { SampleCommandBuilder } from '{{builderImportPath}}'
 
 @Controller()
 export class {{className}}SlashController {

package/dist/esm/bin/builder-template/controller/user-select-menu.controller.template

@@ -0,0 +1,12 @@
+import { UserSelectMenuInteraction } from 'discord.js'
+import { Controller, Command } from 'meocord/decorator'
+import { CommandType } from 'meocord/enum'
+
+@Controller()
+export class {{className}}UserSelectMenuController {
+
+  @Command('user-select-menu', CommandType.USER_SELECT_MENU)
+  async handleUserSelectMenu(interaction: UserSelectMenuInteraction) {
+    await interaction.reply(`Selected: ${interaction.users.map(user => user.username).join(', ')}`)
+  }
+}

package/dist/esm/bin/generator.js

@@ -1,4 +1,5 @@
 import { Argument } from 'commander';
+import { ControllerType } from '../enum/controller.enum.js';
 import { ControllerGeneratorHelper } from './helper/controller-generator.helper.js';
 import { Logger } from '../common/logger.js';
 import '../common/theme.js';
@@ -9,15 +10,9 @@ import wait from '../util/wait.util.js';
 class GeneratorCLI {
     register(program) {
         const generatorCommand = program.command('generate').alias('g').description('Generate components');
-        generatorCommand.command('controller').alias('co').description('Generate a controller component').addArgument(new Argument('<type>', 'Type of the controller (e.g., button, context-menu, etc.)').choices([
-            'button',
-            'context-menu',
-            'message',
-            'modal-submit',
-            'reaction',
-            'select-menu',
-            'slash'
-        ])).addArgument(new Argument('<name>', 'Name of the controller')).action(async (type, name)=>{
+        generatorCommand.command('controller').alias('co').description('Generate a controller component').addArgument(// Derived from the enum rather than listed by hand, so a new controller kind
+        // cannot be added to the framework and stay unreachable from the CLI.
+        new Argument('<type>', 'Type of the controller (e.g., button, context-menu, etc.)').choices(Object.values(ControllerType))).addArgument(new Argument('<name>', 'Name of the controller')).action(async (type, name)=>{
             await this.handleGenerateComponent({
                 component: 'controller',
                 type: type,

package/dist/esm/bin/helper/controller-generator.helper.js

@@ -14,7 +14,7 @@ class ControllerGeneratorHelper {
    */ generateController(args, type) {
         const { parts, kebabCaseName, className } = validateAndFormatName(args.controllerName);
         const controllerDir = path.join(process.cwd(), 'src', 'controllers', type, ...parts);
-        const template = this.buildControllerTemplate(className, type);
+        const template = this.buildControllerTemplate(className, type, parts);
         this.generateControllerStructure(controllerDir, kebabCaseName, className, type, template);
     }
     /**
@@ -23,8 +23,8 @@ class ControllerGeneratorHelper {
    * @param type - The type of the controller, defined in the `ControllerType` enum.
    * @returns The populated template string for the controller.
    * @throws Will throw an error if the controller type is unsupported.
-   */ buildControllerTemplate(className, type) {
-        const templateConfig = this.getTemplateConfig(type, className);
+   */ buildControllerTemplate(className, type, parts = []) {
+        const templateConfig = this.getTemplateConfig(type, className, parts);
         if (!templateConfig) {
             throw new Error(`Unsupported controller type: ${type}`);
         }
@@ -35,22 +35,38 @@ class ControllerGeneratorHelper {
    * @param type - The type of the controller, defined in the `ControllerType` enum.
    * @param className - The name of the controller class.
    * @returns An object containing the template path and variables, or `undefined` if not found.
-   */ getTemplateConfig(type, className) {
+   */ getTemplateConfig(type, className, parts = []) {
         const baseDir = path.resolve(__dirname$1, '..', 'builder-template', 'controller');
         const templates = {
             [ControllerType.BUTTON]: 'button.controller.template',
             [ControllerType.MODAL_SUBMIT]: 'modal-submit.controller.template',
             [ControllerType.SELECT_MENU]: 'select-menu.controller.template',
+            [ControllerType.USER_SELECT_MENU]: 'user-select-menu.controller.template',
+            [ControllerType.ROLE_SELECT_MENU]: 'role-select-menu.controller.template',
+            [ControllerType.MENTIONABLE_SELECT_MENU]: 'mentionable-select-menu.controller.template',
+            [ControllerType.CHANNEL_SELECT_MENU]: 'channel-select-menu.controller.template',
             [ControllerType.REACTION]: 'reaction.controller.template',
             [ControllerType.MESSAGE]: 'message.controller.template',
             [ControllerType.CONTEXT_MENU]: 'context-menu.controller.template',
-            [ControllerType.SLASH]: 'slash.controller.template'
+            [ControllerType.SLASH]: 'slash.controller.template',
+            [ControllerType.AUTOCOMPLETE]: 'autocomplete.controller.template',
+            [ControllerType.PRIMARY_ENTRY_POINT]: 'primary-entry-point.controller.template'
         };
         const template = templates[type] ? path.resolve(baseDir, templates[type]) : undefined;
+        // The builder is written beside the controller, so a nested controller name moves
+        // it too. Hard-coding `@src/controllers/<type>/builders/...` only ever pointed at
+        // the top-level one, which for a nested name does not exist.
+        const builderImportPath = [
+            '@src/controllers',
+            type,
+            ...parts,
+            'builders/sample.builder'
+        ].join('/');
         return template ? {
             template,
             variables: {
-                className
+                className,
+                builderImportPath
             }
         } : undefined;
     }
@@ -99,7 +115,8 @@ class ControllerGeneratorHelper {
         const baseDir = path.resolve(__dirname$1, '..', 'builder-template', 'builder');
         const templates = {
             [ControllerType.CONTEXT_MENU]: 'context-menu.builder.template',
-            [ControllerType.SLASH]: 'slash.builder.template'
+            [ControllerType.SLASH]: 'slash.builder.template',
+            [ControllerType.PRIMARY_ENTRY_POINT]: 'primary-entry-point.builder.template'
         };
         const template = templates[type] ? path.resolve(baseDir, templates[type]) : undefined;
         return template ? {