meocord 3.0.0 → 3.1.0

package/dist/types/decorator/index.d.ts

@@ -1,6 +1,6 @@
+import { BuildableCommandType, CommandBuilderBase, CommandBuilderConstructor, CommandInteractionType, ReactionHandlerOptions, AutocompleteMetadata, CommandMetadata, GuardInterface } from '../interface/index.js';
+import { AutocompleteInteraction, OmitPartialGroupDMChannel, Message, MessageReaction, PartialMessageReaction, ClientOptions, ActivityOptions } from 'discord.js';
 import { CommandType } from '../enum/index.js';
-import { SlashCommandBuilder, SlashCommandSubcommandsOnlyBuilder, ContextMenuCommandBuilder, ButtonInteraction, StringSelectMenuInteraction, ChatInputCommandInteraction, UserContextMenuCommandInteraction, MessageContextMenuCommandInteraction, ModalSubmitInteraction, OmitPartialGroupDMChannel, Message, MessageReaction, PartialMessageReaction, ClientOptions, ActivityOptions } from 'discord.js';
-import { ReactionHandlerOptions, GuardInterface } from '../interface/index.js';
 import { ServiceIdentifier } from 'inversify';
 import 'webpack';
 
@@ -29,44 +29,6 @@ import 'webpack';
  */
 declare function Service<T>(): (target: new (...args: any[]) => T) => void;
 
-/**
- * MeoCord Framework
- * Copyright (c) 2025 Ukasyah Rahmatullah Zada
- * SPDX-License-Identifier: MIT
- */
-
-/**
- * Base interface for a command builder.
- */
-interface CommandBuilderBase<T extends CommandType.SLASH | CommandType.CONTEXT_MENU = CommandType.SLASH | CommandType.CONTEXT_MENU> {
-    /**
-     * Builds the command structure using the specified command name.
-     *
-     * @param commandName - The name of the command.
-     * @returns A SlashCommandBuilder or ContextMenuCommandBuilder instance.
-     */
-    build: (commandName: string) => T extends CommandType.SLASH ? SlashCommandBuilder | SlashCommandSubcommandsOnlyBuilder : T extends CommandType.CONTEXT_MENU ? ContextMenuCommandBuilder : never;
-}
-type CommandBuilderConstructor<T extends CommandType.SLASH | CommandType.CONTEXT_MENU> = new () => CommandBuilderBase<T>;
-/**
- * Command metadata describing a registered command method.
- */
-interface CommandMetadata<T extends string = string> {
-    methodName: string;
-    builder: ReturnType<CommandBuilderBase['build']> | undefined;
-    type: CommandType;
-    regex?: RegExp;
-    dynamicParams?: T[];
-    /**
-     * How specific this pattern is; higher wins when more than one route matches the
-     * same customId. A greedy parameter can overlap a more literal sibling —
-     * `gi-profile-{uuid:*}-{uid}` also matches an id meant for
-     * `gi-profile-summary-{ownerId}-{uid}` — so dispatch cannot rely on declaration order.
-     */
-    specificity?: number;
-}
-type CommandInteractionType<CBC extends CommandType.SLASH | CommandType.CONTEXT_MENU, T extends CommandBuilderConstructor<CBC> | CommandType> = T extends CommandType.BUTTON ? ButtonInteraction : T extends CommandType.SELECT_MENU ? StringSelectMenuInteraction : T extends CommandBuilderConstructor<CommandType.SLASH> ? ChatInputCommandInteraction : T extends CommandBuilderConstructor<CommandType.CONTEXT_MENU> ? UserContextMenuCommandInteraction | MessageContextMenuCommandInteraction : T extends CommandType.MODAL_SUBMIT ? ModalSubmitInteraction : never;
-
 /**
  * MeoCord Framework
  * Copyright (c) 2025 Ukasyah Rahmatullah Zada
@@ -91,7 +53,7 @@ type CommandInteractionType<CBC extends CommandType.SLASH | CommandType.CONTEXT_
  * @returns A decorator function that makes the target class injectable
  *          and assigns the `commandType` metadata.
  */
-declare function CommandBuilder<T extends CommandType.SLASH | CommandType.CONTEXT_MENU>(commandType: T): (target: new () => CommandBuilderBase<T>) => void;
+declare function CommandBuilder<T extends BuildableCommandType>(commandType: T): (target: new () => CommandBuilderBase<T>) => void;
 
 /**
  * MeoCord Framework
@@ -162,8 +124,13 @@ declare const PARAM_SEPARATOR = "/";
 /**
  * Decorator to register command methods in a controller.
  *
- * @param commandName - The name or pattern of the command.
- * @param builderOrType - A command builder class or a command type from `CommandType`.
+ * @param commandName - What the command is addressed by. Commands registered with
+ *   Discord use their name, and a subcommand its full path — `settings notify email`,
+ *   parts separated by a space, the way Discord displays it. Components use a customId
+ *   pattern, where `{name}` captures one `/`-separated segment.
+ * @param builderOrType - A command builder class, or a `CommandType` for a handler that
+ *   registers nothing of its own: every component, and every subcommand of a command
+ *   whose builder already describes it.
  *
  * @example
  * ```typescript
@@ -172,13 +139,23 @@ declare const PARAM_SEPARATOR = "/";
  *   await interaction.reply('This is the help command!')
  * }
  *
- * @Command('stats-{id}', CommandType.BUTTON)
- * public async handleStats(message: ButtonInteraction, { id }) {
- *   await message.reply(`Fetching stats for ID: ${id}`);
+ * @Command('settings notify email', CommandType.SLASH)
+ * public async handleNotifyEmail(interaction: ChatInputCommandInteraction, { enabled }) {
+ *   await interaction.reply(`Email notifications ${enabled ? 'on' : 'off'}`)
+ * }
+ *
+ * @Command('stats/{id}', CommandType.BUTTON)
+ * public async handleStats(interaction: ButtonInteraction, { id }) {
+ *   await interaction.reply(`Fetching stats for ID: ${id}`);
+ * }
+ *
+ * @Command('assign/{taskId}', CommandType.USER_SELECT_MENU)
+ * public async handleAssign(interaction: UserSelectMenuInteraction, { taskId }) {
+ *   await interaction.reply(`Assigned ${interaction.users.size} user(s) to ${taskId}`)
  * }
  * ```
  */
-declare function Command<CBC extends CommandType.SLASH | CommandType.CONTEXT_MENU, T extends CommandBuilderConstructor<CBC> | CommandType>(commandName: string, builderOrType: T): <P extends Record<string, any>, R extends Promise<void> | void>(target: object, propertyKey: string, _descriptor: TypedPropertyDescriptor<(interaction: CommandInteractionType<CBC, T>, params: P) => R> | TypedPropertyDescriptor<(interaction: CommandInteractionType<CBC, T>) => R>) => void;
+declare function Command<CBC extends BuildableCommandType, T extends CommandBuilderConstructor<CBC> | CommandType>(commandName: string, builderOrType: T): <P extends Record<string, any>, R extends Promise<void> | void>(target: object, propertyKey: string, _descriptor: TypedPropertyDescriptor<(interaction: CommandInteractionType<CBC, T>, params: P) => R> | TypedPropertyDescriptor<(interaction: CommandInteractionType<CBC, T>) => R>) => void;
 /**
  * Retrieves the command map for a given controller.
  *
@@ -186,6 +163,41 @@ declare function Command<CBC extends CommandType.SLASH | CommandType.CONTEXT_MEN
  * @returns A record containing command metadata indexed by command names.
  */
 declare function getCommandMap<T extends string>(controller: any): Record<string, CommandMetadata<T>[]>;
+/**
+ * Decorator to register an autocomplete handler for a chat input command's option.
+ *
+ * Autocomplete is a separate interaction from the command it belongs to, and Discord
+ * sends it while the user is still typing. It is not a `@Command`: nothing is
+ * registered for it — the option's own `setAutocomplete(true)` is what turns it on —
+ * and it is answered with `interaction.respond()` rather than a reply. Leaving it
+ * unhandled is not silent to the user: the client shows a loading state until the
+ * three-second window closes.
+ *
+ * @param commandPath - The command to complete, e.g. `settings` or `settings notify email`
+ *   for a subcommand. Parts are separated by a single space, as Discord displays them.
+ * @param optionName - The option to complete. Omit to handle every option of the command,
+ *   branching on `interaction.options.getFocused(true)`.
+ *
+ * @example
+ * ```typescript
+ * @Autocomplete('search', 'query')
+ * async completeQuery(interaction: AutocompleteInteraction) {
+ *   const { value } = interaction.options.getFocused(true)
+ *   await interaction.respond(this.search(value).map(name => ({ name, value: name })))
+ * }
+ * ```
+ */
+declare function Autocomplete<R extends void | Promise<void>>(commandPath: string, optionName?: string): <P extends Record<string, any>>(target: object, propertyKey: string, _descriptor: TypedPropertyDescriptor<(interaction: AutocompleteInteraction, params: P) => R> | TypedPropertyDescriptor<(interaction: AutocompleteInteraction) => R>) => void;
+/**
+ * Retrieves autocomplete handler metadata from a given controller.
+ *
+ * Handlers naming an option come first, so a command-wide handler acts as the fallback
+ * for options no specific handler claimed rather than shadowing them by declaration order.
+ *
+ * @param controller - The controller class instance.
+ * @returns The registered autocomplete handlers, most specific first.
+ */
+declare function getAutocompleteHandlers(controller: any): AutocompleteMetadata[];
 /**
  * Decorator to mark a class as a controller that can later be registered to the App class `(app.ts)` using the `@MeoCord` decorator.
  *
@@ -355,4 +367,4 @@ declare function MeoCord(options: {
     services?: ServiceIdentifier[];
 }): (target: any) => void;
 
-export { Command, CommandBuilder, Controller, Guard, MeoCord, MessageHandler, PARAM_SEPARATOR, ReactionHandler, Service, UseGuard, findAmbiguousRoutes, getCommandMap, getMessageHandlers, getReactionHandlers };
+export { Autocomplete, Command, CommandBuilder, Controller, Guard, MeoCord, MessageHandler, PARAM_SEPARATOR, ReactionHandler, Service, UseGuard, findAmbiguousRoutes, getAutocompleteHandlers, getCommandMap, getMessageHandlers, getReactionHandlers };

package/dist/types/enum/index.d.ts

@@ -1,4 +1,4 @@
-export { C as CommandType, R as ReactionHandlerAction } from '../controller.enum-QA-IuReF.js';
+export { C as CommandType, R as ReactionHandlerAction } from '../controller.enum-DYfhYaat.js';
 
 /**
  * MeoCord Framework

package/dist/types/interface/index.d.ts

@@ -1,6 +1,90 @@
-import { User, PartialUser, BaseInteraction, Message, MessageReaction } from 'discord.js';
+import { SlashCommandBuilder, SlashCommandSubcommandsOnlyBuilder, ContextMenuCommandBuilder, RESTPostAPIPrimaryEntryPointApplicationCommandJSONBody, ChatInputCommandInteraction, UserContextMenuCommandInteraction, MessageContextMenuCommandInteraction, PrimaryEntryPointCommandInteraction, ButtonInteraction, StringSelectMenuInteraction, UserSelectMenuInteraction, RoleSelectMenuInteraction, MentionableSelectMenuInteraction, ChannelSelectMenuInteraction, ModalSubmitInteraction, User, PartialUser, BaseInteraction, Message, MessageReaction } from 'discord.js';
 import { Configuration } from 'webpack';
-import { ReactionHandlerAction } from '../enum/index.js';
+import { CommandType, ReactionHandlerAction } from '../enum/index.js';
+
+/**
+ * MeoCord Framework
+ * Copyright (c) 2025 Ukasyah Rahmatullah Zada
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * The command types that are registered with Discord, and so need a builder.
+ *
+ * Components are addressed by a customId the application makes up, so they have
+ * nothing to register; these three are published through `application.commands.set`.
+ */
+type BuildableCommandType = CommandType.SLASH | CommandType.CONTEXT_MENU | CommandType.PRIMARY_ENTRY_POINT;
+/**
+ * The body an entry point command is registered with.
+ *
+ * `description` is added back on top of the discord-api-types body: that type omits it
+ * from every non-chat-input command, but the API accepts one for entry point commands
+ * — Discord's own default activity command ships with it set.
+ */
+type PrimaryEntryPointCommandData = RESTPostAPIPrimaryEntryPointApplicationCommandJSONBody & {
+    description?: string;
+};
+/**
+ * The payload `build()` returns for a given command type.
+ *
+ * `PRIMARY_ENTRY_POINT` yields a raw REST body rather than a builder because
+ * `@discordjs/builders` ships none for it; `ApplicationCommandManager#set` accepts the
+ * JSON body directly, so nothing is lost.
+ */
+type CommandBuildResult<T extends BuildableCommandType> = T extends CommandType.SLASH ? SlashCommandBuilder | SlashCommandSubcommandsOnlyBuilder : T extends CommandType.CONTEXT_MENU ? ContextMenuCommandBuilder : T extends CommandType.PRIMARY_ENTRY_POINT ? PrimaryEntryPointCommandData : never;
+/**
+ * Base interface for a command builder.
+ */
+interface CommandBuilderBase<T extends BuildableCommandType = BuildableCommandType> {
+    /**
+     * Builds the command structure using the specified command name.
+     *
+     * @param commandName - The name of the command.
+     * @returns A builder instance, or a raw command body for entry point commands.
+     */
+    build: (commandName: string) => CommandBuildResult<T>;
+}
+type CommandBuilderConstructor<T extends BuildableCommandType> = new () => CommandBuilderBase<T>;
+/**
+ * Command metadata describing a registered command method.
+ */
+interface CommandMetadata<T extends string = string> {
+    methodName: string;
+    builder: ReturnType<CommandBuilderBase['build']> | undefined;
+    type: CommandType;
+    regex?: RegExp;
+    dynamicParams?: T[];
+    /**
+     * How specific this pattern is; higher wins when more than one route matches the
+     * same customId. A greedy parameter can overlap a more literal sibling —
+     * `gi-profile-{uuid:*}-{uid}` also matches an id meant for
+     * `gi-profile-summary-{ownerId}-{uid}` — so dispatch cannot rely on declaration order.
+     */
+    specificity?: number;
+}
+/** Metadata describing one `@Autocomplete` handler. */
+interface AutocompleteMetadata {
+    /** The command path the handler serves, e.g. `settings` or `settings notify email`. */
+    commandPath: string;
+    /** The option it completes, or `undefined` to complete every option of that command. */
+    optionName?: string;
+    methodName: string;
+}
+/** The interaction class each non-buildable command type hands to its handler. */
+interface ComponentInteractionMap {
+    [CommandType.BUTTON]: ButtonInteraction;
+    [CommandType.SELECT_MENU]: StringSelectMenuInteraction;
+    [CommandType.USER_SELECT_MENU]: UserSelectMenuInteraction;
+    [CommandType.ROLE_SELECT_MENU]: RoleSelectMenuInteraction;
+    [CommandType.MENTIONABLE_SELECT_MENU]: MentionableSelectMenuInteraction;
+    [CommandType.CHANNEL_SELECT_MENU]: ChannelSelectMenuInteraction;
+    [CommandType.MODAL_SUBMIT]: ModalSubmitInteraction;
+    [CommandType.SLASH]: ChatInputCommandInteraction;
+    [CommandType.CONTEXT_MENU]: UserContextMenuCommandInteraction | MessageContextMenuCommandInteraction;
+    [CommandType.PRIMARY_ENTRY_POINT]: PrimaryEntryPointCommandInteraction;
+}
+type CommandInteractionType<CBC extends BuildableCommandType, T extends CommandBuilderConstructor<CBC> | CommandType> = T extends CommandBuilderConstructor<CommandType.SLASH> ? ChatInputCommandInteraction : T extends CommandBuilderConstructor<CommandType.CONTEXT_MENU> ? UserContextMenuCommandInteraction | MessageContextMenuCommandInteraction : T extends CommandBuilderConstructor<CommandType.PRIMARY_ENTRY_POINT> ? PrimaryEntryPointCommandInteraction : T extends keyof ComponentInteractionMap ? ComponentInteractionMap[T] : never;
 
 /**
  * MeoCord Framework
@@ -92,4 +176,4 @@ interface MeoCordConfig {
     webpack?: (config: MeoCordWebpackConfig) => MeoCordWebpackConfig | undefined;
 }
 
-export type { GuardInterface, MeoCordConfig, MeoCordWebpackConfig, ReactionHandlerOptions };
+export type { AutocompleteMetadata, BuildableCommandType, CommandBuildResult, CommandBuilderBase, CommandBuilderConstructor, CommandInteractionType, CommandMetadata, GuardInterface, MeoCordConfig, MeoCordWebpackConfig, ReactionHandlerOptions };

package/dist/types/testing/index.d.ts

@@ -2,7 +2,7 @@ import { ServiceIdentifier, Container } from 'inversify';
 import { GuardInterface } from '../interface/index.js';
 import { CacheType, CommandInteractionOptionResolver, Channel, Client, Guild, Message, User } from 'discord.js';
 import 'webpack';
-import '../controller.enum-QA-IuReF.js';
+import '../controller.enum-DYfhYaat.js';
 
 /**
  * MeoCord Framework
@@ -277,30 +277,12 @@ declare function createMockMessage(): DeepMocked<Message>;
 interface ChatInputOptions {
     subcommandGroup?: string | null;
     subcommand?: string | null;
+    /** The option the user is currently typing, for autocomplete interactions. */
+    focused?: string | null;
     [name: string]: string | number | boolean | {
         id: string;
     } | null | undefined;
 }
-/**
- * Builds a typed options resolver from a plain record. Mirrors how the real
- * `CommandInteractionOptionResolver` works: declare what options the command
- * was invoked with, and the resolver finds them by name.
- *
- * All explicit methods are mock functions — override per test with `.mockReturnValue()`.
- * Methods not listed (e.g. `getAttachment`) are auto-stubbed by the Proxy.
- *
- * @example
- * ```ts
- * const interaction = createMockInteraction(ChatInputCommandInteraction)
- * interaction.options = createChatInputOptions({
- *   subcommandGroup: 'daily',
- *   subcommand: 'notes',
- *   uid: 12345678,
- * })
- * interaction.options.getSubcommand()  // → 'notes'
- * interaction.options.getNumber('uid') // → 12345678
- * ```
- */
 declare function createChatInputOptions<Cached extends CacheType = any>(opts?: ChatInputOptions): DeepMocked<CommandInteractionOptionResolver<Cached>>;
 
 export { MeoCordTestingModule, TestingModule, TestingModuleBuilder, createChatInputOptions, createMock, createMockChannel, createMockClient, createMockFn, createMockGuild, createMockInteraction, createMockMessage, createMockUser, isMockFunction };

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "meocord",
   "description": "Decorator-based Discord bot framework built on discord.js. Brings NestJS-style controllers, dependency injection, guards, and testing utilities to bot development — with a full CLI and TypeScript-first design.",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "type": "module",
   "engines": {
     "node": ">=22"
   },
   "scripts": {
-    "lint": "eslint --fix . && tsc --noEmit && tsc --noEmit --project tsconfig.test.json",
+    "lint": "prettier --write \"**/*.md\" && eslint --fix . && tsc --noEmit && tsc --noEmit --project tsconfig.test.json",
     "build": "rm -rf ./dist && rollup -c",
     "prepare": "husky",
     "test": "vitest run",

package/dist/cjs/_shared/controller.decorator-CC6BjHkS.cjs

@@ -1,288 +0,0 @@
-'use strict';
-
-require('reflect-metadata');
-var inversify = require('inversify');
-var discord_js = require('discord.js');
-var enum_index = require('../enum/index.cjs');
-var metadataKey_enum = require('./metadata-key.enum-BzzvGUId.cjs');
-
-const COMMAND_METADATA_KEY = Symbol('commands');
-const MESSAGE_HANDLER_METADATA_KEY = Symbol('message_handlers');
-const REACTION_HANDLER_METADATA_KEY = Symbol('reaction_handlers');
-/**
- * Decorator to register message handlers in the controller.
- *
- * @param keyword - An optional keyword to filter messages this handler should respond to.
- *
- * @example
- * ```typescript
- * @MessageHandler('hello')
- * async handleHelloMessage(message: Message) {
- *   await message.reply('Hello! How can I help you?');
- * }
- *
- * @MessageHandler()
- * async handleAnyMessage(message: Message) {
- *   console.log(`Received a message: ${message.content}`);
- * }
- * ```
- */ function MessageHandler(keyword) {
-    return function(target, propertyKey, _descriptor) {
-        const handlers = Reflect.getMetadata(MESSAGE_HANDLER_METADATA_KEY, target) || [];
-        handlers.push({
-            keyword,
-            method: propertyKey.toString()
-        });
-        Reflect.defineMetadata(MESSAGE_HANDLER_METADATA_KEY, handlers, target);
-    };
-}
-/**
- * Decorator to register reaction handlers in the controller.
- *
- * @param emoji - Optional emoji name to filter reactions this handler should respond to.
- *
- * @example
- * ```typescript
- * @ReactionHandler('👍')
- * async handleThumbsUpReaction(reaction: MessageReaction, { user }: ReactionHandlerOptions) {
- *   console.log(`User ${user.username} reacted with 👍`);
- * }
- *
- * @ReactionHandler()
- * async handleAnyReaction(reaction: MessageReaction, { user }: ReactionHandlerOptions) {
- *   console.log(`User ${user.username} reacted with ${reaction.emoji.name}`);
- * }
- * ```
- */ function ReactionHandler(emoji) {
-    return function(target, propertyKey, _descriptor) {
-        const handlers = Reflect.getMetadata(REACTION_HANDLER_METADATA_KEY, target) || [];
-        handlers.push({
-            emoji,
-            method: propertyKey.toString()
-        });
-        Reflect.defineMetadata(REACTION_HANDLER_METADATA_KEY, handlers, target);
-    };
-}
-/**
- * Retrieves reaction handlers metadata from a given controller.
- *
- * @param controller - The controller class instance.
- * @returns An array of reaction handler metadata objects.
- */ function getReactionHandlers(controller) {
-    return Reflect.getMetadata(REACTION_HANDLER_METADATA_KEY, controller) || [];
-}
-/**
- * Retrieves message handlers metadata from a given controller.
- *
- * @param controller - The controller class instance.
- * @returns An array of message handler method names.
- */ function getMessageHandlers(controller) {
-    return Reflect.getMetadata(MESSAGE_HANDLER_METADATA_KEY, controller) || [];
-}
-const PLACEHOLDER_PATTERN = /\{(\w+)}/g;
-/** The character a parameter will not cross, so one pattern segment maps to one value. */ const PARAM_SEPARATOR = '/';
-/** Escapes a literal stretch of a pattern so only placeholders stay meaningful. */ const escapeLiteral = (literal)=>literal.replace(/[/\\^$*+?.()|[\]{}]/g, '\\$&');
-/**
- * Helper function to create regex and parameter mappings from a pattern string.
- *
- * A `{name}` matches anything up to the next `/`, the same rule Express and Rails use
- * for a path segment. That is what lets a value the application does not control — a
- * uuid, an opaque vendor id, a slug — be captured whole without the author annotating
- * anything, since a hyphen inside it is data rather than structure.
- *
- * It also keeps neighbouring patterns apart: `profile/{uuid}` and `profile/{uuid}/{id}`
- * cannot both match one id, because a parameter cannot swallow the separator between
- * them. Patterns separated by `-` instead have no such boundary, so a pair like
- * `profile-{uuid}` and `profile-{uuid}-{id}` is ambiguous — {@link findAmbiguousRoutes}
- * reports those at registration.
- *
- * @param pattern - The pattern string to parse.
- * @returns The regex, the parameter names, and how specific the pattern is.
- */ function createRegexFromPattern(pattern) {
-    const params = [];
-    let regexPattern = '';
-    let cursor = 0;
-    let literalLength = 0;
-    PLACEHOLDER_PATTERN.lastIndex = 0;
-    let match;
-    while((match = PLACEHOLDER_PATTERN.exec(pattern)) !== null){
-        const [placeholder, param] = match;
-        const literal = pattern.slice(cursor, match.index);
-        const after = pattern[match.index + placeholder.length];
-        // A parameter has to own its segment. Sharing one with a literal leaves no
-        // boundary a sibling pattern can be told apart by, and the resulting overlap has
-        // no correct reading -- `profile-{uuid}` and `profile-{uuid}-{id}` both take
-        // `profile-a-b`. Registration is the last point where that is still fixable.
-        if (literal !== '' && !literal.endsWith(PARAM_SEPARATOR) || after !== undefined && after !== PARAM_SEPARATOR) {
-            throw new Error(`Invalid pattern "${pattern}": {${param}} must occupy a whole segment, so it has to be ` + `preceded and followed by "${PARAM_SEPARATOR}" or by the ends of the pattern. ` + `Write "a${PARAM_SEPARATOR}{${param}}" rather than "a-{${param}}".`);
-        }
-        literalLength += literal.length;
-        regexPattern += escapeLiteral(literal);
-        regexPattern += `(?<${param}>[^${PARAM_SEPARATOR}]+)`;
-        params.push(param);
-        cursor = match.index + placeholder.length;
-    }
-    const trailing = pattern.slice(cursor);
-    literalLength += trailing.length;
-    regexPattern += escapeLiteral(trailing);
-    const regex = new RegExp(`^${regexPattern}$`);
-    // Literal text is the signal: a pattern spelling out more of the id describes it
-    // more exactly than one leaving it to a parameter. Fewer parameters breaks a tie
-    // between equal-length patterns, so the ranking is total and never falls back to
-    // declaration order.
-    const specificity = literalLength * 1000 - params.length;
-    return {
-        regex,
-        params,
-        specificity
-    };
-}
-/**
- * Decorator to register command methods in a controller.
- *
- * @param commandName - The name or pattern of the command.
- * @param builderOrType - A command builder class or a command type from `CommandType`.
- *
- * @example
- * ```typescript
- * @Command('help', CommandType.SLASH)
- * public async handleHelp(interaction: ChatInputCommandInteraction) {
- *   await interaction.reply('This is the help command!')
- * }
- *
- * @Command('stats-{id}', CommandType.BUTTON)
- * public async handleStats(message: ButtonInteraction, { id }) {
- *   await message.reply(`Fetching stats for ID: ${id}`);
- * }
- * ```
- */ function Command(commandName, builderOrType) {
-    return function(target, propertyKey, _descriptor) {
-        const originalMethod = _descriptor.value;
-        if (!originalMethod) {
-            throw new Error(`Missing implementation for method ${propertyKey}`);
-        }
-        // Wrap original method for interaction type validation
-        _descriptor.value = function(interaction, params) {
-            const expectedInteraction = commandType === enum_index.CommandType.BUTTON && interaction instanceof discord_js.ButtonInteraction || commandType === enum_index.CommandType.SELECT_MENU && interaction instanceof discord_js.StringSelectMenuInteraction || commandType === enum_index.CommandType.SLASH && interaction instanceof discord_js.ChatInputCommandInteraction || commandType === enum_index.CommandType.CONTEXT_MENU && interaction instanceof discord_js.ContextMenuCommandInteraction || commandType === enum_index.CommandType.MODAL_SUBMIT && interaction instanceof discord_js.ModalSubmitInteraction;
-            if (!expectedInteraction) {
-                throw new Error(`Invalid interaction type passed to @Command for method: ${propertyKey}`);
-            }
-            return originalMethod.apply(this, [
-                interaction,
-                params
-            ]);
-        };
-        // Retrieve existing metadata or initialize it
-        const commands = Reflect.getMetadata(COMMAND_METADATA_KEY, target) || {};
-        let builderInstance;
-        let commandType;
-        let regex;
-        let dynamicParams = [];
-        let specificity;
-        // Determine command type and builder
-        if (typeof builderOrType === 'function') {
-            const builderObj = new builderOrType();
-            builderInstance = builderObj.build(commandName);
-            commandType = Reflect.getMetadata(metadataKey_enum.MetadataKey.CommandType, builderOrType);
-            if (!(commandType in enum_index.CommandType)) {
-                throw new Error(`Metadata for 'commandType' is missing on builder ${builderOrType.name}`);
-            }
-        } else {
-            commandType = builderOrType;
-        }
-        if (commandType !== enum_index.CommandType.SLASH && commandType !== enum_index.CommandType.CONTEXT_MENU) {
-            const { regex: generatedRegex, params, specificity: patternSpecificity } = createRegexFromPattern(commandName);
-            regex = generatedRegex;
-            dynamicParams = params;
-            specificity = patternSpecificity;
-        }
-        // Ensure commandName supports multiple entries
-        if (!commands[commandName]) {
-            commands[commandName] = [];
-        }
-        commands[commandName].push({
-            methodName: propertyKey,
-            builder: builderInstance,
-            type: commandType,
-            regex,
-            dynamicParams,
-            specificity
-        });
-        Reflect.defineMetadata(COMMAND_METADATA_KEY, commands, target);
-    };
-}
-/**
- * Retrieves the command map for a given controller.
- *
- * @param controller - The controller class instance.
- * @returns A record containing command metadata indexed by command names.
- */ function getCommandMap(controller) {
-    return Reflect.getMetadata(COMMAND_METADATA_KEY, controller);
-}
-/**
- * Decorator to mark a class as a controller that can later be registered to the App class `(app.ts)` using the `@MeoCord` decorator.
- *
- * @example
- * ```typescript
- * @Controller()
- * export class PingSlashController {
- *   constructor(private pingService: PingService) {}
- *
- *   @Command('ping', PingCommandBuilder)
- *   async ping(interaction: ChatInputCommandInteraction) {
- *     const response = await this.pingService.handlePing()
- *     await interaction.reply(response)
- *   }
- * }
- * ```
- */ function Controller() {
-    return function(target) {
-        if (!Reflect.hasMetadata(metadataKey_enum.MetadataKey.Injectable, target)) {
-            inversify.injectable()(target);
-        }
-    };
-}
-/**
- * Finds pattern pairs that can both match one customId.
- *
- * Patterns of different segment counts are disjoint, because a parameter cannot cross
- * `/`. Within the same count, two patterns overlap unless some position holds literals
- * that differ: `a/{x}/c` and `a/b/{y}` both take `a/b/c`, and neither is more literal
- * than the other, so ranking cannot settle it either.
- *
- * @param patterns - The registered patterns.
- * @returns Each ambiguous pair, once, in the order the patterns were given.
- */ function findAmbiguousRoutes(patterns) {
-    const isParam = (segment)=>PLACEHOLDER_PATTERN.test(segment);
-    const segmentsOf = (pattern)=>pattern.split(PARAM_SEPARATOR);
-    const collisions = [];
-    for(let i = 0; i < patterns.length; i++){
-        for(let j = i + 1; j < patterns.length; j++){
-            const left = segmentsOf(patterns[i]);
-            const right = segmentsOf(patterns[j]);
-            if (left.length !== right.length) continue;
-            const disjoint = left.some((segment, index)=>{
-                PLACEHOLDER_PATTERN.lastIndex = 0;
-                const leftIsParam = isParam(segment);
-                PLACEHOLDER_PATTERN.lastIndex = 0;
-                const rightIsParam = isParam(right[index]);
-                return !leftIsParam && !rightIsParam && segment !== right[index];
-            });
-            if (!disjoint) collisions.push([
-                patterns[i],
-                patterns[j]
-            ]);
-        }
-    }
-    return collisions;
-}
-
-exports.Command = Command;
-exports.Controller = Controller;
-exports.MessageHandler = MessageHandler;
-exports.PARAM_SEPARATOR = PARAM_SEPARATOR;
-exports.ReactionHandler = ReactionHandler;
-exports.findAmbiguousRoutes = findAmbiguousRoutes;
-exports.getCommandMap = getCommandMap;
-exports.getMessageHandlers = getMessageHandlers;
-exports.getReactionHandlers = getReactionHandlers;

package/dist/types/controller.enum-QA-IuReF.d.ts

@@ -1,18 +0,0 @@
-declare enum CommandType {
-    SLASH = "SLASH",
-    BUTTON = "BUTTON",
-    CONTEXT_MENU = "CONTEXT_MENU",
-    SELECT_MENU = "SELECT_MENU",
-    MODAL_SUBMIT = "MODAL_SUBMIT"
-}
-/**
- * Enum representing actions that can be performed on a message reaction.
- */
-declare enum ReactionHandlerAction {
-    /** Reaction added to a message. */
-    ADD = "ADD",
-    /** Reaction removed from a message. */
-    REMOVE = "REMOVE"
-}
-
-export { CommandType as C, ReactionHandlerAction as R };