@ezzi/base 1.0.0

package/dist/creators/commands/manager.js

@@ -0,0 +1,560 @@
+// src/creators/commands/manager.ts
+import { isDefined, limitText, spaceBuilder } from "@magicyan/discord";
+import ck from "chalk";
+import {
+  ApplicationCommandOptionType,
+  ApplicationCommandType,
+  Collection,
+  GuildMember
+} from "discord.js";
+import {
+  IgnoreCommand
+} from "./command.js";
+import { CommandContext } from "./context.js";
+function resolveOptionValueType(type) {
+  switch (type) {
+    case ApplicationCommandOptionType.String:
+      return "text";
+    case ApplicationCommandOptionType.Number:
+      return "number";
+    case ApplicationCommandOptionType.Integer:
+      return "integer";
+    case ApplicationCommandOptionType.User:
+      return "user";
+    case ApplicationCommandOptionType.Role:
+      return "role";
+    case ApplicationCommandOptionType.Mentionable:
+      return "mentionable";
+    case ApplicationCommandOptionType.Channel:
+      return "channel";
+    case ApplicationCommandOptionType.Attachment:
+      return "attachment";
+    case ApplicationCommandOptionType.Boolean:
+      return "boolean";
+    default:
+      return "text";
+  }
+}
+function resolveMissingPermissions(member, required) {
+  if (!member || !required.length)
+    return [];
+  return required.filter((perm) => !member.permissions.has(perm));
+}
+
+class CommandManager {
+  app;
+  constructor(app) {
+    this.app = app;
+  }
+  get config() {
+    return this.app.config.commands;
+  }
+  collection = new Collection;
+  runtimeCollection = new Collection;
+  aliasCollection = new Collection;
+  commandRunners = new Collection;
+  autocompleteRunners = new Collection;
+  optionDefs = new Collection;
+  shortcuts = new Collection;
+  botPermissionsMap = new Collection;
+  logs = [];
+  formatName(name, type = ApplicationCommandType.ChatInput) {
+    return limitText(type === ApplicationCommandType.ChatInput ? name.toLowerCase().replaceAll(" ", "") : name, 32);
+  }
+  clear() {
+    this.runtimeCollection = new Collection(this.collection);
+    for (const [k, v] of this.aliasCollection) {
+      this.runtimeCollection.set(k, v);
+    }
+    this.collection.clear();
+    this.aliasCollection.clear();
+  }
+  getAutocompleteHandler(...path) {
+    const commandName = path[0];
+    const type = ApplicationCommandType.ChatInput;
+    const resolved = `/${type}/${path.filter(isDefined).join("/")}`;
+    return this.autocompleteRunners.get(resolved) ?? this.autocompleteRunners.get(`/${type}/${commandName}`);
+  }
+  getHandler(type, ...path) {
+    const commandName = path[0];
+    const resolved = `/${type}/${path.filter(isDefined).join("/")}`;
+    return this.commandRunners.get(resolved) ?? this.commandRunners.get(`/${type}/${commandName}`);
+  }
+  getBotPermissions(path) {
+    return this.botPermissionsMap.get(path);
+  }
+  resolveBotPermissions(commandName, subcommandGroup, subcommand) {
+    const type = ApplicationCommandType.ChatInput;
+    const parts = [commandName, subcommandGroup, subcommand].filter(isDefined);
+    const specificPath = `/${type}/${parts.join("/")}`;
+    const basePath = `/${type}/${commandName}`;
+    return this.botPermissionsMap.get(specificPath) ?? this.botPermissionsMap.get(basePath);
+  }
+  resolvePrefixCommand(commandName, args, resolvedCommandData) {
+    const type = ApplicationCommandType.ChatInput;
+    const shortcutPath = this.shortcuts.get(commandName);
+    if (shortcutPath) {
+      const runners2 = this.commandRunners.get(shortcutPath);
+      const defs2 = this.optionDefs.get(shortcutPath) ?? [];
+      const botPermissions2 = this.botPermissionsMap.get(shortcutPath);
+      if (runners2)
+        return { runners: runners2, optionDefs: defs2, botPermissions: botPermissions2 };
+    }
+    const rawCommand = resolvedCommandData ?? this.runtimeCollection.get(commandName) ?? this.collection.get(commandName) ?? this.aliasCollection.get(commandName);
+    if (!rawCommand)
+      return;
+    const path = [rawCommand.name];
+    if (rawCommand.modules && rawCommand.modules.length > 0) {
+      const nextArg = args[0]?.toLowerCase();
+      if (nextArg) {
+        const foundModule = rawCommand.modules.find((m) => m.name.toLowerCase() === nextArg || m.aliases?.some((a) => a.toLowerCase() === nextArg));
+        if (foundModule) {
+          args.shift();
+          path.push(foundModule.name);
+          if (foundModule.type === ApplicationCommandOptionType.SubcommandGroup) {
+            const subArg = args[0]?.toLowerCase();
+            if (subArg) {
+              const foundSub = rawCommand.modules.find((m) => m.type === ApplicationCommandOptionType.Subcommand && m.group === foundModule.name && (m.name.toLowerCase() === subArg || m.aliases?.some((a) => a.toLowerCase() === subArg)));
+              if (foundSub) {
+                args.shift();
+                path.push(foundSub.name);
+              }
+            }
+          }
+        }
+      }
+    }
+    const resolved = `/${type}/${path.join("/")}`;
+    const runners = this.commandRunners.get(resolved);
+    if (!runners)
+      return;
+    const defs = this.optionDefs.get(resolved) ?? [];
+    const botPermissions = this.botPermissionsMap.get(resolved);
+    return { runners, optionDefs: defs, botPermissions };
+  }
+  getTitle(data) {
+    const type = data.type ?? ApplicationCommandType.ChatInput;
+    if (type === ApplicationCommandType.User) {
+      return ["{☰}", "User context menu"];
+    }
+    if (type === ApplicationCommandType.Message) {
+      return ["{☰}", "Message context menu"];
+    }
+    const ignoreValue = data.ignore;
+    if (ignoreValue === IgnoreCommand.Slash) {
+      return ["{~}", "Prefix command"];
+    }
+    if (ignoreValue === IgnoreCommand.Message) {
+      return ["{/}", "Slash command"];
+    }
+    return ["{☰}", "Hybrid command"];
+  }
+  buildOptions(options, path) {
+    const resolved = [];
+    for (const option of options) {
+      const description = option.description ?? option.name;
+      if ("autocomplete" in option && option.autocomplete && typeof option.autocomplete === "function") {
+        this.autocompleteRunners.set(`${path}/${option.name}`, option.autocomplete);
+      }
+      switch (option.type) {
+        case ApplicationCommandOptionType.SubcommandGroup: {
+          const {
+            options: subcommands,
+            defaultMemberPermissions,
+            botPermissions,
+            ...data
+          } = option;
+          if (botPermissions?.length) {
+            this.botPermissionsMap.set(`${path}/${data.name}`, botPermissions);
+          }
+          resolved.push({
+            ...data,
+            description,
+            ...defaultMemberPermissions !== undefined ? { defaultMemberPermissions } : {},
+            options: this.buildOptions(subcommands, `${path}/${data.name}`)
+          });
+          continue;
+        }
+        case ApplicationCommandOptionType.Subcommand: {
+          const {
+            options: subOpts,
+            defaultMemberPermissions,
+            botPermissions,
+            ...data
+          } = option;
+          if (botPermissions?.length) {
+            this.botPermissionsMap.set(`${path}/${data.name}`, botPermissions);
+          }
+          resolved.push({
+            ...data,
+            description,
+            ...defaultMemberPermissions !== undefined ? { defaultMemberPermissions } : {},
+            ...subOpts?.length ? {
+              options: this.buildOptions(subOpts, `${path}/${data.name}`)
+            } : {}
+          });
+          continue;
+        }
+        case ApplicationCommandOptionType.String:
+        case ApplicationCommandOptionType.Integer:
+        case ApplicationCommandOptionType.Number: {
+          const { choices, autocomplete, ...data } = option;
+          const validation = data.type === ApplicationCommandOptionType.String ? { minLength: data.minLength, maxLength: data.maxLength } : { minValue: data.minValue, maxValue: data.maxValue };
+          const extra = autocomplete ? { autocomplete: true, ...validation } : choices?.length ? { choices: choices.slice(0, 25) } : validation;
+          resolved.push(Object.assign({ ...data, description, ...extra }));
+          continue;
+        }
+        default: {
+          resolved.push({ ...option, description });
+        }
+      }
+    }
+    return resolved;
+  }
+  resolveModules(modules, path, parentRun) {
+    const resolved = [];
+    if (!modules.length)
+      return resolved;
+    const groups = modules.filter((m) => m.type === ApplicationCommandOptionType.SubcommandGroup);
+    const subcommands = modules.filter((m) => m.type === ApplicationCommandOptionType.Subcommand);
+    for (const group of groups) {
+      const groupSubs = subcommands.filter((s) => s.group === group.name);
+      const slashSubs = groupSubs.filter((s) => s.ignore !== IgnoreCommand.Slash);
+      const mappedSubs = slashSubs.map((sub) => ({
+        ...sub,
+        type: ApplicationCommandOptionType.Subcommand
+      }));
+      resolved.push({ ...group, options: mappedSubs });
+      if (group.botPermissions?.length) {
+        this.botPermissionsMap.set(`${path}/${group.name}`, group.botPermissions);
+      }
+      for (const sub of groupSubs) {
+        if (sub.ignore === IgnoreCommand.Slash)
+          continue;
+        const subPath = `${path}/${group.name}/${sub.name}`;
+        this.commandRunners.set(subPath, [parentRun, group.run, sub.run].filter(isDefined));
+        if (sub.options?.length) {
+          this.optionDefs.set(subPath, sub.options);
+        }
+        if (sub.botPermissions?.length) {
+          this.botPermissionsMap.set(subPath, sub.botPermissions);
+        }
+        if (sub.shortcut) {
+          this.shortcuts.set(sub.name, subPath);
+          for (const alias of sub.aliases ?? []) {
+            this.shortcuts.set(alias, subPath);
+          }
+        }
+      }
+    }
+    for (const sub of subcommands.filter((s) => !s.group)) {
+      if (sub.ignore === IgnoreCommand.Slash)
+        continue;
+      const subPath = `${path}/${sub.name}`;
+      this.commandRunners.set(subPath, [parentRun, sub.run].filter(isDefined));
+      if (sub.options?.length) {
+        this.optionDefs.set(subPath, sub.options);
+      }
+      if (sub.botPermissions?.length) {
+        this.botPermissionsMap.set(subPath, sub.botPermissions);
+      }
+      if (sub.shortcut) {
+        this.shortcuts.set(sub.name, subPath);
+        for (const alias of sub.aliases ?? []) {
+          this.shortcuts.set(alias, subPath);
+        }
+      }
+      resolved.push(sub);
+    }
+    return resolved;
+  }
+  set(data) {
+    const type = data.type ?? ApplicationCommandType.ChatInput;
+    const name = this.formatName(data.name, type);
+    const dmPermission = data.dmPermission ?? false;
+    const commandData = {
+      ...data,
+      name,
+      type,
+      dmPermission
+    };
+    if (this.collection.has(name)) {
+      const existing = this.collection.get(name);
+      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) {
+          this.aliasCollection.delete(this.formatName(alias, type));
+        }
+      }
+    }
+    this.collection.set(name, commandData);
+    const canonicalPath = `/${type}/${name}`;
+    this.commandRunners.set(canonicalPath, [data.run]);
+    if (data.botPermissions?.length) {
+      this.botPermissionsMap.set(canonicalPath, data.botPermissions);
+    }
+    if (data.aliases?.length) {
+      for (const alias of data.aliases) {
+        const aliasName = this.formatName(alias, type);
+        this.aliasCollection.set(aliasName, commandData);
+      }
+    }
+    if (data.options?.length) {
+      const primitive = data.options.filter((o) => o.type !== ApplicationCommandOptionType.Subcommand && o.type !== ApplicationCommandOptionType.SubcommandGroup);
+      if (primitive.length) {
+        this.optionDefs.set(canonicalPath, primitive);
+      }
+    }
+    if ("autocomplete" in data && data.autocomplete) {
+      this.autocompleteRunners.set(canonicalPath, data.autocomplete);
+    }
+    return commandData;
+  }
+  build() {
+    const result = Array.from(this.collection.values()).filter((raw) => raw.ignore !== IgnoreCommand.Slash).map((raw) => {
+      const {
+        options,
+        modules,
+        description,
+        descriptionLocalizations,
+        category,
+        botPermissions: _bp,
+        ...data
+      } = raw;
+      const path = `/${data.type}/${data.name}`;
+      const slashData = data.type === ApplicationCommandType.ChatInput ? {
+        description: description ?? data.name,
+        descriptionLocalizations,
+        options: this.buildOptions([
+          ...options ?? [],
+          ...this.resolveModules(modules ?? [], path, data.run)
+        ], path)
+      } : {};
+      return { ...data, ...slashData, category };
+    });
+    return result;
+  }
+  addLog(data) {
+    const [icon, label] = this.getTitle(data);
+    this.logs.push(ck.green(spaceBuilder(ck.gray(icon), ck.green(`${label}`), ck.gray(">"), ck.underline.blue(data.name), ck.bold("✓"))));
+  }
+  addModule(commandName, module) {
+    const command = this.collection.get(commandName);
+    if (!command)
+      return;
+    command.modules ??= [];
+    command.modules.push(module);
+  }
+  getPrefixCommandCount() {
+    return Array.from(this.runtimeCollection.values()).filter((cmd) => cmd.ignore !== IgnoreCommand.Slash).length;
+  }
+  async onAutocomplete(interaction) {
+    const options = interaction.options;
+    const handler = this.getAutocompleteHandler(interaction.commandName, options.getSubcommandGroup(false), options.getSubcommand(false), options.getFocused(true).name);
+    if (!handler)
+      return;
+    const choices = await handler(interaction);
+    if (choices && Array.isArray(choices)) {
+      await interaction.respond(choices.slice(0, 25));
+    }
+  }
+  async onPrefixCommand(message) {
+    if (message.author.bot)
+      return;
+    if (!this.config.prefix)
+      return;
+    const prefixes = await this.config.prefix(message);
+    const prefix = prefixes.find((p) => message.content.toLowerCase().startsWith(p.toLowerCase()));
+    if (!prefix)
+      return;
+    const rawArgs = message.content.slice(prefix.length).trim().split(/ +/);
+    const commandName = rawArgs.shift()?.toLowerCase();
+    if (!commandName)
+      return;
+    const rawCommandData = this.runtimeCollection.get(commandName) ?? this.collection.get(commandName) ?? this.aliasCollection.get(commandName);
+    if (rawCommandData?.ignore === IgnoreCommand.Message)
+      return;
+    const args = [...rawArgs];
+    const resolved = this.resolvePrefixCommand(commandName, args, rawCommandData);
+    if (!resolved)
+      return;
+    const { runners, optionDefs, botPermissions } = resolved;
+    const ctx = new CommandContext(message.client, message, args, optionDefs);
+    const {
+      middleware,
+      onMemberPermissionsFailed,
+      onBotPermissionsFailed,
+      onOptionsError,
+      onError
+    } = this.config;
+    if (middleware) {
+      let isBlock = false;
+      const block = () => {
+        isBlock = true;
+      };
+      await middleware(ctx, block);
+      if (isBlock)
+        return;
+    }
+    if (onMemberPermissionsFailed && rawCommandData?.defaultMemberPermissions) {
+      const perms = Array.isArray(rawCommandData.defaultMemberPermissions) ? rawCommandData.defaultMemberPermissions : [rawCommandData.defaultMemberPermissions];
+      const missing = resolveMissingPermissions(message.member, perms);
+      if (missing.length) {
+        onMemberPermissionsFailed(ctx, missing);
+        return;
+      }
+    }
+    if (onBotPermissionsFailed && botPermissions?.length) {
+      const botMember = message.guild?.members.me ?? null;
+      const missing = resolveMissingPermissions(botMember, botPermissions);
+      if (missing.length) {
+        onBotPermissionsFailed(ctx, missing);
+        return;
+      }
+    }
+    if (onOptionsError && optionDefs.length) {
+      const missing = optionDefs.filter((def) => def.required && args[optionDefs.indexOf(def)] === undefined).map((def) => ({
+        name: def.name,
+        description: def.description ?? def.name,
+        value: resolveOptionValueType(def.type)
+      }));
+      if (missing.length > 0) {
+        onOptionsError(message, missing);
+        return;
+      }
+    }
+    try {
+      let result;
+      for (const run of runners.filter(isDefined)) {
+        result = await run(ctx, result);
+      }
+    } catch (err) {
+      if (onError) {
+        console.error(`Error in prefix command [${commandName}]:`, err);
+        onError(ctx, err);
+      } else {
+        throw err;
+      }
+    }
+  }
+  async onCommand(interaction) {
+    if (interaction.isPrimaryEntryPointCommand())
+      return;
+    const {
+      onNotFound,
+      middleware,
+      onError,
+      onMemberPermissionsFailed,
+      onBotPermissionsFailed
+    } = this.config;
+    const path = [interaction.commandName];
+    let subcommandGroup = null;
+    let subcommand = null;
+    if (interaction.isChatInputCommand()) {
+      subcommandGroup = interaction.options.getSubcommandGroup(false);
+      subcommand = interaction.options.getSubcommand(false);
+      path.push(subcommandGroup, subcommand);
+    }
+    const handler = this.getHandler(interaction.commandType, ...path);
+    if (!handler) {
+      return onNotFound?.(interaction);
+    }
+    const rawCommandData = this.runtimeCollection.get(interaction.commandName) ?? this.collection.get(interaction.commandName);
+    if (rawCommandData?.ignore === IgnoreCommand.Slash) {
+      return onNotFound?.(interaction);
+    }
+    const ctx = new CommandContext(interaction.client, interaction, []);
+    if (middleware) {
+      let isBlock = false;
+      const block = () => {
+        isBlock = true;
+      };
+      await middleware(ctx, block);
+      if (isBlock)
+        return;
+    }
+    if (onMemberPermissionsFailed && rawCommandData?.defaultMemberPermissions) {
+      const perms = Array.isArray(rawCommandData.defaultMemberPermissions) ? rawCommandData.defaultMemberPermissions : [rawCommandData.defaultMemberPermissions];
+      const missing = resolveMissingPermissions(interaction.member instanceof GuildMember ? interaction.member : null, perms);
+      if (missing.length) {
+        onMemberPermissionsFailed(ctx, missing);
+        return;
+      }
+    }
+    if (onBotPermissionsFailed) {
+      const botPermissions = this.resolveBotPermissions(interaction.commandName, subcommandGroup, subcommand);
+      if (botPermissions?.length) {
+        const botMember = interaction.guild?.members.me ?? null;
+        const missing = resolveMissingPermissions(botMember, botPermissions);
+        if (missing.length) {
+          onBotPermissionsFailed(ctx, missing);
+          return;
+        }
+      }
+    }
+    try {
+      let result;
+      for (const run of handler.filter(isDefined)) {
+        result = await run(ctx, result);
+      }
+    } catch (err) {
+      if (onError) {
+        onError(ctx, err);
+        return;
+      }
+      throw err;
+    }
+  }
+  async register(client) {
+    const messages = [];
+    const pluralize = (n) => n > 1 ? "s" : "";
+    const commands = this.build();
+    const createVerboseLogs = (cmdsCollection) => cmdsCollection.map(({ id, name, type, client: cl, createdAt, guild }) => {
+      const [icon] = this.getTitle({
+        type
+      });
+      return ck.dim.green(spaceBuilder(` └ ${icon}`, ck.underline.cyan(id), "CREATED", ck.underline.blue(name), ck.gray(">"), guild ? `${ck.blue(guild.name)} guild` : `${ck.blue(cl.user.username)} application`, ck.gray(">"), "created at:", ck.greenBright(createdAt.toLocaleTimeString())));
+    });
+    const logRegistration = (cmdsCollection, location) => {
+      if (!cmdsCollection.size)
+        return;
+      messages.push(ck.greenBright(`└ ${cmdsCollection.size} command${pluralize(cmdsCollection.size)} successfully registered ${location}!`));
+      if (this.config.verbose) {
+        messages.push(...createVerboseLogs(cmdsCollection));
+      }
+    };
+    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`);
+      }
+    } else {
+      await Promise.all(client.guilds.cache.map((guild) => guild.commands.set([])));
+      await client.application.commands.set(commands).then((cmds) => logRegistration(cmds, "globally"));
+    }
+    const prefixCount = this.getPrefixCommandCount();
+    if (prefixCount > 0 && this.config.prefix) {
+      messages.push(ck.greenBright(`└ ${prefixCount} prefix command${pluralize(prefixCount)} available!`));
+    }
+    this.clear();
+    if (messages.length) {
+      console.log(messages.join(`
+`));
+    }
+  }
+}
+export {
+  CommandManager
+};

package/dist/creators/events/event.d.ts

@@ -0,0 +1,21 @@
+import type { ClientEvents } from "discord.js";
+export type ClientEventKey = keyof ClientEvents;
+export type EventPropData = {
+    [Key in ClientEventKey]: {
+        name: Key;
+        args: ClientEvents[Key];
+    };
+}[ClientEventKey];
+export interface EventData<EventName extends ClientEventKey> {
+    name: string;
+    event: EventName;
+    once?: boolean;
+    tags?: string[];
+    run(this: void, ...args: ClientEvents[EventName]): Promise<void>;
+}
+export declare class Event<EventName extends ClientEventKey> {
+    readonly data: EventData<EventName>;
+    constructor(data: EventData<EventName>);
+}
+export type GenericEventArgs = ClientEvents[ClientEventKey];
+export type EventsCollection = Map<string, Event<ClientEventKey>>;

package/dist/creators/events/event.js

@@ -0,0 +1,10 @@
+// src/creators/events/event.ts
+class Event {
+  data;
+  constructor(data) {
+    this.data = data;
+  }
+}
+export {
+  Event
+};

package/dist/creators/events/manager.d.ts

@@ -0,0 +1,12 @@
+import { Client, Collection, type ClientEvents } from "discord.js";
+import { BaseManager } from "../manager.js";
+import type { ClientEventKey, Event, EventsCollection, GenericEventArgs } from "./event.js";
+export declare class EventManager extends BaseManager {
+    private get config();
+    readonly collection: Collection<keyof ClientEvents, EventsCollection>;
+    getEvents(key: ClientEventKey): EventsCollection;
+    add(event: Event<ClientEventKey>): void;
+    onEvent(event: Event<ClientEventKey>, args: GenericEventArgs): Promise<void>;
+    register(client: Client): void;
+    runReady(client: Client<true>): Promise<void>;
+}

package/dist/creators/events/manager.js

@@ -0,0 +1,71 @@
+// src/creators/events/manager.ts
+import { Collection } from "discord.js";
+import { styleText } from "node:util";
+import { BaseManager } from "../manager.js";
+
+class EventManager extends BaseManager {
+  get config() {
+    return this.app.config.events;
+  }
+  collection = new Collection;
+  getEvents(key) {
+    if (!this.collection.has(key)) {
+      this.collection.set(key, new Map);
+    }
+    return this.collection.get(key);
+  }
+  add(event) {
+    const events = this.getEvents(event.data.event);
+    events.set(event.data.name, event);
+    this.logs.push([
+      styleText("yellow", `✦ Event`),
+      styleText("gray", `>`),
+      styleText(["yellow"], event.data.event),
+      styleText("gray", `>`),
+      styleText(["blue", "underline"], event.data.name),
+      styleText("green", "✓")
+    ].join(" "));
+  }
+  async onEvent(event, args) {
+    const { middleware, onError } = this.config;
+    let isBlock = false;
+    const block = (...selected) => {
+      const tags = event.data.tags ?? [];
+      if (selected.length === 0) {
+        isBlock = tags.length === 0;
+        return;
+      }
+      isBlock = selected.some((tag) => tags.includes(tag));
+    };
+    const eventData = { name: event.data.name, args };
+    if (middleware)
+      await middleware(eventData, block);
+    if (isBlock)
+      return;
+    await event.data.run(...args).catch((err) => {
+      if (onError) {
+        onError(err, eventData);
+        return;
+      }
+      throw err;
+    });
+    if (event.data.once) {
+      this.getEvents(event.data.event)?.delete(event.data.name);
+    }
+  }
+  register(client) {
+    const collection = this.collection.filter((_, key) => key !== "clientReady" && key !== "messageCreate");
+    for (const [key, events] of collection.entries()) {
+      client.on(key, (...args) => {
+        Promise.all(Array.from(events.values()).map((event) => this.onEvent(event, args)));
+      });
+    }
+  }
+  async runReady(client) {
+    const collection = this.getEvents("clientReady");
+    await Promise.all(Array.from(collection.values()).map((event) => this.onEvent(event, [client])));
+  }
+}
+export {
+  EventManager
+};

package/dist/creators/index.d.ts

@@ -0,0 +1,5 @@
+export { ResponderType, type Responder, type ResponderData, type ResponderInteraction } from "./responders/responder.js";
+export { emitResponder } from "./responders/emit.js";
+export { type Command, type AppCommandData } from "./commands/command.js";
+export { type Event, type EventData, type EventPropData } from "./events/event.js";
+export * from "./setup.js";

package/dist/creators/index.js

@@ -0,0 +1,11 @@
+// src/creators/index.ts
+import {
+  ResponderType
+} from "./responders/responder.js";
+import { emitResponder } from "./responders/emit.js";
+
+export * from "./setup.js";
+export {
+  emitResponder,
+  ResponderType
+};