@carzo/enire 3.0.0

package/lib/classes/Utils.js

@@ -0,0 +1,563 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Utils = void 0;
+
+const tslib_1 = require("tslib");
+const types_1 = require("util/types");
+const DJS = tslib_1.__importStar(require("discord.js"));
+const Errors = tslib_1.__importStar(require("./Errors.js"));
+const Cooldowns_js_1 = require("./Cooldowns.js");
+
+class Utils {
+  static isType(obj, func) {
+    return func(obj);
+  }
+
+  static noop(n = null) {
+    return n;
+  }
+
+  static async getMember(query, options) {
+    if (!query || !options?.guild) return null;
+
+    const id = query.replace(/[^\d]/g, "");
+    let member = id ? options.guild.members.cache.get(id) : null;
+
+    member =
+      member ||
+      options.guild.members.cache.find(
+        (target) =>
+          target.user.username.toLowerCase() === query.toLowerCase() ||
+          target.user.globalName?.toLowerCase() === query.toLowerCase() ||
+          target.user.username.toLowerCase().includes(query.toLowerCase())
+      ) ||
+      null;
+
+    if (!member && id && options.force) {
+      member = (await options.guild.members.fetch(id).catch(Utils.noop)) || null;
+    }
+
+    return member;
+  }
+
+  static async getChannel(query, options) {
+    if (!query || !options?.guild) return null;
+
+    const id = query.replace(/[^\d]/g, "");
+    let channel = id ? options.guild.channels.cache.get(id) : null;
+
+    channel =
+      channel ||
+      options.guild.channels.cache.find(
+        (target) => target.name.toLowerCase() === query.toLowerCase() || target.name.toLowerCase().includes(query.toLowerCase())
+      ) ||
+      null;
+
+    if (!channel && id && options.force) {
+      channel = (await options.guild.channels.fetch(id).catch(Utils.noop)) || null;
+    }
+
+    return channel;
+  }
+
+  static async getRole(query, options) {
+    if (!query || !options?.guild) return null;
+
+    const id = query.replace(/[^\d]/g, "");
+    let role = id ? options.guild.roles.cache.get(id) : null;
+
+    role =
+      role ||
+      options.guild.roles.cache.find(
+        (target) => target.name.toLowerCase() === query.toLowerCase() || target.name.toLowerCase().includes(query.toLowerCase())
+      ) ||
+      null;
+
+    if (!role && id && options.force) {
+      role = (await options.guild.roles.fetch(id).catch(Utils.noop)) || null;
+    }
+
+    return role;
+  }
+
+  static async getUser(query, bot) {
+    if (!query) return null;
+
+    const id = query.replace(/[^\d]/g, "");
+
+    const cached =
+      (id ? bot.users.cache.get(id) : null) ||
+      bot.users.cache.find(
+        (user) =>
+          user.globalName?.toLowerCase() === query.toLowerCase() ||
+          user.username.toLowerCase() === query.toLowerCase() ||
+          user.id === query
+      ) ||
+      null;
+
+    if (cached) return cached;
+
+    try {
+      return await bot.users.fetch(id || query);
+    } catch {
+      return null;
+    }
+  }
+
+  static #cloneParams(paramsBuilder) {
+    if (!paramsBuilder?.params?.length) return [];
+    return paramsBuilder.params.map((param) => ({ ...param, value: undefined }));
+  }
+
+  static async transform(input, param, ctx, seeable = true) {
+    if (!input && seeable) {
+      return { break: false, value: null };
+    }
+
+    if (param.choices?.length) {
+      const selected = param.choices.find((choice) => choice.name.toLowerCase() === String(input).toLowerCase());
+      if (selected) return { break: false, value: selected.value };
+      throw new Errors.InvalidParamChoice(ctx, param, param.choices);
+    }
+
+    if (param.type === DJS.ApplicationCommandOptionType.String) {
+      const value = String(input ?? "");
+
+      if (typeof param.max_length === "number" && value.length > param.max_length) {
+        throw new Errors.InvalidParam(ctx, `${param.name} exceeds max length.`, { param });
+      }
+
+      if (typeof param.min_length === "number" && value.length < param.min_length) {
+        throw new Errors.InvalidParam(ctx, `${param.name} is under min length.`, { param });
+      }
+
+      return { break: false, value };
+    }
+
+    if (param.type === DJS.ApplicationCommandOptionType.Number) {
+      const value = Number(input);
+      if (Number.isNaN(value)) throw new Errors.InvalidParamNumber(ctx, param);
+
+      if (typeof param.max_value === "number" && value > param.max_value) {
+        throw new Errors.InvalidParam(ctx, `${param.name} exceeds max value.`, { param });
+      }
+
+      if (typeof param.min_value === "number" && value < param.min_value) {
+        throw new Errors.InvalidParam(ctx, `${param.name} is under min value.`, { param });
+      }
+
+      return { break: false, value };
+    }
+
+    if (param.type === DJS.ApplicationCommandOptionType.Boolean) {
+      const lowered = String(input).toLowerCase();
+      if (lowered !== "true" && lowered !== "false") throw new Errors.InvalidParamBoolean(ctx, param);
+      return { break: false, value: lowered === "true" };
+    }
+
+    if (param.type === DJS.ApplicationCommandOptionType.User) {
+      const member = ctx.guild ? await Utils.getMember(String(input), { guild: ctx.guild, force: true }) : await Utils.getUser(String(input), ctx.bot);
+      if (member) return { break: false, value: member };
+      throw new Errors.InvalidParamMember(ctx, param);
+    }
+
+    if (param.type === DJS.ApplicationCommandOptionType.Channel) {
+      const channel = await Utils.getChannel(String(input), { guild: ctx.guild, force: true });
+      if (!channel) throw new Errors.InvalidParamChannel(ctx, param);
+
+      if (param.channel_types?.length && !param.channel_types.includes(channel.type)) {
+        throw new Errors.InvalidChannelType(ctx, param, channel.type, param.channel_types);
+      }
+
+      return { break: false, value: channel };
+    }
+
+    if (param.type === DJS.ApplicationCommandOptionType.Role) {
+      const role = await Utils.getRole(String(input), { guild: ctx.guild, force: true });
+      if (role) return { break: false, value: role };
+      throw new Errors.InvalidParamRole(ctx, param);
+    }
+
+    if (param.type === DJS.ApplicationCommandOptionType.Attachment) {
+      const attachment = ctx.message?.attachments?.first();
+      if (!attachment && param.required) throw new Errors.InvalidParamAttachment(ctx, param);
+      return { break: false, value: attachment };
+    }
+
+    return { break: false, value: input ?? null };
+  }
+
+  static async #resolvePrefixParams(ctx, command, args) {
+    const params = Utils.#cloneParams(command.params);
+    if (!params.length) {
+      ctx.params = [];
+      ctx.args = args;
+      return;
+    }
+
+    let argIndex = 0;
+
+    for (let paramIndex = 0; paramIndex < params.length; paramIndex += 1) {
+      const param = params[paramIndex];
+
+      if (param.type === DJS.ApplicationCommandOptionType.Attachment) {
+        const transformed = await Utils.transform("", param, ctx, false);
+        param.value = transformed.value;
+        continue;
+      }
+
+      if (param.ellipsis) {
+        const remaining = args.slice(argIndex).join(" ").trim();
+
+        if (!remaining && param.required) {
+          throw new Errors.MissingRequiredParam(ctx, param);
+        }
+
+        if (remaining) {
+          const transformed = await Utils.transform(remaining, param, ctx);
+          param.value = transformed.value;
+          argIndex = args.length;
+        } else {
+          param.value = null;
+        }
+
+        continue;
+      }
+
+      const raw = args[argIndex];
+      if ((raw === undefined || raw === null || raw === "") && param.required) {
+        throw new Errors.MissingRequiredParam(ctx, param);
+      }
+
+      if (raw === undefined || raw === null || raw === "") {
+        param.value = null;
+      } else {
+        const transformed = await Utils.transform(raw, param, ctx);
+        param.value = transformed.value;
+      }
+
+      argIndex += 1;
+    }
+
+    ctx.params = params;
+    ctx.args = args;
+  }
+
+  static #resolveInteractionParamValue(interaction, param) {
+    const name = param.name;
+
+    switch (param.type) {
+      case DJS.ApplicationCommandOptionType.String:
+        return interaction.options.getString(name, !!param.required);
+      case DJS.ApplicationCommandOptionType.Number:
+        return interaction.options.getNumber(name, !!param.required);
+      case DJS.ApplicationCommandOptionType.Boolean:
+        return interaction.options.getBoolean(name, !!param.required);
+      case DJS.ApplicationCommandOptionType.User:
+        return interaction.options.getMember(name) ?? interaction.options.getUser(name, !!param.required);
+      case DJS.ApplicationCommandOptionType.Channel:
+        return interaction.options.getChannel(name, !!param.required);
+      case DJS.ApplicationCommandOptionType.Role:
+        return interaction.options.getRole(name, !!param.required);
+      case DJS.ApplicationCommandOptionType.Attachment:
+        return interaction.options.getAttachment(name, !!param.required);
+      default:
+        return interaction.options.get(name)?.value ?? null;
+    }
+  }
+
+  static async #resolveInteractionParams(ctx, command, interaction) {
+    const params = Utils.#cloneParams(command.params);
+
+    for (const param of params) {
+      const value = Utils.#resolveInteractionParamValue(interaction, param);
+
+      if ((value === null || value === undefined) && param.required) {
+        throw new Errors.MissingRequiredParam(ctx, param);
+      }
+
+      param.value = value ?? null;
+    }
+
+    ctx.params = params;
+    ctx.args = null;
+  }
+
+  static async #runPlugins(ctx, command) {
+    const plugins = [...(command.plugins ?? []), ...ctx.bot.loader.globalPlugins];
+
+    for (const plugin of plugins) {
+      if ((0, types_1.isPromise)(plugin)) {
+        const resolved = await plugin;
+        if (!(await resolved(ctx))) return false;
+        continue;
+      }
+
+      if (!(await plugin(ctx))) return false;
+    }
+
+    return true;
+  }
+
+  static async #runPredicates(ctx, predicates) {
+    for (const predicate of predicates) {
+      if (!predicate) continue;
+      if (!(await predicate(ctx))) return false;
+    }
+
+    return true;
+  }
+
+  static #resolveCooldownSource(ctx, bucket) {
+    switch (bucket) {
+      case Cooldowns_js_1.Bucket.Guild:
+        return ctx.guild?.id || "-1";
+      case Cooldowns_js_1.Bucket.Member:
+        return ctx.guild ? `${ctx.guild.id}_${ctx.author.id}` : ctx.author.id;
+      case Cooldowns_js_1.Bucket.Channel:
+        return ctx.channel?.id || "-1";
+      case Cooldowns_js_1.Bucket.User:
+      default:
+        return ctx.author.id;
+    }
+  }
+
+  static async #applyCooldown(ctx, command) {
+    const cooldown = command?.data?.cooldown;
+    if (!cooldown?.seconds || cooldown.seconds <= 0) return;
+
+    const bucket = cooldown.bucket || Cooldowns_js_1.Bucket.User;
+    const source = Utils.#resolveCooldownSource(ctx, bucket);
+    const cooldownMs = cooldown.seconds * 1000;
+
+    const active = await ctx.bot.cooldowns.check(command.data.name, source, cooldownMs, bucket);
+    if (active) throw new Errors.CommandInCooldown(ctx, active.left);
+
+    await ctx.bot.cooldowns.setCooldownSource(command.data.name, source, bucket, cooldownMs);
+  }
+
+  static async executeCommand(ctx, command, options) {
+    const { group = null, source, args = null, interaction = null, prefix = "" } = options;
+
+    if (ctx.bot.ops.guildOnly && !ctx.guild) {
+      throw new Errors.GuildOnly(ctx);
+    }
+
+    if (command.data.guildOnly === true && !ctx.guild) {
+      throw new Errors.GuildOnly(ctx, "This command is only available in guilds.");
+    }
+
+    if (group?.data?.guildOnly === true && !ctx.guild) {
+      throw new Errors.GuildOnly(ctx, "This command group is only available in guilds.");
+    }
+
+    ctx.command = command;
+    ctx.parent = group;
+    ctx.prefix = prefix;
+
+    const canRunPlugins = await Utils.#runPlugins(ctx, command);
+    if (!canRunPlugins) return;
+
+    const canRunGuards = await Utils.#runPredicates(ctx, [...(group?.data?.guards ?? []), ...(command.data?.guards ?? [])]);
+    if (!canRunGuards) return;
+
+    await Utils.#applyCooldown(ctx, command);
+
+    if (source === "prefix") {
+      await Utils.#resolvePrefixParams(ctx, command, args ?? []);
+    } else {
+      await Utils.#resolveInteractionParams(ctx, command, interaction);
+    }
+
+    await command.code(ctx);
+  }
+
+  static async #resolvePrefix(bot, ctx, message) {
+    if (typeof bot.ops.prefix === "string") {
+      if (!message.content.toLowerCase().startsWith(bot.ops.prefix.toLowerCase())) return null;
+      return bot.ops.prefix;
+    }
+
+    if (Array.isArray(bot.ops.prefix)) {
+      return bot.ops.prefix.find((prefix) => message.content.toLowerCase().startsWith(prefix.toLowerCase())) || null;
+    }
+
+    if ((0, types_1.isAsyncFunction)(bot.ops.prefix) || typeof bot.ops.prefix === "function") {
+      const resolved = await bot.ops.prefix(ctx);
+      if (!resolved) return null;
+      if (!message.content.toLowerCase().startsWith(resolved.toLowerCase())) return null;
+      return resolved;
+    }
+
+    return null;
+  }
+
+  static #matchAlias(target, value) {
+    const lowered = value.toLowerCase();
+    return target.data.name.toLowerCase() === lowered || (target.data.aliases || []).map((alias) => alias.toLowerCase()).includes(lowered);
+  }
+
+  static #findPrefixCommand(bot, trigger, args) {
+    const normal =
+      bot.loader.commands.normal?.find((command) => Utils.#matchAlias(command, trigger) && command.data.as_prefix) || null;
+
+    const group =
+      bot.loader.commands.group?.find((entry) => Utils.#matchAlias(entry, trigger) && entry.data.as_prefix) || null;
+
+    if (group) {
+      const maybeSub = (args.shift() || "").toLowerCase();
+      const sub =
+        group.data.commands.find((command) => Utils.#matchAlias(command, maybeSub) && command.data.as_prefix) ||
+        group.data.commands.find((command) => command.data.fallback && command.data.as_prefix) ||
+        null;
+
+      if (sub) return { command: sub, group, args };
+    }
+
+    if (normal) return { command: normal, group: null, args };
+    return null;
+  }
+
+  static async handleMessage(bot, message, isEdit = false) {
+    if (!message || !message.content || message.author?.bot) return;
+
+    const ctx = bot.getContext(message);
+
+    if (bot.ops.restrictions?.guildIDs?.has(String(message.guild?.id))) {
+      throw new Errors.RestrictedGuild(ctx, message.guild);
+    }
+
+    if (bot.ops.restrictions?.userIDs?.has(message.author.id)) {
+      throw new Errors.RestrictedUser(ctx, message.author);
+    }
+
+    const prefix = await Utils.#resolvePrefix(bot, ctx, message);
+    if (!prefix) return;
+
+    const body = message.content.slice(prefix.length).trim();
+    if (!body.length) return;
+
+    const tokens = Utils.splitArgs(body);
+    const trigger = (tokens.shift() || "").toLowerCase();
+    if (!trigger) return;
+
+    const resolved = Utils.#findPrefixCommand(bot, trigger, tokens);
+    if (!resolved) return;
+
+    await Utils.executeCommand(ctx, resolved.command, {
+      group: resolved.group,
+      source: "prefix",
+      args: resolved.args,
+      prefix,
+    });
+  }
+
+  static #findSlashCommand(bot, interaction) {
+    const subCommand = interaction.options.getSubcommand(false);
+
+    if (subCommand) {
+      const group = bot.loader.commands.group?.get(interaction.commandName) || null;
+      if (!group?.data?.as_slash) return null;
+
+      const command =
+        group.data.commands.find((entry) => entry.data.name === subCommand && entry.data.as_slash) ||
+        group.data.commands.find((entry) => entry.data.fallback && entry.data.as_slash) ||
+        null;
+
+      if (!command) return null;
+      return { command, group };
+    }
+
+    const command = bot.loader.commands.normal?.find((entry) => entry.data.name === interaction.commandName && entry.data.as_slash) || null;
+    if (!command) return null;
+
+    return { command, group: null };
+  }
+
+  static #resolveInteractionModule(bot, interaction) {
+    if (interaction.isAutocomplete()) return bot.loader.interactions.autocomplete.get(interaction.commandName) || null;
+    if (interaction.isButton()) return bot.loader.interactions.button.get(interaction.customId) || null;
+    if (interaction.isModalSubmit()) return bot.loader.interactions.modalSubmit.get(interaction.customId) || null;
+    if (interaction.isMessageContextMenuCommand()) return bot.loader.interactions.messageContextMenu.get(interaction.commandName) || null;
+    if (interaction.isUserContextMenuCommand()) return bot.loader.interactions.userContextMenu.get(interaction.commandName) || null;
+    if (interaction.isChannelSelectMenu()) return bot.loader.interactions.channelSelectMenu.get(interaction.customId) || null;
+    if (interaction.isMentionableSelectMenu()) return bot.loader.interactions.mentionableSelectMenu.get(interaction.customId) || null;
+    if (interaction.isRoleSelectMenu()) return bot.loader.interactions.roleSelectMenu.get(interaction.customId) || null;
+    if (interaction.isStringSelectMenu()) return bot.loader.interactions.stringSelectMenu.get(interaction.customId) || null;
+    if (interaction.isUserSelectMenu()) return bot.loader.interactions.userSelectMenu.get(interaction.customId) || null;
+    return null;
+  }
+
+  static async handleInteraction(bot, interaction) {
+    const ctx = bot.getContext(interaction);
+
+    if (bot.ops.restrictions?.guildIDs?.has(String(interaction.guild?.id))) {
+      throw new Errors.RestrictedGuild(ctx, interaction.guild);
+    }
+
+    if (bot.ops.restrictions?.userIDs?.has(interaction.user.id)) {
+      throw new Errors.RestrictedUser(ctx, interaction.user);
+    }
+
+    if (interaction.isChatInputCommand()) {
+      const resolved = Utils.#findSlashCommand(bot, interaction);
+      if (!resolved) return;
+
+      await Utils.executeCommand(ctx, resolved.command, {
+        group: resolved.group,
+        source: "slash",
+        interaction,
+        prefix: "/",
+      });
+      return;
+    }
+
+    const matched = Utils.#resolveInteractionModule(bot, interaction);
+    if (matched) {
+      await matched.code?.(interaction);
+    }
+
+    for (const callback of bot.loader.interactions.anyInteraction.values()) {
+      await callback.code?.(interaction);
+    }
+  }
+
+  static async runPrefixCommand(ctx, command, args, group) {
+    await Utils.executeCommand(ctx, command, {
+      group: group || null,
+      source: "prefix",
+      args,
+      prefix: ctx.prefix,
+    });
+  }
+
+  static async runInteractionCommand(ctx, interaction) {
+    const resolved = Utils.#findSlashCommand(ctx.bot, interaction);
+    if (!resolved) return;
+
+    await Utils.executeCommand(ctx, resolved.command, {
+      group: resolved.group,
+      source: "slash",
+      interaction,
+      prefix: "/",
+    });
+  }
+
+  static splitArgs(text, special = true, removeNewLines = false) {
+    if (!special) {
+      return text.trim().split(/ +/g).filter(Boolean);
+    }
+
+    const regexp = /("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[\S]+)/gim;
+    const clean = text.replaceAll(/\r|\n/gm, removeNewLines ? "" : "#ER_BREAK_LINE#");
+    const args = [];
+
+    let match;
+    while ((match = regexp.exec(clean))) {
+      args.push(match[0].replace(/^(['"])(.*)\1$/, "$2").replace(/\\(.)/gim, "$1"));
+    }
+
+    return args.map((arg) => arg.replaceAll("#ER_BREAK_LINE#", "\n"));
+  }
+}
+exports.Utils = Utils;

package/lib/classes/builders/CommandBuilder.d.ts

@@ -0,0 +1,44 @@
+export declare function validateDefaultMemberPermissions(permissions: unknown): string | null | undefined;
+
+export interface CommandDataBuilder {
+  name: string;
+  aliases?: string[];
+  description?: string;
+  as_prefix?: boolean;
+  as_slash?: boolean;
+  fallback?: true;
+  guildOnly?: boolean;
+  multiple_args?: boolean;
+  defaultMemberPermissions?: string | bigint;
+  guards?: Array<(ctx: any) => boolean | Promise<boolean>>;
+  cooldown?: { seconds: number; bucket?: string };
+}
+
+export declare class CommandBuilder {
+  name: string;
+  aliases: string[];
+  description: string;
+  as_prefix: boolean;
+  as_slash: boolean;
+  fallback: boolean;
+  guildOnly: boolean | undefined;
+  multiple_args?: boolean;
+  defaultMemberPermissions?: string | bigint | undefined;
+  guards: Array<(ctx: any) => boolean | Promise<boolean>>;
+  cooldown?: { seconds: number; bucket?: string };
+  constructor(options?: CommandDataBuilder);
+  setName(name: string): CommandBuilder;
+  setDescription(description: string): CommandBuilder;
+  setAliases(...aliases: string[]): CommandBuilder;
+  allowPrefix(allow: boolean): CommandBuilder;
+  allowSlash(allow: boolean): CommandBuilder;
+  allowMultipleArgs(allow: boolean): CommandBuilder;
+  setGuards(...guards: Array<(ctx: any) => boolean | Promise<boolean>>): CommandBuilder;
+  setCooldown(seconds: number, bucket?: string): CommandBuilder;
+  toJSON(): {
+    name: string;
+    description: string;
+    default_member_permissions: string | null | undefined;
+    dm_permission: boolean | undefined;
+  };
+}

package/lib/classes/builders/CommandBuilder.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandBuilder = exports.validateDefaultMemberPermissions = void 0;
+
+const shapeshift_1 = require("@sapphire/shapeshift");
+
+const memberPermissionPredicate = shapeshift_1.s
+  .union(shapeshift_1.s.bigint.transform((value) => value.toString()), shapeshift_1.s.number.safeInt.transform((value) => value.toString()), shapeshift_1.s.string.regex(/^\d+$/))
+  .nullish;
+
+function validateDefaultMemberPermissions(permissions) {
+  return memberPermissionPredicate.parse(permissions);
+}
+exports.validateDefaultMemberPermissions = validateDefaultMemberPermissions;
+
+class CommandBuilder {
+  name;
+  aliases;
+  description;
+  as_prefix;
+  as_slash;
+  fallback;
+  guildOnly;
+  multiple_args;
+  defaultMemberPermissions;
+  guards;
+  cooldown;
+
+  constructor(options) {
+    this.name = options?.name ?? "";
+    this.aliases = options?.aliases ?? [];
+    this.description = options?.description ?? "...";
+    this.fallback = options?.fallback ?? false;
+    this.as_prefix = options?.as_prefix ?? true;
+    this.as_slash = options?.as_slash ?? true;
+    this.guildOnly = options?.guildOnly;
+    this.defaultMemberPermissions = options?.defaultMemberPermissions;
+    this.guards = options?.guards ?? [];
+    this.cooldown = options?.cooldown;
+  }
+
+  setName(name) {
+    this.name = name;
+    return this;
+  }
+
+  setDescription(description) {
+    this.description = description;
+    return this;
+  }
+
+  setAliases(...aliases) {
+    this.aliases = aliases;
+    return this;
+  }
+
+  allowPrefix(allow) {
+    this.as_prefix = allow;
+    return this;
+  }
+
+  allowSlash(allow) {
+    this.as_slash = allow;
+    return this;
+  }
+
+  allowMultipleArgs(allow) {
+    this.multiple_args = allow;
+    return this;
+  }
+
+  setGuards(...guards) {
+    this.guards = guards;
+    return this;
+  }
+
+  setCooldown(seconds, bucket = "USER") {
+    this.cooldown = { seconds, bucket };
+    return this;
+  }
+
+  toJSON() {
+    return {
+      name: this.name,
+      description: this.description,
+      default_member_permissions: this.defaultMemberPermissions ? validateDefaultMemberPermissions(this.defaultMemberPermissions) : undefined,
+      dm_permission: typeof this.guildOnly === "boolean" ? !this.guildOnly : undefined,
+    };
+  }
+}
+exports.CommandBuilder = CommandBuilder;