spearkit 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1242 @@
+'use strict';
+
+var discord_js = require('discord.js');
+var promises = require('fs/promises');
+var path = require('path');
+var url = require('url');
+
+// src/index.ts
+function withEphemeralFlag(flags) {
+  if (flags == null) return discord_js.MessageFlags.Ephemeral;
+  if (typeof flags === "number" || typeof flags === "bigint") {
+    return Number(flags) | discord_js.MessageFlags.Ephemeral;
+  }
+  if (Array.isArray(flags)) return [...flags, discord_js.MessageFlags.Ephemeral];
+  return [flags, discord_js.MessageFlags.Ephemeral];
+}
+function normalizeReply(input) {
+  if (typeof input === "string") return { content: input };
+  const { ephemeral, ...rest } = input;
+  if (ephemeral) return { ...rest, flags: withEphemeralFlag(rest.flags) };
+  return rest;
+}
+function normalizeEdit(input) {
+  if (typeof input === "string") return { content: input };
+  const { ephemeral: _ephemeral, flags: _flags, ...rest } = input;
+  return rest;
+}
+function asEphemeral(input) {
+  if (typeof input === "string") return { content: input, ephemeral: true };
+  return { ...input, ephemeral: true };
+}
+var BaseContext = class {
+  constructor(interaction) {
+    this.interaction = interaction;
+  }
+  interaction;
+  get client() {
+    return this.interaction.client;
+  }
+  get user() {
+    return this.interaction.user;
+  }
+  get member() {
+    return this.interaction.member;
+  }
+  get guild() {
+    return this.interaction.guild;
+  }
+  get guildId() {
+    return this.interaction.guildId;
+  }
+  get channel() {
+    return this.interaction.channel;
+  }
+  get channelId() {
+    return this.interaction.channelId;
+  }
+  get locale() {
+    return this.interaction.locale;
+  }
+  /** Whether the interaction is already deferred. */
+  get deferred() {
+    return this.interaction.deferred;
+  }
+  /** Whether the interaction already received an initial response. */
+  get replied() {
+    return this.interaction.replied;
+  }
+  /** Send the initial response to the interaction. */
+  reply(input) {
+    return this.interaction.reply(normalizeReply(input));
+  }
+  /** Reply, but always hidden to everyone except the invoking user. */
+  replyEphemeral(input) {
+    return this.reply(asEphemeral(input));
+  }
+  /** Acknowledge now and respond later via {@link editReply}. */
+  defer(options = {}) {
+    return this.interaction.deferReply(
+      options.ephemeral ? { flags: discord_js.MessageFlags.Ephemeral } : {}
+    );
+  }
+  /** Edit the original (or deferred) response. */
+  editReply(input) {
+    return this.interaction.editReply(normalizeEdit(input));
+  }
+  /** Add an additional message after the initial response. */
+  followUp(input) {
+    return this.interaction.followUp(normalizeReply(input));
+  }
+  /**
+   * State-aware send: replies, edits a deferred response, or follows up —
+   * whichever is valid given the current interaction state. The single method
+   * most handlers ever need.
+   */
+  async send(input) {
+    if (this.interaction.deferred) {
+      await this.editReply(input);
+    } else if (this.interaction.replied) {
+      await this.followUp(input);
+    } else {
+      await this.reply(input);
+    }
+  }
+  /** State-aware ephemeral error message. */
+  error(message) {
+    return this.send(asEphemeral(message));
+  }
+};
+function makeOption(type, config) {
+  return { type, ...config, required: config.required ?? false };
+}
+var option = {
+  string(config) {
+    return makeOption(discord_js.ApplicationCommandOptionType.String, config);
+  },
+  integer(config) {
+    return makeOption(discord_js.ApplicationCommandOptionType.Integer, config);
+  },
+  number(config) {
+    return makeOption(discord_js.ApplicationCommandOptionType.Number, config);
+  },
+  boolean(config) {
+    return makeOption(discord_js.ApplicationCommandOptionType.Boolean, config);
+  },
+  user(config) {
+    return makeOption(discord_js.ApplicationCommandOptionType.User, config);
+  },
+  channel(config) {
+    return makeOption(discord_js.ApplicationCommandOptionType.Channel, config);
+  },
+  role(config) {
+    return makeOption(discord_js.ApplicationCommandOptionType.Role, config);
+  },
+  mentionable(config) {
+    return makeOption(discord_js.ApplicationCommandOptionType.Mentionable, config);
+  },
+  attachment(config) {
+    return makeOption(discord_js.ApplicationCommandOptionType.Attachment, config);
+  }
+};
+function mapChoices(choices) {
+  return choices?.map((c) => ({
+    name: c.name,
+    value: c.value,
+    name_localizations: c.nameLocalizations
+  }));
+}
+function toAPIOption(name, def) {
+  const shared = {
+    name,
+    description: def.description,
+    required: def.required,
+    name_localizations: def.nameLocalizations,
+    description_localizations: def.descriptionLocalizations
+  };
+  switch (def.type) {
+    case discord_js.ApplicationCommandOptionType.String: {
+      const base = { ...shared, min_length: def.minLength, max_length: def.maxLength };
+      return def.autocomplete !== void 0 ? { ...base, type: discord_js.ApplicationCommandOptionType.String, autocomplete: true } : { ...base, type: discord_js.ApplicationCommandOptionType.String, choices: mapChoices(def.choices) };
+    }
+    case discord_js.ApplicationCommandOptionType.Integer: {
+      const base = { ...shared, min_value: def.minValue, max_value: def.maxValue };
+      return def.autocomplete !== void 0 ? { ...base, type: discord_js.ApplicationCommandOptionType.Integer, autocomplete: true } : { ...base, type: discord_js.ApplicationCommandOptionType.Integer, choices: mapChoices(def.choices) };
+    }
+    case discord_js.ApplicationCommandOptionType.Number: {
+      const base = { ...shared, min_value: def.minValue, max_value: def.maxValue };
+      return def.autocomplete !== void 0 ? { ...base, type: discord_js.ApplicationCommandOptionType.Number, autocomplete: true } : { ...base, type: discord_js.ApplicationCommandOptionType.Number, choices: mapChoices(def.choices) };
+    }
+    case discord_js.ApplicationCommandOptionType.Channel:
+      return {
+        ...shared,
+        type: discord_js.ApplicationCommandOptionType.Channel,
+        channel_types: def.channelTypes ? [...def.channelTypes] : void 0
+      };
+    case discord_js.ApplicationCommandOptionType.User:
+      return { ...shared, type: discord_js.ApplicationCommandOptionType.User };
+    case discord_js.ApplicationCommandOptionType.Boolean:
+      return { ...shared, type: discord_js.ApplicationCommandOptionType.Boolean };
+    case discord_js.ApplicationCommandOptionType.Role:
+      return { ...shared, type: discord_js.ApplicationCommandOptionType.Role };
+    case discord_js.ApplicationCommandOptionType.Mentionable:
+      return { ...shared, type: discord_js.ApplicationCommandOptionType.Mentionable };
+    case discord_js.ApplicationCommandOptionType.Attachment:
+      return { ...shared, type: discord_js.ApplicationCommandOptionType.Attachment };
+    default:
+      return { ...shared, type: discord_js.ApplicationCommandOptionType.String };
+  }
+}
+function readOption(resolver, name, def) {
+  switch (def.type) {
+    case discord_js.ApplicationCommandOptionType.String:
+      return resolver.getString(name) ?? void 0;
+    case discord_js.ApplicationCommandOptionType.Integer:
+      return resolver.getInteger(name) ?? void 0;
+    case discord_js.ApplicationCommandOptionType.Number:
+      return resolver.getNumber(name) ?? void 0;
+    case discord_js.ApplicationCommandOptionType.Boolean:
+      return resolver.getBoolean(name) ?? void 0;
+    case discord_js.ApplicationCommandOptionType.User:
+      return resolver.getUser(name) ?? void 0;
+    case discord_js.ApplicationCommandOptionType.Channel:
+      return resolver.getChannel(name) ?? void 0;
+    case discord_js.ApplicationCommandOptionType.Role:
+      return resolver.getRole(name) ?? void 0;
+    case discord_js.ApplicationCommandOptionType.Mentionable:
+      return resolver.getMentionable(name) ?? void 0;
+    case discord_js.ApplicationCommandOptionType.Attachment:
+      return resolver.getAttachment(name) ?? void 0;
+    default:
+      return void 0;
+  }
+}
+function optionsHaveAutocomplete(options) {
+  for (const def of Object.values(options)) {
+    if (def.autocomplete !== void 0) return true;
+  }
+  return false;
+}
+
+// src/commands/context.ts
+var CommandContext = class extends BaseContext {
+  constructor(interaction, options) {
+    super(interaction);
+    this.options = options;
+  }
+  options;
+  get commandName() {
+    return this.interaction.commandName;
+  }
+  /** The invoked subcommand name, if any. */
+  get subcommand() {
+    return this.interaction.options.getSubcommand(false);
+  }
+  /** Present a modal to the user in response to this command. */
+  async showModal(modal2) {
+    await this.interaction.showModal(modal2);
+  }
+};
+var AutocompleteContext = class {
+  constructor(interaction) {
+    this.interaction = interaction;
+  }
+  interaction;
+  get client() {
+    return this.interaction.client;
+  }
+  get user() {
+    return this.interaction.user;
+  }
+  get guild() {
+    return this.interaction.guild;
+  }
+  get guildId() {
+    return this.interaction.guildId;
+  }
+  get commandName() {
+    return this.interaction.commandName;
+  }
+  /** Name of the option currently being completed. */
+  get focusedName() {
+    return this.interaction.options.getFocused(true).name;
+  }
+  /** Current partial value typed by the user. */
+  get value() {
+    return this.interaction.options.getFocused();
+  }
+  /** Send autocomplete suggestions (capped at the discord limit of 25). */
+  respond(choices) {
+    return this.interaction.respond(
+      choices.slice(0, 25).map((c) => ({
+        name: c.name,
+        value: c.value,
+        name_localizations: c.nameLocalizations
+      }))
+    );
+  }
+};
+
+// src/commands/command.ts
+var SlashCommand = class {
+  /** The top-level command name (used as the registry lookup key). */
+  name;
+  /** Whether any option declares an autocomplete handler. */
+  hasAutocomplete;
+  json;
+  executor;
+  autocompleter;
+  /** @internal */
+  constructor(spec) {
+    this.name = spec.name;
+    this.hasAutocomplete = spec.hasAutocomplete;
+    this.json = spec.json;
+    this.executor = spec.executor;
+    this.autocompleter = spec.autocompleter;
+  }
+  /** Serialise to the discord REST chat-input command payload. */
+  toJSON() {
+    return this.json;
+  }
+  /** Execute the command for an incoming chat-input interaction. */
+  execute(interaction) {
+    return this.executor(interaction);
+  }
+  /** Execute autocomplete for the focused option. */
+  autocomplete(interaction) {
+    return this.autocompleter(interaction);
+  }
+};
+function resolveOptions(interaction, options) {
+  const resolved = {};
+  for (const [name, def] of Object.entries(options)) {
+    resolved[name] = readOption(interaction.options, name, def);
+  }
+  return resolved;
+}
+function makeAutocompleter(options) {
+  return async (interaction) => {
+    const focused = interaction.options.getFocused(true);
+    const def = options[focused.name];
+    if (def?.autocomplete === void 0) {
+      if (!interaction.responded) await interaction.respond([]);
+      return;
+    }
+    const ctx = new AutocompleteContext(interaction);
+    const choices = await def.autocomplete(ctx);
+    if (!interaction.responded) await ctx.respond(choices);
+  };
+}
+function baseJSON(meta, options) {
+  return {
+    type: discord_js.ApplicationCommandType.ChatInput,
+    name: meta.name,
+    description: meta.description,
+    name_localizations: meta.nameLocalizations,
+    description_localizations: meta.descriptionLocalizations,
+    nsfw: meta.nsfw,
+    default_member_permissions: meta.defaultMemberPermissions == null ? meta.defaultMemberPermissions : new discord_js.PermissionsBitField(meta.defaultMemberPermissions).bitfield.toString(),
+    contexts: meta.guildOnly ? [discord_js.InteractionContextType.Guild] : void 0,
+    options
+  };
+}
+function leafOptionsJSON(options) {
+  return Object.entries(options).map(([name, def]) => toAPIOption(name, def));
+}
+function subcommandJSON(name, sub) {
+  return {
+    type: discord_js.ApplicationCommandOptionType.Subcommand,
+    name,
+    description: sub.description,
+    name_localizations: sub.nameLocalizations,
+    description_localizations: sub.descriptionLocalizations,
+    options: Object.entries(sub.options).map(([n, def]) => toAPIOption(n, def))
+  };
+}
+function routeSubcommand(groupName, subName, subcommands, groups) {
+  if (groupName !== null) return groups?.[groupName]?.subcommands[subName ?? ""];
+  if (subName !== null) return subcommands?.[subName];
+  return void 0;
+}
+function command(config) {
+  const options = config.options ?? {};
+  const { run } = config;
+  const executor = async (interaction) => {
+    const resolved = resolveOptions(interaction, options);
+    await run(new CommandContext(interaction, resolved));
+  };
+  return new SlashCommand({
+    name: config.name,
+    json: baseJSON(config, leafOptionsJSON(options)),
+    hasAutocomplete: optionsHaveAutocomplete(options),
+    executor,
+    autocompleter: makeAutocompleter(options)
+  });
+}
+function subcommand(config) {
+  const options = config.options ?? {};
+  const { run } = config;
+  const execute = async (interaction) => {
+    const resolved = resolveOptions(interaction, options);
+    await run(new CommandContext(interaction, resolved));
+  };
+  return {
+    kind: "subcommand",
+    description: config.description,
+    options,
+    nameLocalizations: config.nameLocalizations,
+    descriptionLocalizations: config.descriptionLocalizations,
+    hasAutocomplete: optionsHaveAutocomplete(options),
+    execute,
+    autocomplete: makeAutocompleter(options)
+  };
+}
+function subcommandGroup(config) {
+  return { kind: "group", ...config };
+}
+function commandGroup(config) {
+  const { subcommands, groups } = config;
+  const options = [];
+  for (const [name, sub] of Object.entries(subcommands ?? {})) {
+    options.push(subcommandJSON(name, sub));
+  }
+  for (const [name, group] of Object.entries(groups ?? {})) {
+    options.push({
+      type: discord_js.ApplicationCommandOptionType.SubcommandGroup,
+      name,
+      description: group.description,
+      name_localizations: group.nameLocalizations,
+      description_localizations: group.descriptionLocalizations,
+      options: Object.entries(group.subcommands).map(([n, s]) => subcommandJSON(n, s))
+    });
+  }
+  const hasAutocomplete = Object.values(subcommands ?? {}).some((s) => s.hasAutocomplete) || Object.values(groups ?? {}).some((g) => Object.values(g.subcommands).some((s) => s.hasAutocomplete));
+  const executor = async (interaction) => {
+    const target = routeSubcommand(
+      interaction.options.getSubcommandGroup(false),
+      interaction.options.getSubcommand(false),
+      subcommands,
+      groups
+    );
+    if (target === void 0) {
+      throw new Error(`spearkit: no subcommand handler for /${config.name}`);
+    }
+    await target.execute(interaction);
+  };
+  const autocompleter = async (interaction) => {
+    const target = routeSubcommand(
+      interaction.options.getSubcommandGroup(false),
+      interaction.options.getSubcommand(false),
+      subcommands,
+      groups
+    );
+    if (target === void 0) {
+      if (!interaction.responded) await interaction.respond([]);
+      return;
+    }
+    await target.autocomplete(interaction);
+  };
+  return new SlashCommand({
+    name: config.name,
+    json: baseJSON(config, options),
+    hasAutocomplete,
+    executor,
+    autocompleter
+  });
+}
+var CommandRegistry = class {
+  commands = /* @__PURE__ */ new Map();
+  errorHandler;
+  /** Register one or more commands. Later registrations override by name. */
+  add(...commands) {
+    for (const command2 of commands) this.commands.set(command2.name, command2);
+    return this;
+  }
+  /** Remove a command by name. */
+  remove(name) {
+    return this.commands.delete(name);
+  }
+  /** Look up a command by name. */
+  get(name) {
+    return this.commands.get(name);
+  }
+  /** All registered commands. */
+  all() {
+    return [...this.commands.values()];
+  }
+  /** All registered command names. */
+  get names() {
+    return [...this.commands.keys()];
+  }
+  /** Number of registered commands. */
+  get size() {
+    return this.commands.size;
+  }
+  /** Set the handler used when a command throws. */
+  onError(handler) {
+    this.errorHandler = handler;
+    return this;
+  }
+  /** Serialise every command to discord REST payloads. */
+  toJSON() {
+    return this.all().map((c) => c.toJSON());
+  }
+  /** Dispatch an incoming chat-input interaction to its command. */
+  async handle(interaction) {
+    const command2 = this.commands.get(interaction.commandName);
+    if (command2 === void 0) return;
+    try {
+      await command2.execute(interaction);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      if (this.errorHandler !== void 0) {
+        await this.errorHandler(err, interaction);
+      } else {
+        await this.defaultErrorReply(err, interaction);
+      }
+    }
+  }
+  /** Dispatch an autocomplete interaction to its command. */
+  async handleAutocomplete(interaction) {
+    const command2 = this.commands.get(interaction.commandName);
+    if (command2 === void 0) return;
+    try {
+      await command2.autocomplete(interaction);
+    } catch {
+      if (!interaction.responded) await interaction.respond([]).catch(() => void 0);
+    }
+  }
+  /**
+   * Push the registered commands to discord. Returns the API response.
+   *
+   * Guild deploys apply instantly and are ideal during development; global
+   * deploys can take up to an hour to propagate.
+   */
+  async deploy(options) {
+    let rest = options.rest;
+    if (rest === void 0) {
+      if (options.token === void 0) {
+        throw new Error("spearkit: deploy() requires a token or a pre-configured REST instance");
+      }
+      rest = new discord_js.REST().setToken(options.token);
+    }
+    const body = this.toJSON();
+    const route = options.guildId !== void 0 ? discord_js.Routes.applicationGuildCommands(options.applicationId, options.guildId) : discord_js.Routes.applicationCommands(options.applicationId);
+    return await rest.put(route, { body });
+  }
+  async defaultErrorReply(error, interaction) {
+    interaction.client.emit("error", error);
+    const content = "Something went wrong while running that command.";
+    try {
+      if (interaction.deferred) {
+        await interaction.editReply({ content });
+      } else if (interaction.replied) {
+        await interaction.followUp({ content, flags: discord_js.MessageFlags.Ephemeral });
+      } else {
+        await interaction.reply({ content, flags: discord_js.MessageFlags.Ephemeral });
+      }
+    } catch {
+    }
+  }
+};
+
+// src/events.ts
+function toError(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
+function build(name, once, run) {
+  const listeners = /* @__PURE__ */ new WeakMap();
+  return {
+    name,
+    once,
+    attach(client) {
+      const listener = (...args) => {
+        try {
+          const result = run(...args);
+          if (result instanceof Promise) {
+            result.catch((error) => client.emit("error", toError(error)));
+          }
+        } catch (error) {
+          client.emit("error", toError(error));
+        }
+      };
+      listeners.set(client, listener);
+      if (once) client.once(name, listener);
+      else client.on(name, listener);
+    },
+    detach(client) {
+      const listener = listeners.get(client);
+      if (listener !== void 0) {
+        client.off(name, listener);
+        listeners.delete(client);
+      }
+    }
+  };
+}
+function event(nameOrConfig, run) {
+  if (typeof nameOrConfig === "object") {
+    return build(nameOrConfig.name, nameOrConfig.once ?? false, nameOrConfig.run);
+  }
+  if (run === void 0) {
+    throw new Error("spearkit: event(name, run) requires a handler");
+  }
+  return build(nameOrConfig, false, run);
+}
+var EventRegistry = class {
+  events = [];
+  attached = /* @__PURE__ */ new Set();
+  /** Register one or more event definitions. */
+  add(...defs) {
+    this.events.push(...defs);
+    for (const client of this.attached) {
+      for (const def of defs) def.attach(client);
+    }
+    return this;
+  }
+  /** Number of registered listeners. */
+  get size() {
+    return this.events.length;
+  }
+  /** Attach every registered listener to the client. */
+  attachAll(client) {
+    this.attached.add(client);
+    for (const def of this.events) def.attach(client);
+  }
+  /** Detach every registered listener from the client. */
+  detachAll(client) {
+    this.attached.delete(client);
+    for (const def of this.events) def.detach(client);
+  }
+};
+
+// src/components/customId.ts
+var MAX_CUSTOM_ID_LENGTH = 100;
+var PARAM_SEGMENT = /^\{([A-Za-z0-9_]+)\}$/;
+function compilePattern(pattern) {
+  const segments = pattern.split(":");
+  const namespace = segments[0] ?? "";
+  if (namespace.length === 0 || /[{}]/.test(namespace)) {
+    throw new Error(
+      `spearkit: invalid custom-id pattern "${pattern}". Expected "namespace" or "namespace:{param}".`
+    );
+  }
+  const paramNames = [];
+  for (let i = 1; i < segments.length; i++) {
+    const match = PARAM_SEGMENT.exec(segments[i] ?? "");
+    if (match === null) {
+      throw new Error(
+        `spearkit: invalid custom-id pattern "${pattern}". Segment "${segments[i]}" must be "{param}".`
+      );
+    }
+    paramNames.push(match[1]);
+  }
+  return { pattern, namespace, paramNames };
+}
+function encodeValue(value) {
+  return value.replace(/%/g, "%25").replace(/:/g, "%3A");
+}
+function decodeValue(value) {
+  return value.replace(/%3A/g, ":").replace(/%25/g, "%");
+}
+function buildCustomId(compiled, params) {
+  const parts = [compiled.namespace];
+  for (const name of compiled.paramNames) {
+    const value = params[name];
+    if (value === void 0) {
+      throw new Error(`spearkit: missing param "${name}" for custom-id "${compiled.pattern}"`);
+    }
+    parts.push(encodeValue(value));
+  }
+  const id = parts.join(":");
+  if (id.length > MAX_CUSTOM_ID_LENGTH) {
+    throw new Error(
+      `spearkit: custom-id "${id}" exceeds the ${MAX_CUSTOM_ID_LENGTH}-character discord limit`
+    );
+  }
+  return id;
+}
+function parseCustomId(customId) {
+  const segments = customId.split(":");
+  const namespace = segments[0] ?? "";
+  const values = segments.slice(1).map(decodeValue);
+  return { namespace, values };
+}
+function paramsFromValues(paramNames, values) {
+  const params = {};
+  for (let i = 0; i < paramNames.length; i++) {
+    params[paramNames[i]] = values[i] ?? "";
+  }
+  return params;
+}
+
+// src/components/context.ts
+var MessageComponentContext = class extends BaseContext {
+  constructor(interaction, params) {
+    super(interaction);
+    this.params = params;
+  }
+  params;
+  /** The raw custom-id that triggered this interaction. */
+  get customId() {
+    return this.interaction.customId;
+  }
+  /** The message the component lives on. */
+  get message() {
+    return this.interaction.message;
+  }
+  /** Edit the message this component belongs to. */
+  async update(input) {
+    await this.interaction.update(input);
+  }
+  /** Acknowledge the interaction without editing the message yet. */
+  async deferUpdate() {
+    await this.interaction.deferUpdate();
+  }
+  /** Open a modal in response to this component. */
+  async showModal(modal2) {
+    await this.interaction.showModal(modal2);
+  }
+};
+var ButtonContext = class extends MessageComponentContext {
+};
+var StringSelectContext = class extends MessageComponentContext {
+  /** All selected values. */
+  get values() {
+    return this.interaction.values;
+  }
+  /** The first selected value, or `undefined` if none. */
+  get value() {
+    return this.interaction.values[0];
+  }
+};
+var UserSelectContext = class extends MessageComponentContext {
+  get values() {
+    return this.interaction.values;
+  }
+  get users() {
+    return this.interaction.users;
+  }
+  get members() {
+    return this.interaction.members;
+  }
+};
+var RoleSelectContext = class extends MessageComponentContext {
+  get values() {
+    return this.interaction.values;
+  }
+  get roles() {
+    return this.interaction.roles;
+  }
+};
+var ChannelSelectContext = class extends MessageComponentContext {
+  get values() {
+    return this.interaction.values;
+  }
+  get channels() {
+    return this.interaction.channels;
+  }
+};
+var MentionableSelectContext = class extends MessageComponentContext {
+  get values() {
+    return this.interaction.values;
+  }
+  get users() {
+    return this.interaction.users;
+  }
+  get roles() {
+    return this.interaction.roles;
+  }
+  get members() {
+    return this.interaction.members;
+  }
+};
+var ModalContext = class extends BaseContext {
+  constructor(interaction, params, fields) {
+    super(interaction);
+    this.params = params;
+    this.fields = fields;
+  }
+  params;
+  fields;
+  /** The raw custom-id that triggered this modal submission. */
+  get customId() {
+    return this.interaction.customId;
+  }
+};
+function toError2(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
+var ComponentRegistry = class {
+  buttons = /* @__PURE__ */ new Map();
+  stringSelects = /* @__PURE__ */ new Map();
+  userSelects = /* @__PURE__ */ new Map();
+  roleSelects = /* @__PURE__ */ new Map();
+  channelSelects = /* @__PURE__ */ new Map();
+  mentionableSelects = /* @__PURE__ */ new Map();
+  modals = /* @__PURE__ */ new Map();
+  errorHandler;
+  /** Register one or more components. Later registrations override by namespace. */
+  add(...defs) {
+    for (const def of defs) {
+      switch (def.kind) {
+        case "button":
+          this.buttons.set(def.namespace, def);
+          break;
+        case "stringSelect":
+          this.stringSelects.set(def.namespace, def);
+          break;
+        case "userSelect":
+          this.userSelects.set(def.namespace, def);
+          break;
+        case "roleSelect":
+          this.roleSelects.set(def.namespace, def);
+          break;
+        case "channelSelect":
+          this.channelSelects.set(def.namespace, def);
+          break;
+        case "mentionableSelect":
+          this.mentionableSelects.set(def.namespace, def);
+          break;
+        case "modal":
+          this.modals.set(def.namespace, def);
+          break;
+      }
+    }
+    return this;
+  }
+  /** Set the handler used when a component throws. */
+  onError(handler) {
+    this.errorHandler = handler;
+    return this;
+  }
+  /** Total number of registered components. */
+  get size() {
+    return this.buttons.size + this.stringSelects.size + this.userSelects.size + this.roleSelects.size + this.channelSelects.size + this.mentionableSelects.size + this.modals.size;
+  }
+  /**
+   * Dispatch an interaction to its component handler. Returns `true` if a
+   * handler matched and ran, `false` otherwise.
+   */
+  async handle(interaction) {
+    if (interaction.isButton()) {
+      return this.exec(this.buttons.get(namespaceOf(interaction.customId)), interaction);
+    }
+    if (interaction.isStringSelectMenu()) {
+      return this.exec(this.stringSelects.get(namespaceOf(interaction.customId)), interaction);
+    }
+    if (interaction.isUserSelectMenu()) {
+      return this.exec(this.userSelects.get(namespaceOf(interaction.customId)), interaction);
+    }
+    if (interaction.isRoleSelectMenu()) {
+      return this.exec(this.roleSelects.get(namespaceOf(interaction.customId)), interaction);
+    }
+    if (interaction.isChannelSelectMenu()) {
+      return this.exec(this.channelSelects.get(namespaceOf(interaction.customId)), interaction);
+    }
+    if (interaction.isMentionableSelectMenu()) {
+      return this.exec(this.mentionableSelects.get(namespaceOf(interaction.customId)), interaction);
+    }
+    if (interaction.isModalSubmit()) {
+      return this.exec(this.modals.get(namespaceOf(interaction.customId)), interaction);
+    }
+    return false;
+  }
+  async exec(route, interaction) {
+    if (route === void 0) return false;
+    const { values } = parseCustomId(interaction.customId);
+    const params = paramsFromValues(route.paramNames, values);
+    try {
+      await route.handle(interaction, params);
+    } catch (error) {
+      const err = toError2(error);
+      if (this.errorHandler !== void 0) {
+        await this.errorHandler(err, interaction);
+      } else {
+        interaction.client.emit("error", err);
+        if (!interaction.replied && !interaction.deferred) {
+          await interaction.reply({ content: "Something went wrong.", flags: discord_js.MessageFlags.Ephemeral }).catch(() => void 0);
+        }
+      }
+    }
+    return true;
+  }
+};
+function namespaceOf(customId) {
+  return parseCustomId(customId).namespace;
+}
+function resolveButtonStyle(input) {
+  if (input === void 0) return discord_js.ButtonStyle.Secondary;
+  return typeof input === "number" ? input : discord_js.ButtonStyle[input];
+}
+function button(config) {
+  const compiled = compilePattern(config.id);
+  const style = resolveButtonStyle(config.style);
+  return {
+    kind: "button",
+    namespace: compiled.namespace,
+    paramNames: compiled.paramNames,
+    async handle(interaction, params) {
+      await config.run(new ButtonContext(interaction, params));
+    },
+    build(...args) {
+      const params = args[0] ?? {};
+      const builder = new discord_js.ButtonBuilder().setCustomId(buildCustomId(compiled, params)).setStyle(style);
+      if (config.label !== void 0) builder.setLabel(config.label);
+      if (config.emoji !== void 0) builder.setEmoji(config.emoji);
+      if (config.disabled !== void 0) builder.setDisabled(config.disabled);
+      return builder;
+    }
+  };
+}
+function linkButton(config) {
+  const builder = new discord_js.ButtonBuilder().setStyle(discord_js.ButtonStyle.Link).setURL(config.url);
+  if (config.label !== void 0) builder.setLabel(config.label);
+  if (config.emoji !== void 0) builder.setEmoji(config.emoji);
+  if (config.disabled !== void 0) builder.setDisabled(config.disabled);
+  return builder;
+}
+function applySelectBase(builder, config) {
+  if (config.placeholder !== void 0) builder.setPlaceholder(config.placeholder);
+  if (config.minValues !== void 0) builder.setMinValues(config.minValues);
+  if (config.maxValues !== void 0) builder.setMaxValues(config.maxValues);
+  if (config.disabled !== void 0) builder.setDisabled(config.disabled);
+}
+function stringSelect(config) {
+  const compiled = compilePattern(config.id);
+  return {
+    kind: "stringSelect",
+    namespace: compiled.namespace,
+    paramNames: compiled.paramNames,
+    async handle(interaction, params) {
+      await config.run(new StringSelectContext(interaction, params));
+    },
+    build(...args) {
+      const params = args[0] ?? {};
+      const builder = new discord_js.StringSelectMenuBuilder().setCustomId(buildCustomId(compiled, params)).addOptions(...config.options);
+      applySelectBase(builder, config);
+      return builder;
+    }
+  };
+}
+function userSelect(config) {
+  const compiled = compilePattern(config.id);
+  return {
+    kind: "userSelect",
+    namespace: compiled.namespace,
+    paramNames: compiled.paramNames,
+    async handle(interaction, params) {
+      await config.run(new UserSelectContext(interaction, params));
+    },
+    build(...args) {
+      const params = args[0] ?? {};
+      const builder = new discord_js.UserSelectMenuBuilder().setCustomId(buildCustomId(compiled, params));
+      applySelectBase(builder, config);
+      return builder;
+    }
+  };
+}
+function roleSelect(config) {
+  const compiled = compilePattern(config.id);
+  return {
+    kind: "roleSelect",
+    namespace: compiled.namespace,
+    paramNames: compiled.paramNames,
+    async handle(interaction, params) {
+      await config.run(new RoleSelectContext(interaction, params));
+    },
+    build(...args) {
+      const params = args[0] ?? {};
+      const builder = new discord_js.RoleSelectMenuBuilder().setCustomId(buildCustomId(compiled, params));
+      applySelectBase(builder, config);
+      return builder;
+    }
+  };
+}
+function channelSelect(config) {
+  const compiled = compilePattern(config.id);
+  return {
+    kind: "channelSelect",
+    namespace: compiled.namespace,
+    paramNames: compiled.paramNames,
+    async handle(interaction, params) {
+      await config.run(new ChannelSelectContext(interaction, params));
+    },
+    build(...args) {
+      const params = args[0] ?? {};
+      const builder = new discord_js.ChannelSelectMenuBuilder().setCustomId(buildCustomId(compiled, params));
+      if (config.channelTypes !== void 0) builder.setChannelTypes(...config.channelTypes);
+      applySelectBase(builder, config);
+      return builder;
+    }
+  };
+}
+function mentionableSelect(config) {
+  const compiled = compilePattern(config.id);
+  return {
+    kind: "mentionableSelect",
+    namespace: compiled.namespace,
+    paramNames: compiled.paramNames,
+    async handle(interaction, params) {
+      await config.run(new MentionableSelectContext(interaction, params));
+    },
+    build(...args) {
+      const params = args[0] ?? {};
+      const builder = new discord_js.MentionableSelectMenuBuilder().setCustomId(buildCustomId(compiled, params));
+      applySelectBase(builder, config);
+      return builder;
+    }
+  };
+}
+function resolveTextInputStyle(input) {
+  if (input === void 0) return discord_js.TextInputStyle.Short;
+  return typeof input === "number" ? input : discord_js.TextInputStyle[input];
+}
+function textInput(config) {
+  return {
+    label: config.label,
+    style: resolveTextInputStyle(config.style),
+    placeholder: config.placeholder,
+    required: config.required,
+    minLength: config.minLength,
+    maxLength: config.maxLength,
+    value: config.value
+  };
+}
+function buildTextInput(customId, def) {
+  const input = new discord_js.TextInputBuilder().setCustomId(customId).setLabel(def.label).setStyle(def.style);
+  if (def.placeholder !== void 0) input.setPlaceholder(def.placeholder);
+  if (def.required !== void 0) input.setRequired(def.required);
+  if (def.minLength !== void 0) input.setMinLength(def.minLength);
+  if (def.maxLength !== void 0) input.setMaxLength(def.maxLength);
+  if (def.value !== void 0) input.setValue(def.value);
+  return input;
+}
+function modal(config) {
+  const compiled = compilePattern(config.id);
+  const fieldKeys = Object.keys(config.fields);
+  return {
+    kind: "modal",
+    namespace: compiled.namespace,
+    paramNames: compiled.paramNames,
+    async handle(interaction, params) {
+      const fields = {};
+      for (const key of fieldKeys) {
+        try {
+          fields[key] = interaction.fields.getTextInputValue(key);
+        } catch {
+          fields[key] = "";
+        }
+      }
+      await config.run(
+        new ModalContext(interaction, params, fields)
+      );
+    },
+    build(...args) {
+      const params = args[0] ?? {};
+      const builder = new discord_js.ModalBuilder().setCustomId(buildCustomId(compiled, params)).setTitle(config.title);
+      for (const [key, def] of Object.entries(config.fields)) {
+        builder.addComponents(
+          new discord_js.ActionRowBuilder().addComponents(buildTextInput(key, def))
+        );
+      }
+      return builder;
+    }
+  };
+}
+function row(...components) {
+  return new discord_js.ActionRowBuilder().addComponents(...components);
+}
+var DEFAULT_EXTENSIONS = [".js", ".mjs", ".cjs"];
+function isRegisterable(value) {
+  if (value instanceof SlashCommand) return true;
+  if (typeof value !== "object" || value === null) return false;
+  const record = value;
+  if (typeof record["attach"] === "function" && typeof record["detach"] === "function") {
+    return true;
+  }
+  if (typeof record["kind"] === "string" && typeof record["handle"] === "function") {
+    return true;
+  }
+  return false;
+}
+async function collectModules(dir, options = {}) {
+  const extensions = options.extensions ?? DEFAULT_EXTENSIONS;
+  const recursive = options.recursive ?? true;
+  const found = [];
+  const entries = await promises.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (recursive) found.push(...await collectModules(fullPath, options));
+      continue;
+    }
+    if (!extensions.includes(path.extname(entry.name))) continue;
+    const mod = await import(url.pathToFileURL(fullPath).href);
+    for (const value of Object.values(mod)) {
+      if (isRegisterable(value)) found.push(value);
+    }
+  }
+  return found;
+}
+async function loadInto(client, dir, options) {
+  const items = await collectModules(dir, options);
+  client.register(...items);
+  return items.length;
+}
+
+// src/client.ts
+var allIntents = Object.values(discord_js.GatewayIntentBits).filter(
+  (value) => typeof value === "number"
+);
+var Intents = {
+  /** No intents. */
+  none: [],
+  /** Just `Guilds` — enough for slash commands and interactions. */
+  default: [discord_js.GatewayIntentBits.Guilds],
+  /** Guild + member gateway data. */
+  guilds: [discord_js.GatewayIntentBits.Guilds, discord_js.GatewayIntentBits.GuildMembers],
+  /** Read message content (privileged) alongside guild messages. */
+  messages: [
+    discord_js.GatewayIntentBits.Guilds,
+    discord_js.GatewayIntentBits.GuildMessages,
+    discord_js.GatewayIntentBits.MessageContent
+  ],
+  /** Every intent, including privileged ones. */
+  all: allIntents
+};
+var SpearClient = class extends discord_js.Client {
+  /** Slash command registry and dispatcher. */
+  commands = new CommandRegistry();
+  /** Event listener registry. */
+  events = new EventRegistry();
+  /** Button / select / modal registry and router. */
+  components = new ComponentRegistry();
+  constructor(options = {}) {
+    const { intents, ...rest } = options;
+    super({ ...rest, intents: intents ?? Intents.default });
+    this.events.attachAll(this);
+    this.on("interactionCreate", (interaction) => this.route(interaction));
+  }
+  /**
+   * Register commands, events and components in one call. Each item is routed
+   * to the matching registry based on its kind.
+   */
+  register(...items) {
+    for (const item of items) {
+      if (item instanceof SlashCommand) {
+        this.commands.add(item);
+      } else if ("attach" in item) {
+        this.events.add(item);
+      } else {
+        this.components.add(item);
+      }
+    }
+    return this;
+  }
+  /** Install one or more plugins, running each plugin's `setup`. */
+  async use(...plugins) {
+    for (const plugin of plugins) {
+      await plugin.setup(this);
+    }
+    return this;
+  }
+  /**
+   * Recursively load a directory and register every command, event and
+   * component it exports. Returns the number of items registered.
+   */
+  load(dir, options) {
+    return loadInto(this, dir, options);
+  }
+  /**
+   * Log in. Falls back to the `DISCORD_TOKEN` environment variable when no
+   * token is passed.
+   */
+  async start(token) {
+    const resolved = token ?? process.env.DISCORD_TOKEN;
+    if (resolved === void 0 || resolved.length === 0) {
+      throw new Error("spearkit: start() needs a token (pass one or set DISCORD_TOKEN)");
+    }
+    await this.login(resolved);
+    return this;
+  }
+  /**
+   * Push the registered slash commands to discord using the client's own
+   * authenticated REST connection. Call after the client is ready.
+   */
+  async deployCommands(options = {}) {
+    const applicationId = this.application?.id ?? this.user?.id;
+    if (applicationId == null) {
+      throw new Error("spearkit: deployCommands() must run after the client is ready");
+    }
+    return this.commands.deploy({ rest: this.rest, applicationId, guildId: options.guildId });
+  }
+  async route(interaction) {
+    if (interaction.isChatInputCommand()) {
+      await this.commands.handle(interaction);
+    } else if (interaction.isAutocomplete()) {
+      await this.commands.handleAutocomplete(interaction);
+    } else {
+      await this.components.handle(interaction);
+    }
+  }
+};
+
+// src/plugin.ts
+function definePlugin(plugin) {
+  return plugin;
+}
+
+exports.AutocompleteContext = AutocompleteContext;
+exports.BaseContext = BaseContext;
+exports.ButtonContext = ButtonContext;
+exports.ChannelSelectContext = ChannelSelectContext;
+exports.CommandContext = CommandContext;
+exports.CommandRegistry = CommandRegistry;
+exports.ComponentRegistry = ComponentRegistry;
+exports.EventRegistry = EventRegistry;
+exports.Intents = Intents;
+exports.MAX_CUSTOM_ID_LENGTH = MAX_CUSTOM_ID_LENGTH;
+exports.MentionableSelectContext = MentionableSelectContext;
+exports.MessageComponentContext = MessageComponentContext;
+exports.ModalContext = ModalContext;
+exports.RoleSelectContext = RoleSelectContext;
+exports.SlashCommand = SlashCommand;
+exports.SpearClient = SpearClient;
+exports.StringSelectContext = StringSelectContext;
+exports.UserSelectContext = UserSelectContext;
+exports.asEphemeral = asEphemeral;
+exports.buildCustomId = buildCustomId;
+exports.button = button;
+exports.channelSelect = channelSelect;
+exports.collectModules = collectModules;
+exports.command = command;
+exports.commandGroup = commandGroup;
+exports.compilePattern = compilePattern;
+exports.definePlugin = definePlugin;
+exports.event = event;
+exports.linkButton = linkButton;
+exports.loadInto = loadInto;
+exports.mentionableSelect = mentionableSelect;
+exports.modal = modal;
+exports.normalizeReply = normalizeReply;
+exports.option = option;
+exports.optionsHaveAutocomplete = optionsHaveAutocomplete;
+exports.paramsFromValues = paramsFromValues;
+exports.parseCustomId = parseCustomId;
+exports.readOption = readOption;
+exports.roleSelect = roleSelect;
+exports.row = row;
+exports.stringSelect = stringSelect;
+exports.subcommand = subcommand;
+exports.subcommandGroup = subcommandGroup;
+exports.textInput = textInput;
+exports.toAPIOption = toAPIOption;
+exports.userSelect = userSelect;
+Object.keys(discord_js).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return discord_js[k]; }
+  });
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map