@carzo/enire 3.0.0

package/lib/classes/Loader.js

@@ -0,0 +1,302 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Loader = exports.Types = void 0;
+
+const discord_js_1 = require("discord.js");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const process_1 = require("process");
+const crypto_1 = require("crypto");
+const Client_js_1 = require("./Client.js");
+const CommandBuilder_js_1 = require("./builders/CommandBuilder.js");
+const GroupBuilder_js_1 = require("./builders/GroupBuilder.js");
+const EventBuilder_js_1 = require("./builders/EventBuilder.js");
+const InteractionBuilder_js_1 = require("./builders/InteractionBuilder.js");
+
+const isValidFile = (file) => {
+  if (file.endsWith(".d.ts")) return false;
+  return file.endsWith(".js") || file.endsWith(".mjs") || file.endsWith(".ts") || file.endsWith(".mts");
+};
+
+var Types;
+(function (Types) {
+  Types["Normal"] = "normal";
+  Types["Group"] = "group";
+})(Types || (exports.Types = Types = {}));
+
+class Loader {
+  client;
+  commands;
+  interactions;
+  globalPlugins;
+  listeners;
+  rest;
+  #eventHandlers;
+
+  constructor(options) {
+    if (!(options?.client instanceof Client_js_1.Enire)) {
+      throw new SyntaxError("Invalid client provided in options");
+    }
+
+    this.client = options.client;
+    this.commands = { normal: null, group: null };
+    this.interactions = {
+      autocomplete: new discord_js_1.Collection(),
+      button: new discord_js_1.Collection(),
+      chatInput: new discord_js_1.Collection(),
+      modalSubmit: new discord_js_1.Collection(),
+      userContextMenu: new discord_js_1.Collection(),
+      messageContextMenu: new discord_js_1.Collection(),
+      channelSelectMenu: new discord_js_1.Collection(),
+      roleSelectMenu: new discord_js_1.Collection(),
+      stringSelectMenu: new discord_js_1.Collection(),
+      userSelectMenu: new discord_js_1.Collection(),
+      mentionableSelectMenu: new discord_js_1.Collection(),
+      anyInteraction: new discord_js_1.Collection(),
+    };
+    this.globalPlugins = [];
+    this.listeners = null;
+    this.rest = new discord_js_1.REST();
+    this.#eventHandlers = new Map();
+  }
+
+  #toAbsolutePath(inputPath) {
+    if ((0, path_1.isAbsolute)(inputPath)) return inputPath;
+    return (0, path_1.join)((0, process_1.cwd)(), inputPath);
+  }
+
+  #collectModules(dirPath, reload, output) {
+    const entries = (0, fs_1.readdirSync)(dirPath);
+
+    for (const entry of entries) {
+      const absolute = (0, path_1.join)(dirPath, entry);
+      const stat = (0, fs_1.lstatSync)(absolute);
+
+      if (stat.isDirectory()) {
+        this.#collectModules(absolute, reload, output);
+        continue;
+      }
+
+      if (!isValidFile(entry)) continue;
+
+      if (reload) {
+        try {
+          delete require.cache[require.resolve(absolute)];
+        } catch {
+          /* ignore */
+        }
+      }
+
+      const mod = require(absolute)?.data;
+      if (!mod) continue;
+
+      if (Array.isArray(mod)) output.push(...mod);
+      else output.push(mod);
+    }
+  }
+
+  #attachEvent(moduleData) {
+    const eventData = moduleData.data;
+    const key = `${eventData.name}:${(0, crypto_1.randomUUID)()}`;
+    const handler = (...args) => moduleData.code?.(this.client, ...args);
+
+    this.#eventHandlers.set(key, { eventName: eventData.name, handler });
+
+    if (eventData.once) this.client.once(eventData.name, handler);
+    else this.client.on(eventData.name, handler);
+  }
+
+  #clearEventHandlers() {
+    for (const { eventName, handler } of this.#eventHandlers.values()) {
+      this.client.off(eventName, handler);
+    }
+    this.#eventHandlers.clear();
+  }
+
+  #resetCollectionsForReload() {
+    this.commands = { normal: new discord_js_1.Collection(), group: new discord_js_1.Collection() };
+
+    for (const key of Object.keys(this.interactions)) {
+      this.interactions[key].clear();
+    }
+  }
+
+  #storeInteraction(moduleData) {
+    const interaction = moduleData.data;
+
+    switch (interaction.type) {
+      case InteractionBuilder_js_1.Interactions.Autocomplete:
+        this.interactions.autocomplete.set(interaction.name, moduleData);
+        break;
+      case InteractionBuilder_js_1.Interactions.Button:
+        this.interactions.button.set(interaction.name, moduleData);
+        break;
+      case InteractionBuilder_js_1.Interactions.ChannelSelectMenu:
+        this.interactions.channelSelectMenu.set(interaction.name, moduleData);
+        break;
+      case InteractionBuilder_js_1.Interactions.ChatInput:
+        this.interactions.chatInput.set(interaction.name, moduleData);
+        break;
+      case InteractionBuilder_js_1.Interactions.MessageContextMenu:
+        this.interactions.messageContextMenu.set(interaction.name, moduleData);
+        break;
+      case InteractionBuilder_js_1.Interactions.Modal:
+        this.interactions.modalSubmit.set(interaction.name, moduleData);
+        break;
+      case InteractionBuilder_js_1.Interactions.RoleSelectMenu:
+        this.interactions.roleSelectMenu.set(interaction.name, moduleData);
+        break;
+      case InteractionBuilder_js_1.Interactions.StringSelectMenu:
+        this.interactions.stringSelectMenu.set(interaction.name, moduleData);
+        break;
+      case InteractionBuilder_js_1.Interactions.UserContextMenu:
+        this.interactions.userContextMenu.set(interaction.name, moduleData);
+        break;
+      case InteractionBuilder_js_1.Interactions.UserSelectMenu:
+        this.interactions.userSelectMenu.set(interaction.name, moduleData);
+        break;
+      case InteractionBuilder_js_1.Interactions.MentionableSelectMenu:
+        this.interactions.mentionableSelectMenu.set(interaction.name, moduleData);
+        break;
+      case InteractionBuilder_js_1.Interactions.AnyInteraction:
+        this.interactions.anyInteraction.set((0, crypto_1.randomUUID)(), moduleData);
+        break;
+      default:
+        break;
+    }
+  }
+
+  async load(dir, reload = false) {
+    const modules = [];
+    const absoluteDir = this.#toAbsolutePath(dir);
+
+    if (!(0, fs_1.existsSync)(absoluteDir)) {
+      throw new Error(`Path not found: ${absoluteDir}`);
+    }
+
+    if (reload) {
+      this.#clearEventHandlers();
+      this.#resetCollectionsForReload();
+    }
+
+    this.#collectModules(absoluteDir, reload, modules);
+
+    for (const moduleData of modules) {
+      if (moduleData.data instanceof EventBuilder_js_1.EventBuilder) {
+        this.#attachEvent(moduleData);
+        continue;
+      }
+
+      if (moduleData.data instanceof InteractionBuilder_js_1.InteractionBuilder) {
+        this.#storeInteraction(moduleData);
+        continue;
+      }
+
+      if (moduleData.data instanceof CommandBuilder_js_1.CommandBuilder) {
+        if (!this.commands.normal) this.commands.normal = new discord_js_1.Collection();
+        this.commands.normal.set(moduleData.data.name, moduleData);
+        continue;
+      }
+
+      if (moduleData.data instanceof GroupBuilder_js_1.GroupBuilder) {
+        if (!this.commands.group) this.commands.group = new discord_js_1.Collection();
+        this.commands.group.set(moduleData.data.name, moduleData);
+      }
+    }
+
+    return modules;
+  }
+
+  walkCommands(sorter = () => 0) {
+    const output = [];
+
+    if (this.commands.normal) {
+      output.push(...this.commands.normal.map((command) => ({ ...command, group: null })));
+    }
+
+    if (this.commands.group) {
+      for (const group of this.commands.group.values()) {
+        for (const command of group.data.commands) {
+          output.push({ ...command, group });
+        }
+      }
+    }
+
+    return output.sort(sorter);
+  }
+
+  #buildTopLevelSlash(command) {
+    const payload = { ...command.data.toJSON() };
+    payload.options = command.params?.params || [];
+    return payload;
+  }
+
+  #mergeGroupSlashPayload(payloads, groupRef, commandRef) {
+    const groupJSON = { ...groupRef.data.toJSON() };
+    const subCommandJSON = { ...commandRef.data.toJSON() };
+
+    subCommandJSON.type = 1;
+    subCommandJSON.options = commandRef.params?.params || [];
+
+    if (subCommandJSON.default_member_permissions === undefined && groupJSON.default_member_permissions !== undefined) {
+      subCommandJSON.default_member_permissions = groupJSON.default_member_permissions;
+    }
+
+    if (subCommandJSON.dm_permission === undefined && groupJSON.dm_permission !== undefined) {
+      subCommandJSON.dm_permission = groupJSON.dm_permission;
+    }
+
+    const existingIndex = payloads.findIndex((entry) => entry.name === groupJSON.name && entry.type === 1);
+
+    if (existingIndex >= 0) {
+      payloads[existingIndex].options ||= [];
+      payloads[existingIndex].options.push(subCommandJSON);
+      return;
+    }
+
+    const groupPayload = {
+      ...groupJSON,
+      type: 1,
+      options: [subCommandJSON],
+    };
+
+    payloads.push(groupPayload);
+  }
+
+  async sync(guildIDs) {
+    if (!this.client.token) {
+      throw new Error("Cannot sync application commands before login token is set.");
+    }
+
+    if (!this.client.user?.id) {
+      throw new Error("Cannot sync application commands before client is ready.");
+    }
+
+    this.rest.setToken(this.client.token);
+
+    const commands = this.walkCommands();
+    const payload = [];
+
+    for (const command of commands) {
+      if (!command.data.as_slash) continue;
+
+      if (!command.group) {
+        payload.push(this.#buildTopLevelSlash(command));
+        continue;
+      }
+
+      if (!command.group.data.as_slash) continue;
+      this.#mergeGroupSlashPayload(payload, command.group, command);
+    }
+
+    if (!guildIDs?.length) {
+      await this.rest.put(discord_js_1.Routes.applicationCommands(this.client.user.id), { body: payload });
+      return;
+    }
+
+    for (const guildID of guildIDs) {
+      await this.rest.put(discord_js_1.Routes.applicationGuildCommands(this.client.user.id, guildID), { body: payload });
+    }
+  }
+}
+exports.Loader = Loader;

package/lib/classes/Plugins.d.ts

@@ -0,0 +1,52 @@
+import { Context } from "./Context.js";
+import { ChannelType, PermissionsString } from "discord.js";
+import { Bucket } from "./Cooldowns.js";
+import { AsyncFunction } from "./Loader.js";
+/**
+ * Checks if the author is in a guild (Guild Only)
+ */
+export declare function isGuild(ctx: Context): boolean;
+/**
+ * Checks if the author is in specified channel types
+ * @param types The channel types
+ */
+export declare function isInChannelType(...types: ChannelType[]): (ctx: Context) => boolean;
+/**
+ * Checks if the author is in a NSFW channel
+ */
+export declare function isNSFW(ctx: Context): boolean;
+/**
+ * Checks if the author is a bot owner
+ */
+export declare function isOwner(ctx: Context): boolean;
+/**
+ * Checks if the bot has any of the specified permissions in this guild
+ * @param permissions The bot permissions
+ */
+export declare function hasAnyBotPerms(...permissions: PermissionsString[]): (ctx: Context) => boolean;
+/**
+ * Checks if the bot has ALL of the specified permissions in this guild
+ * @param permissions The required bot permissions
+ */
+export declare function hasBotPerms(...permissions: PermissionsString[]): (ctx: Context) => boolean;
+/**
+ * Checks if the author has any of the specified permissions in this guild
+ * @param permissions The author permissions
+ */
+export declare function hasAnyPerms(...permissions: PermissionsString[]): (ctx: Context) => boolean;
+/**
+ * Checks if the author has ALL of the specified permissions in this guild
+ * @param permissions The required author permissions
+ */
+export declare function hasPerms(...permissions: PermissionsString[]): (ctx: Context) => boolean;
+/**
+ * Checks if the Bucket has a cooldown in this command
+ * @param seconds The cooldown for this command
+ * @param bucket The type of object to set the cooldown, ex: Bucket.User, Bucket.Member
+ */
+export declare function cooldown(seconds: number, bucket: Bucket): (ctx: Context) => Promise<boolean>;
+/**
+ * Checks a custom condition using an async function
+ * @param predicate The async function
+ */
+export declare function check<T = Context>(predicate: AsyncFunction<T, boolean>): AsyncFunction<T, boolean>;

package/lib/classes/Plugins.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.check = exports.cooldown = exports.hasPerms = exports.hasAnyPerms = exports.hasBotPerms = exports.hasAnyBotPerms = exports.isOwner = exports.isNSFW = exports.isInChannelType = exports.isGuild = void 0;
+
+const discord_js_1 = require("discord.js");
+const tslib_1 = require("tslib");
+const Errors = tslib_1.__importStar(require("./Errors.js"));
+const Cooldowns_js_1 = require("./Cooldowns.js");
+
+function isGuild(ctx) {
+  if (ctx.channel?.type === discord_js_1.ChannelType.DM) throw new Errors.GuildOnly(ctx);
+  return true;
+}
+exports.isGuild = isGuild;
+
+function isInChannelType(...types) {
+  return function (ctx) {
+    if (ctx.channel && types.includes(ctx.channel.type)) return true;
+    throw new Errors.NotInChannelType(ctx, types, ctx.channel);
+  };
+}
+exports.isInChannelType = isInChannelType;
+
+function isNSFW(ctx) {
+  if (!ctx.channel || !("nsfw" in ctx.channel) || !ctx.channel.nsfw) {
+    throw new Errors.NotNSFW(ctx);
+  }
+
+  return true;
+}
+exports.isNSFW = isNSFW;
+
+function isOwner(ctx) {
+  if (ctx.bot.ops.owners?.includes(ctx.author.id)) return true;
+  throw new Errors.NotOwner(ctx);
+}
+exports.isOwner = isOwner;
+
+function hasAnyBotPerms(...permissions) {
+  return function (ctx) {
+    if (permissions.some((permission) => ctx.guild?.members.me?.permissions.has(permission))) return true;
+    throw new Errors.MissingBotPermission(ctx, permissions);
+  };
+}
+exports.hasAnyBotPerms = hasAnyBotPerms;
+
+function hasBotPerms(...permissions) {
+  return function (ctx) {
+    if (permissions.every((permission) => ctx.guild?.members.me?.permissions.has(permission))) return true;
+    throw new Errors.MissingBotPermission(ctx, permissions);
+  };
+}
+exports.hasBotPerms = hasBotPerms;
+
+function hasAnyPerms(...permissions) {
+  return function (ctx) {
+    if (permissions.some((permission) => ctx.member?.permissions?.has?.(permission))) return true;
+    throw new Errors.MissingPermission(ctx, permissions);
+  };
+}
+exports.hasAnyPerms = hasAnyPerms;
+
+function hasPerms(...permissions) {
+  return function (ctx) {
+    if (permissions.every((permission) => ctx.member?.permissions?.has?.(permission))) return true;
+    throw new Errors.MissingPermission(ctx, permissions);
+  };
+}
+exports.hasPerms = hasPerms;
+
+function cooldown(seconds, bucket) {
+  return async function (ctx) {
+    let source = "-1";
+
+    switch (bucket) {
+      case Cooldowns_js_1.Bucket.Guild:
+        source = ctx.guild?.id || "-1";
+        break;
+      case Cooldowns_js_1.Bucket.Member:
+        source = ctx.guild ? `${ctx.guild.id}_${ctx.author.id}` : ctx.author.id;
+        break;
+      case Cooldowns_js_1.Bucket.User:
+        source = ctx.author.id;
+        break;
+      case Cooldowns_js_1.Bucket.Channel:
+        source = ctx.channel?.id || "-1";
+        break;
+      default:
+        source = ctx.author.id;
+        break;
+    }
+
+    const cooldownInMs = 1000 * seconds;
+
+    const active = await ctx.bot.cooldowns.check(ctx.command.data.name, source, cooldownInMs, bucket);
+    if (active) throw new Errors.CommandInCooldown(ctx, active.left);
+
+    await ctx.bot.cooldowns.setCooldownSource(ctx.command.data.name, source, bucket, cooldownInMs);
+    return true;
+  };
+}
+exports.cooldown = cooldown;
+
+function check(predicate) {
+  return predicate;
+}
+exports.check = check;

package/lib/classes/Utils.d.ts

@@ -0,0 +1,25 @@
+import { Command, Types } from "../classes/Loader.js";
+import * as P from "./builders/ParamsBuilder.js";
+import { Context } from "./Context.js";
+import { Enire } from "./Client.js";
+import * as DJS from "discord.js";
+
+export declare class Utils {
+  static isType<T, R>(obj: any, func: (obj: R) => boolean): obj is T;
+  static noop(n?: null): null;
+  static getMember(query: string, options: { guild: DJS.Guild; force: boolean }): Promise<DJS.GuildMember | null>;
+  static getChannel<T = DJS.Channel>(query: string, options: { guild: DJS.Guild; force?: boolean }): Promise<T | null>;
+  static getRole(query: string, options: { guild: DJS.Guild; force?: boolean }): Promise<DJS.Role | null>;
+  static getUser(query: string, bot: Enire): Promise<DJS.User | null>;
+  static transform(input: string, param: P.BaseParam, ctx: Context, seeable?: boolean): Promise<{ break: boolean; value: any }>;
+  static executeCommand(
+    ctx: Context,
+    command: Command<Types.Normal>,
+    options: { group?: Command<Types.Group> | null; source: "prefix" | "slash"; args?: string[] | null; interaction?: DJS.ChatInputCommandInteraction | null; prefix?: string }
+  ): Promise<void>;
+  static handleMessage(bot: Enire, message: DJS.Message, isEdit?: boolean): Promise<void>;
+  static handleInteraction(bot: Enire, interaction: DJS.Interaction): Promise<void>;
+  static runPrefixCommand(ctx: Context, command: Command<Types.Normal>, args: string[], group?: Command<Types.Group>): Promise<void>;
+  static runInteractionCommand(ctx: Context, int: DJS.ChatInputCommandInteraction): Promise<void>;
+  static splitArgs(text: string, special?: boolean, removeNewLines?: boolean): string[];
+}