@ezzi/base 1.0.3 → 2.0.0

package/dist/creators/commands/command.d.ts

@@ -80,7 +80,6 @@ export interface GroupOptionData<Contexts> extends Omit<BaseOptionData, "require
 export type SlashCommandOptionData<Contexts> = SlashCommandPrimitiveOptionData<Contexts> | GroupOptionData<Contexts> | SubCommandOptionData<Contexts>;
 export type RunInteraction<T, Contexts> = T extends ApplicationCommandType.Message ? MessageContextMenuCommandInteraction<CacheMode<Contexts>> : T extends ApplicationCommandType.User ? UserContextMenuCommandInteraction<CacheMode<Contexts>> : ChatInputCommandInteraction<CacheMode<Contexts>>;
 interface CommandRunThis {
-    /** Blocks the flow of executions */
     block(): never;
 }
 type BaseAppCommandData = Omit<BaseApplicationCommandData, "contexts" | "dmPermission"> & Pick<BaseOptionData, "descriptionLocalizations">;
@@ -133,6 +132,7 @@ declare class GroupCommandModule<Type, Contexts extends readonly InteractionCont
 export declare class Command<Type, Contexts extends readonly InteractionContextType[] = readonly InteractionContextType[], Return = unknown> {
     readonly modules: CommandModule[];
     readonly data: AppCommandData<Type, Contexts, Return>;
+    moduleListener?: (module: CommandModule) => void;
     constructor(data: AppCommandData<Type, Contexts, Return>);
     group<ModuleReturn = Return>(data: SubCommandGroupModuleData<Contexts, Return, ModuleReturn>): GroupCommandModule<Type, Contexts, Return, ModuleReturn>;
     subcommand<R = Return>(data: SubCommandModuleData<Contexts, R>): this;

package/dist/creators/commands/command.js

@@ -26,6 +26,7 @@ class GroupCommandModule {
 class Command {
   modules = [];
   data;
+  moduleListener;
   constructor(data) {
     this.data = data;
     this.data.type ??= ApplicationCommandType.ChatInput;
@@ -41,17 +42,21 @@ class Command {
     }
   }
   group(data) {
-    this.modules.push({
+    const module = {
       ...data,
       type: ApplicationCommandOptionType.SubcommandGroup
-    });
+    };
+    this.modules.push(module);
+    this.moduleListener?.(module);
     return new GroupCommandModule(this, data);
   }
   subcommand(data) {
-    this.modules.push({
+    const module = {
       ...data,
       type: ApplicationCommandOptionType.Subcommand
-    });
+    };
+    this.modules.push(module);
+    this.moduleListener?.(module);
     return this;
   }
 }

package/dist/creators/commands/manager.js

@@ -66,8 +66,6 @@ class CommandManager {
     for (const [k, v] of this.aliasCollection) {
       this.runtimeCollection.set(k, v);
     }
-    this.collection.clear();
-    this.aliasCollection.clear();
   }
   getAutocompleteHandler(...path) {
     const commandName = path[0];
@@ -162,6 +160,9 @@ class CommandManager {
             options: subcommands,
             defaultMemberPermissions,
             botPermissions,
+            run: _groupRun,
+            ignore: _groupIgnore,
+            aliases: _groupAliases,
             ...data
           } = option;
           if (botPermissions?.length) {
@@ -180,6 +181,11 @@ class CommandManager {
             options: subOpts,
             defaultMemberPermissions,
             botPermissions,
+            run: _subRun,
+            ignore: _subIgnore,
+            aliases: _subAliases,
+            shortcut: _subShortcut,
+            group: _subGroup,
             ...data
           } = option;
           if (botPermissions?.length) {
@@ -272,21 +278,22 @@ class CommandManager {
     const type = data.type ?? ApplicationCommandType.ChatInput;
     const name = this.formatName(data.name, type);
     const dmPermission = data.dmPermission ?? false;
+    const existingData = this.collection.get(name);
     const commandData = {
       ...data,
       name,
       type,
-      dmPermission
+      dmPermission,
+      modules: existingData?.modules ?? []
     };
-    if (this.collection.has(name)) {
-      const existing = this.collection.get(name);
+    if (existingData) {
       const canonicalPath2 = `/${type}/${name}`;
       this.commandRunners.delete(canonicalPath2);
       this.optionDefs.delete(canonicalPath2);
       this.botPermissionsMap.delete(canonicalPath2);
       this.autocompleteRunners.delete(canonicalPath2);
-      if (existing.aliases?.length) {
-        for (const alias of existing.aliases) {
+      if (existingData.aliases?.length) {
+        for (const alias of existingData.aliases) {
           this.aliasCollection.delete(this.formatName(alias, type));
         }
       }
@@ -323,6 +330,9 @@ class CommandManager {
         descriptionLocalizations,
         category,
         botPermissions: _bp,
+        run: _run,
+        ignore: _ignore,
+        aliases: _aliases,
         ...data
       } = raw;
       const path = `/${data.type}/${data.name}`;
@@ -331,7 +341,7 @@ class CommandManager {
         descriptionLocalizations,
         options: this.buildOptions([
           ...options ?? [],
-          ...this.resolveModules(modules ?? [], path, data.run)
+          ...this.resolveModules(modules ?? [], path, raw.run)
         ], path)
       } : {};
       return { ...data, ...slashData, category };
@@ -344,8 +354,10 @@ class CommandManager {
   }
   addModule(commandName, module) {
     const command = this.collection.get(commandName);
-    if (!command)
+    if (!command) {
+      console.warn(`[EzziApp] Comando "${commandName}" não encontrado ao registrar o módulo "${module.name}". Verifique se createCommand foi chamado antes de subcommand/group para esse comando.`);
       return;
+    }
     command.modules ??= [];
     command.modules.push(module);
   }
@@ -513,6 +525,10 @@ class CommandManager {
     const messages = [];
     const pluralize = (n) => n > 1 ? "s" : "";
     const commands = this.build();
+    const stripInternal = (cmd) => {
+      const { global: _global, category: _category, ...rest } = cmd;
+      return rest;
+    };
     const createVerboseLogs = (cmdsCollection) => cmdsCollection.map(({ id, name, type, client: cl, createdAt, guild }) => {
       const [icon] = this.getTitle({
         type
@@ -528,21 +544,26 @@ class CommandManager {
       }
     };
     const targetGuilds = client.guilds.cache.filter(({ id }) => this.config.guilds?.includes(id));
-    if (targetGuilds.size) {
-      const globalCommands = commands.filter((c) => c.global);
-      const guildCommands = commands.filter((c) => !c.global);
-      await client.application.commands.set(globalCommands).then((cmds) => {
-        if (!cmds.size)
-          return;
-        logRegistration(cmds, "globally");
-      });
-      for (const guild of targetGuilds.values()) {
-        const cmds = await guild.commands.set(guildCommands);
-        logRegistration(cmds, `in ${ck.underline(guild.name)} guild`);
+    try {
+      if (targetGuilds.size) {
+        const globalCommands = commands.filter((c) => c.global).map(stripInternal);
+        const guildCommands = commands.filter((c) => !c.global).map(stripInternal);
+        await client.application.commands.set(globalCommands).then((cmds) => {
+          if (!cmds.size)
+            return;
+          logRegistration(cmds, "globally");
+        });
+        for (const guild of targetGuilds.values()) {
+          const cmds = await guild.commands.set(guildCommands);
+          logRegistration(cmds, `in ${ck.underline(guild.name)} guild`);
+        }
+      } else {
+        await Promise.all(client.guilds.cache.map((guild) => guild.commands.set([])));
+        const globalCommands = commands.map(stripInternal);
+        await client.application.commands.set(globalCommands).then((cmds) => logRegistration(cmds, "globally"));
       }
-    } else {
-      await Promise.all(client.guilds.cache.map((guild) => guild.commands.set([])));
-      await client.application.commands.set(commands).then((cmds) => logRegistration(cmds, "globally"));
+    } catch (err) {
+      console.error("[EzziApp] Falha ao registrar comandos no Discord:", err);
     }
     const prefixCount = this.getPrefixCommandCount();
     if (prefixCount > 0 && this.config.prefix) {

package/dist/creators/setup.d.ts

@@ -1,6 +1,6 @@
 import { ApplicationCommandType, InteractionContextType, type CacheType, type ClientEvents, type PermissionResolvable } from "discord.js";
 import { type BaseCommandsConfig, type BaseEventsConfig, type BaseRespondersConfig } from "../app.js";
-import { type AppCommandData, type CommandType } from "./commands/command.js";
+import { Command, type AppCommandData, type CommandType } from "./commands/command.js";
 import { type EventData } from "./events/event.js";
 import { Responder, type ResponderData, type ResponderType } from "./responders/responder.js";
 export interface SetupCreatorsOptions {
@@ -11,15 +11,8 @@ export interface SetupCreatorsOptions {
     responders?: Partial<BaseRespondersConfig>;
     events?: Partial<BaseEventsConfig>;
 }
-/**
- * Initializes the Ezzi command/event/responder creation system.
- *
- * This function configures the Ezzi application’s internal registries
- * for commands, events, and responders, and returns a set of factory
- * functions used to create each type of component.
- */
 export declare function setupCreators(options?: SetupCreatorsOptions): {
-    createCommand<T extends CommandType = ApplicationCommandType.ChatInput, Contexts extends readonly InteractionContextType[] = readonly InteractionContextType[], R = void>(data: AppCommandData<T, Contexts, R>): any;
+    createCommand<T extends CommandType = ApplicationCommandType.ChatInput, const C extends readonly InteractionContextType[] = [InteractionContextType.Guild], R = void>(data: AppCommandData<T, C, R>): Command<T, C, R>;
     createEvent<EventName extends keyof ClientEvents>(data: EventData<EventName>): void;
     createResponder<Path extends string, const Types extends readonly ResponderType[], Schema, Cache extends CacheType = CacheType>(data: ResponderData<Path, Types, Schema, Cache>): Responder<string, readonly ResponderType[], unknown, CacheType>;
 };

package/dist/creators/setup.js

@@ -1,11 +1,10 @@
 // src/creators/setup.ts
-import {
-  ApplicationCommandOptionType,
-  ApplicationCommandType
-} from "discord.js";
 import {
   EzziApp
 } from "../app.js";
+import {
+  Command
+} from "./commands/command.js";
 import { Event } from "./events/event.js";
 import {
   Responder
@@ -24,46 +23,19 @@ function setupCreators(options = {}) {
   return {
     createCommand(data) {
       const currentApp = EzziApp.getInstance();
-      if (defaultMemberPerms) {
+      if (defaultMemberPerms)
         data.defaultMemberPermissions ??= defaultMemberPerms;
-      }
-      if (defaultBotPerms && !data.botPermissions?.length) {
+      if (defaultBotPerms && !data.botPermissions?.length)
         data.botPermissions = defaultBotPerms;
-      }
-      const resolved = currentApp.commands.set(data);
+      const command = new Command(data);
+      const resolved = currentApp.commands.set(command.data);
+      command.moduleListener = (module) => {
+        currentApp.commands.addModule(resolved.name, module);
+      };
       if (typeof currentApp.commands.addLog === "function") {
         currentApp.commands.addLog(resolved);
       }
-      if (resolved.type !== ApplicationCommandType.ChatInput) {
-        return resolved;
-      }
-      const commandName = resolved.name;
-      const createSubcommand = (group) => (subData) => {
-        const subApp = EzziApp.getInstance();
-        if (defaultBotPerms && !subData.botPermissions?.length) {
-          subData = { ...subData, botPermissions: defaultBotPerms };
-        }
-        subApp.commands.addModule(commandName, {
-          ...subData,
-          group,
-          type: ApplicationCommandOptionType.Subcommand
-        });
-      };
-      return Object.assign(data, {
-        ...resolved,
-        group(groupData) {
-          const groupApp = EzziApp.getInstance();
-          if (defaultBotPerms && !groupData.botPermissions?.length) {
-            groupData = { ...groupData, botPermissions: defaultBotPerms };
-          }
-          groupApp.commands.addModule(commandName, {
-            ...groupData,
-            type: ApplicationCommandOptionType.SubcommandGroup
-          });
-          return { subcommand: createSubcommand(groupData.name) };
-        },
-        subcommand: createSubcommand()
-      });
+      return command;
     },
     createEvent(data) {
       const currentApp = EzziApp.getInstance();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ezzi/base",
-  "version": "1.0.3",
+  "version": "2.0.0",
   "description": "Library with structures and functions for creating modern Discord applications.",
   "license": "MIT",
   "type": "module",