meocord 3.0.0 → 3.2.0

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