@spatulox/discord-module 0.1.0

package/README.md

@@ -0,0 +1,64 @@
+# Discord Module System
+
+An ultra-simple and fully type-safe TypeScript module system for Discord.js
+
+## 🚀 What’s it for ?
+
+Turn your Discord bot into independent modules that can be enabled or disabled at will.
+
+✨ Fonctionalities
+
+    🔗 Auto-binding : module.events → automatic client.on()
+
+    🎯 Free name : handleMessage() or myPingHandler() → you choose !
+
+    ⚡ Performance : Only declared event are bind
+
+    🔄 Hot reload : Enable/Disable problematic modules without restarting the bot !
+
+    Discordjs : Always up to date and completely compatible
+
+## 🎮 Usage (2 minutes)
+1. Module example
+```ts
+    export class PongModule extends Module {
+        public name: string = "Pong Module";
+        public description: string = "Reply with pong";
+        public get events(): ModuleEventsMap {
+            return {
+                [Events.MessageCreate]: this.handleMessage,
+                [Events.MessageUpdate]: [this.handleMessageUpdate1, this.handleMessageUpdate2],
+            }
+        }
+    
+        async handleMessage(message: Message) {
+            if(message.content == "!ping") {
+                message.reply("Pong !")
+            }
+        }
+    
+        async handleMessageUpdate1(message: Message) {
+            message.reply("Update 1 !")
+        }
+    
+        async handleMessageUpdate2(message: Message) {
+            message.reply("Update 2 !")
+        }
+    
+    }
+```
+2. Bot
+```ts
+client.once(Events.ClientReady, () => {
+    const manager = ModuleManager.createInstance(client); // ModuleManager is a singleton
+    manager.register(new PongModule(client)); // You can register a Module or a MultiModule (Menu for Module)
+    manager.enableAll(); // By default, a Module is disable
+    manager.sendUIToChannel("channelID") // Optionnal, only if you want to dynamically toggle modules
+});
+```
+
+| Functionnalities    | Without Modules  | With Module   |
+|---------------------|------------------|---------------|
+| Hidden client.on    | ❌                | ✅             |
+| Live module enabled | ❌ (Need restart) | ✅ (One click) |
+| Organised           | ❌                | ✅             |

package/dist/index.d.mts

@@ -0,0 +1,68 @@
+import { ClientEvents, SectionBuilder, InteractionReplyOptions, ContainerBuilder, ButtonInteraction, Client } from 'discord.js';
+
+type ModuleEventHandler = ((...args: any[]) => any) | ((...args: any[]) => any)[];
+type ModuleEventsMap = Partial<Record<keyof ClientEvents, ModuleEventHandler>>;
+declare abstract class Module {
+    private _parent;
+    abstract name: string;
+    abstract description: string;
+    private _enabled;
+    abstract get events(): ModuleEventsMap;
+    setParent(parent: string): void;
+    get parent(): string | "root";
+    createModuleUI(namePrefix?: string): SectionBuilder;
+    showModule(): InteractionReplyOptions;
+    get enabled(): boolean;
+    toggle(): void;
+    enable(): void;
+    disable(): void;
+}
+
+declare abstract class MultiModule extends Module {
+    private readonly manager;
+    abstract readonly subModules: Module[];
+    constructor();
+    get events(): ModuleEventsMap;
+    protected createSubmoduleUI(): ContainerBuilder;
+    showModule(): InteractionReplyOptions;
+    enable(interaction?: ButtonInteraction): void;
+    enableAll(interaction?: ButtonInteraction): Promise<void>;
+    disable(interaction?: ButtonInteraction): void;
+    disableAll(interaction?: ButtonInteraction): Promise<void>;
+    notifyChange(interaction?: ButtonInteraction): void;
+    isAnyEnabled(): boolean;
+}
+
+type ModuleMap = Record<string, Module[]>;
+declare class ModuleManager {
+    private _modules;
+    private client;
+    private static instance;
+    private static message;
+    private constructor();
+    static createInstance(client: Client): ModuleManager;
+    private static initClient;
+    static getInstance(): ModuleManager | null;
+    get modules(): ModuleMap;
+    register(module: Module | MultiModule): void;
+    private registerMod;
+    private createManagerUI;
+    private bindEvents;
+    enableAll(): void;
+    disableAll(): void;
+    getModule(name: string): Module | undefined;
+    get enabledCount(): number;
+    sendUIToChannel(channelID: string): Promise<void>;
+    /**
+     * Global update for the main message
+     */
+    private updateMainUI;
+    /**
+     * This update the MultiModule component when a single module is updated
+     * @param interaction
+     * @param module
+     */
+    updateMultiModuleUI(interaction: ButtonInteraction, module: Module): void;
+}
+
+export { Module, type ModuleEventsMap, ModuleManager, MultiModule };

package/dist/index.d.ts

@@ -0,0 +1,68 @@
+import { ClientEvents, SectionBuilder, InteractionReplyOptions, ContainerBuilder, ButtonInteraction, Client } from 'discord.js';
+
+type ModuleEventHandler = ((...args: any[]) => any) | ((...args: any[]) => any)[];
+type ModuleEventsMap = Partial<Record<keyof ClientEvents, ModuleEventHandler>>;
+declare abstract class Module {
+    private _parent;
+    abstract name: string;
+    abstract description: string;
+    private _enabled;
+    abstract get events(): ModuleEventsMap;
+    setParent(parent: string): void;
+    get parent(): string | "root";
+    createModuleUI(namePrefix?: string): SectionBuilder;
+    showModule(): InteractionReplyOptions;
+    get enabled(): boolean;
+    toggle(): void;
+    enable(): void;
+    disable(): void;
+}
+
+declare abstract class MultiModule extends Module {
+    private readonly manager;
+    abstract readonly subModules: Module[];
+    constructor();
+    get events(): ModuleEventsMap;
+    protected createSubmoduleUI(): ContainerBuilder;
+    showModule(): InteractionReplyOptions;
+    enable(interaction?: ButtonInteraction): void;
+    enableAll(interaction?: ButtonInteraction): Promise<void>;
+    disable(interaction?: ButtonInteraction): void;
+    disableAll(interaction?: ButtonInteraction): Promise<void>;
+    notifyChange(interaction?: ButtonInteraction): void;
+    isAnyEnabled(): boolean;
+}
+
+type ModuleMap = Record<string, Module[]>;
+declare class ModuleManager {
+    private _modules;
+    private client;
+    private static instance;
+    private static message;
+    private constructor();
+    static createInstance(client: Client): ModuleManager;
+    private static initClient;
+    static getInstance(): ModuleManager | null;
+    get modules(): ModuleMap;
+    register(module: Module | MultiModule): void;
+    private registerMod;
+    private createManagerUI;
+    private bindEvents;
+    enableAll(): void;
+    disableAll(): void;
+    getModule(name: string): Module | undefined;
+    get enabledCount(): number;
+    sendUIToChannel(channelID: string): Promise<void>;
+    /**
+     * Global update for the main message
+     */
+    private updateMainUI;
+    /**
+     * This update the MultiModule component when a single module is updated
+     * @param interaction
+     * @param module
+     */
+    updateMultiModuleUI(interaction: ButtonInteraction, module: Module): void;
+}
+
+export { Module, type ModuleEventsMap, ModuleManager, MultiModule };

package/dist/index.js

@@ -0,0 +1,303 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Module: () => Module,
+  ModuleManager: () => ModuleManager,
+  MultiModule: () => MultiModule
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/code/Module.ts
+var import_discord = require("discord.js");
+var Module = class {
+  constructor() {
+    this._parent = "root";
+    this._enabled = false;
+  }
+  setParent(parent) {
+    this._parent = parent;
+  }
+  get parent() {
+    return this._parent;
+  }
+  createModuleUI(namePrefix) {
+    const namePrefixStr = namePrefix ? `${namePrefix}_` : "";
+    const name = `${namePrefixStr}toggle_${this.name.toLowerCase()}`;
+    if (name.length > 100) {
+      throw new Error(`In order to create the Module UI, buttons customId should not be more than 100 char, please reduce the name of your Module : ${this.name}`);
+    }
+    return new import_discord.SectionBuilder().addTextDisplayComponents(new import_discord.TextDisplayBuilder().setContent(`## ${this.enabled ? "\u{1F7E2}" : "\u{1F534}"} ${this.name}`)).addTextDisplayComponents(new import_discord.TextDisplayBuilder().setContent(`${this.description}`)).setButtonAccessory(new import_discord.ButtonBuilder().setLabel(this.enabled ? "Disabled" : "Enable").setCustomId(name).setStyle(this.enabled ? import_discord.ButtonStyle.Danger : import_discord.ButtonStyle.Success));
+  }
+  showModule() {
+    return {
+      components: [new import_discord.ContainerBuilder().addSectionComponents(this.createModuleUI())],
+      flags: import_discord.MessageFlags.IsComponentsV2
+    };
+  }
+  get enabled() {
+    return this._enabled;
+  }
+  toggle() {
+    this._enabled = !this._enabled;
+  }
+  enable() {
+    this._enabled = true;
+  }
+  disable() {
+    this._enabled = false;
+  }
+};
+
+// src/code/ModuleManager.ts
+var import_discord2 = require("discord.js");
+var _ModuleManager = class _ModuleManager {
+  constructor(client) {
+    this._modules = {};
+    this.client = client;
+  }
+  static createInstance(client) {
+    _ModuleManager.instance = new _ModuleManager(client);
+    this.initClient(client);
+    return _ModuleManager.instance;
+  }
+  static initClient(client) {
+    client.on(import_discord2.Events.InteractionCreate, async (interaction) => {
+      if (interaction.isButton()) {
+        const custID = interaction.customId;
+        console.log(custID);
+        const manager = _ModuleManager.getInstance();
+        if (custID.startsWith("toggle_")) {
+          const module2 = manager?.getModule(custID.split("toggle_")[1]);
+          if (module2 instanceof MultiModule) {
+            interaction.reply(module2.showModule());
+          } else if (module2 instanceof Module) {
+            module2.toggle();
+            manager?.updateMultiModuleUI(interaction, module2);
+          }
+        } else if (custID.startsWith("all_")) {
+          const module2 = manager?.getModule(custID.split("toggle_")[1]);
+          if (module2 instanceof MultiModule) {
+            module2.enabled ? await module2.disableAll(interaction) : await module2.enableAll(interaction);
+            manager?.updateMultiModuleUI(interaction, module2);
+          }
+          console.log(module2);
+        }
+      }
+    });
+  }
+  static getInstance() {
+    return _ModuleManager.instance;
+  }
+  get modules() {
+    return this._modules;
+  }
+  register(module2) {
+    if (this.getModule(module2.name)) {
+      throw new Error(`Duplicate Module name : '${module2.name}' already exist`);
+    }
+    if (module2 instanceof MultiModule) {
+      this.registerMod(module2);
+      for (const mod of module2.subModules) {
+        mod.setParent(module2.name);
+        if (mod instanceof MultiModule) {
+          throw new Error(`The Multi Module "${module2.name}" cannot have a Multi Module as a Module : ${mod.name}`);
+        }
+        this.registerMod(mod);
+      }
+      return;
+    }
+    this.registerMod(module2);
+  }
+  registerMod(module2) {
+    if (!this._modules[module2.parent]) {
+      this._modules[module2.parent] = [];
+    }
+    this._modules[module2.parent].push(module2);
+    this.bindEvents(module2);
+  }
+  createManagerUI() {
+    const container = new import_discord2.ContainerBuilder();
+    container.addTextDisplayComponents(new import_discord2.TextDisplayBuilder().setContent(`# Module Manager`)).addTextDisplayComponents(new import_discord2.TextDisplayBuilder().setContent(`You can enable/disable any module`)).addSeparatorComponents(new import_discord2.SeparatorBuilder().setDivider(true).setSpacing(import_discord2.SeparatorSpacingSize.Large));
+    for (const module2 of this._modules["root"]) {
+      container.addSectionComponents(module2.createModuleUI());
+    }
+    return container;
+  }
+  bindEvents(module2) {
+    const eventsMap = module2.events;
+    for (const [eventName, method] of Object.entries(eventsMap)) {
+      if (typeof method === "function") {
+        this.client?.on(eventName, async (...args) => {
+          if (module2.enabled) {
+            await method(...args);
+          }
+        });
+      } else if (Array.isArray(method)) {
+        for (const handler of method) {
+          if (typeof handler === "function") {
+            this.client?.on(eventName, async (...args) => {
+              if (module2.enabled) {
+                await handler(...args);
+              }
+            });
+          }
+        }
+      }
+    }
+  }
+  enableAll() {
+    Object.values(this._modules).forEach(
+      (modules) => modules.forEach((mod) => mod.enable())
+    );
+  }
+  disableAll() {
+    Object.values(this._modules).forEach(
+      (modules) => modules.forEach((mod) => mod.disable())
+    );
+  }
+  getModule(name) {
+    for (const parentModules of Object.values(this._modules)) {
+      const found = parentModules.find(
+        (m) => m.name.toLowerCase() === name.toLowerCase()
+      );
+      if (found) return found;
+    }
+  }
+  get enabledCount() {
+    return Object.values(this._modules).flat().filter((m) => m.enabled).length;
+  }
+  async sendUIToChannel(channelID) {
+    const channel = this.client?.channels.cache.get(channelID) || await this.client?.channels.fetch(channelID);
+    if (!channel) {
+      throw new Error(`Channel (${channelID}) does not exist or is unavailable`);
+    }
+    if (channel.isTextBased() && channel.isSendable()) {
+      _ModuleManager.message = await channel.send({
+        components: [this.createManagerUI()],
+        flags: import_discord2.MessageFlags.IsComponentsV2
+      });
+      return;
+    }
+    throw new Error(`Channel (${channelID}) does not exist or is not a valid sendable channel`);
+  }
+  /**
+   * Global update for the main message
+   */
+  async updateMainUI() {
+    const m = {
+      components: [this.createManagerUI()]
+    };
+    await _ModuleManager.message?.edit(m);
+  }
+  /**
+   * This update the MultiModule component when a single module is updated
+   * @param interaction
+   * @param module
+   */
+  updateMultiModuleUI(interaction, module2) {
+    const manager = _ModuleManager.getInstance();
+    if (manager) {
+      if (module2.parent == "root") {
+        this.updateMainUI();
+      }
+      const parentMod = manager.getModule(module2.parent);
+      if (!parentMod || !(parentMod instanceof MultiModule)) {
+        if (!(module2 instanceof MultiModule)) {
+          interaction.deferUpdate();
+        }
+        return;
+      }
+      parentMod.notifyChange(interaction);
+      return;
+    }
+    console.error("No existing manager");
+  }
+};
+_ModuleManager.message = null;
+var ModuleManager = _ModuleManager;
+
+// src/code/MultiModule.ts
+var import_discord3 = require("discord.js");
+var MultiModule = class extends Module {
+  constructor() {
+    super();
+    const inst = ModuleManager.getInstance();
+    if (inst) {
+      this.manager = inst;
+    } else {
+      throw new Error("Module Manager Instance is null");
+    }
+  }
+  get events() {
+    return [];
+  }
+  createSubmoduleUI() {
+    const container = new import_discord3.ContainerBuilder();
+    container.addSectionComponents(this.createModuleUI("all"));
+    container.addSeparatorComponents(new import_discord3.SeparatorBuilder().setSpacing(import_discord3.SeparatorSpacingSize.Large).setDivider(true));
+    for (const module2 of this.subModules) {
+      container.addSectionComponents(module2.createModuleUI());
+    }
+    return container;
+  }
+  showModule() {
+    return {
+      components: [this.createSubmoduleUI()],
+      flags: [import_discord3.MessageFlags.IsComponentsV2, import_discord3.MessageFlags.Ephemeral]
+    };
+  }
+  enable(interaction) {
+    super.enable();
+    this.notifyChange(interaction);
+  }
+  async enableAll(interaction) {
+    this.subModules.forEach((module2) => {
+      module2.enable();
+    });
+    this.enable(interaction);
+  }
+  disable(interaction) {
+    super.disable();
+    this.notifyChange(interaction);
+  }
+  async disableAll(interaction) {
+    this.subModules.forEach((module2) => {
+      module2.disable();
+    });
+    this.disable(interaction);
+  }
+  notifyChange(interaction) {
+    if (!interaction) return;
+    interaction.update({
+      components: [this.createSubmoduleUI()]
+    });
+  }
+  isAnyEnabled() {
+    return Object.values(this.manager.modules).flat().some((m) => m.enabled);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Module,
+  ModuleManager,
+  MultiModule
+});

package/dist/index.mjs

@@ -0,0 +1,293 @@
+// src/code/Module.ts
+import {
+  ButtonBuilder,
+  ButtonStyle,
+  ContainerBuilder,
+  MessageFlags,
+  SectionBuilder,
+  TextDisplayBuilder
+} from "discord.js";
+var Module = class {
+  constructor() {
+    this._parent = "root";
+    this._enabled = false;
+  }
+  setParent(parent) {
+    this._parent = parent;
+  }
+  get parent() {
+    return this._parent;
+  }
+  createModuleUI(namePrefix) {
+    const namePrefixStr = namePrefix ? `${namePrefix}_` : "";
+    const name = `${namePrefixStr}toggle_${this.name.toLowerCase()}`;
+    if (name.length > 100) {
+      throw new Error(`In order to create the Module UI, buttons customId should not be more than 100 char, please reduce the name of your Module : ${this.name}`);
+    }
+    return new SectionBuilder().addTextDisplayComponents(new TextDisplayBuilder().setContent(`## ${this.enabled ? "\u{1F7E2}" : "\u{1F534}"} ${this.name}`)).addTextDisplayComponents(new TextDisplayBuilder().setContent(`${this.description}`)).setButtonAccessory(new ButtonBuilder().setLabel(this.enabled ? "Disabled" : "Enable").setCustomId(name).setStyle(this.enabled ? ButtonStyle.Danger : ButtonStyle.Success));
+  }
+  showModule() {
+    return {
+      components: [new ContainerBuilder().addSectionComponents(this.createModuleUI())],
+      flags: MessageFlags.IsComponentsV2
+    };
+  }
+  get enabled() {
+    return this._enabled;
+  }
+  toggle() {
+    this._enabled = !this._enabled;
+  }
+  enable() {
+    this._enabled = true;
+  }
+  disable() {
+    this._enabled = false;
+  }
+};
+
+// src/code/ModuleManager.ts
+import {
+  ContainerBuilder as ContainerBuilder2,
+  Events,
+  MessageFlags as MessageFlags2,
+  SeparatorBuilder,
+  SeparatorSpacingSize,
+  TextDisplayBuilder as TextDisplayBuilder2
+} from "discord.js";
+var _ModuleManager = class _ModuleManager {
+  constructor(client) {
+    this._modules = {};
+    this.client = client;
+  }
+  static createInstance(client) {
+    _ModuleManager.instance = new _ModuleManager(client);
+    this.initClient(client);
+    return _ModuleManager.instance;
+  }
+  static initClient(client) {
+    client.on(Events.InteractionCreate, async (interaction) => {
+      if (interaction.isButton()) {
+        const custID = interaction.customId;
+        console.log(custID);
+        const manager = _ModuleManager.getInstance();
+        if (custID.startsWith("toggle_")) {
+          const module = manager?.getModule(custID.split("toggle_")[1]);
+          if (module instanceof MultiModule) {
+            interaction.reply(module.showModule());
+          } else if (module instanceof Module) {
+            module.toggle();
+            manager?.updateMultiModuleUI(interaction, module);
+          }
+        } else if (custID.startsWith("all_")) {
+          const module = manager?.getModule(custID.split("toggle_")[1]);
+          if (module instanceof MultiModule) {
+            module.enabled ? await module.disableAll(interaction) : await module.enableAll(interaction);
+            manager?.updateMultiModuleUI(interaction, module);
+          }
+          console.log(module);
+        }
+      }
+    });
+  }
+  static getInstance() {
+    return _ModuleManager.instance;
+  }
+  get modules() {
+    return this._modules;
+  }
+  register(module) {
+    if (this.getModule(module.name)) {
+      throw new Error(`Duplicate Module name : '${module.name}' already exist`);
+    }
+    if (module instanceof MultiModule) {
+      this.registerMod(module);
+      for (const mod of module.subModules) {
+        mod.setParent(module.name);
+        if (mod instanceof MultiModule) {
+          throw new Error(`The Multi Module "${module.name}" cannot have a Multi Module as a Module : ${mod.name}`);
+        }
+        this.registerMod(mod);
+      }
+      return;
+    }
+    this.registerMod(module);
+  }
+  registerMod(module) {
+    if (!this._modules[module.parent]) {
+      this._modules[module.parent] = [];
+    }
+    this._modules[module.parent].push(module);
+    this.bindEvents(module);
+  }
+  createManagerUI() {
+    const container = new ContainerBuilder2();
+    container.addTextDisplayComponents(new TextDisplayBuilder2().setContent(`# Module Manager`)).addTextDisplayComponents(new TextDisplayBuilder2().setContent(`You can enable/disable any module`)).addSeparatorComponents(new SeparatorBuilder().setDivider(true).setSpacing(SeparatorSpacingSize.Large));
+    for (const module of this._modules["root"]) {
+      container.addSectionComponents(module.createModuleUI());
+    }
+    return container;
+  }
+  bindEvents(module) {
+    const eventsMap = module.events;
+    for (const [eventName, method] of Object.entries(eventsMap)) {
+      if (typeof method === "function") {
+        this.client?.on(eventName, async (...args) => {
+          if (module.enabled) {
+            await method(...args);
+          }
+        });
+      } else if (Array.isArray(method)) {
+        for (const handler of method) {
+          if (typeof handler === "function") {
+            this.client?.on(eventName, async (...args) => {
+              if (module.enabled) {
+                await handler(...args);
+              }
+            });
+          }
+        }
+      }
+    }
+  }
+  enableAll() {
+    Object.values(this._modules).forEach(
+      (modules) => modules.forEach((mod) => mod.enable())
+    );
+  }
+  disableAll() {
+    Object.values(this._modules).forEach(
+      (modules) => modules.forEach((mod) => mod.disable())
+    );
+  }
+  getModule(name) {
+    for (const parentModules of Object.values(this._modules)) {
+      const found = parentModules.find(
+        (m) => m.name.toLowerCase() === name.toLowerCase()
+      );
+      if (found) return found;
+    }
+  }
+  get enabledCount() {
+    return Object.values(this._modules).flat().filter((m) => m.enabled).length;
+  }
+  async sendUIToChannel(channelID) {
+    const channel = this.client?.channels.cache.get(channelID) || await this.client?.channels.fetch(channelID);
+    if (!channel) {
+      throw new Error(`Channel (${channelID}) does not exist or is unavailable`);
+    }
+    if (channel.isTextBased() && channel.isSendable()) {
+      _ModuleManager.message = await channel.send({
+        components: [this.createManagerUI()],
+        flags: MessageFlags2.IsComponentsV2
+      });
+      return;
+    }
+    throw new Error(`Channel (${channelID}) does not exist or is not a valid sendable channel`);
+  }
+  /**
+   * Global update for the main message
+   */
+  async updateMainUI() {
+    const m = {
+      components: [this.createManagerUI()]
+    };
+    await _ModuleManager.message?.edit(m);
+  }
+  /**
+   * This update the MultiModule component when a single module is updated
+   * @param interaction
+   * @param module
+   */
+  updateMultiModuleUI(interaction, module) {
+    const manager = _ModuleManager.getInstance();
+    if (manager) {
+      if (module.parent == "root") {
+        this.updateMainUI();
+      }
+      const parentMod = manager.getModule(module.parent);
+      if (!parentMod || !(parentMod instanceof MultiModule)) {
+        if (!(module instanceof MultiModule)) {
+          interaction.deferUpdate();
+        }
+        return;
+      }
+      parentMod.notifyChange(interaction);
+      return;
+    }
+    console.error("No existing manager");
+  }
+};
+_ModuleManager.message = null;
+var ModuleManager = _ModuleManager;
+
+// src/code/MultiModule.ts
+import {
+  ContainerBuilder as ContainerBuilder3,
+  MessageFlags as MessageFlags3,
+  SeparatorBuilder as SeparatorBuilder2,
+  SeparatorSpacingSize as SeparatorSpacingSize2
+} from "discord.js";
+var MultiModule = class extends Module {
+  constructor() {
+    super();
+    const inst = ModuleManager.getInstance();
+    if (inst) {
+      this.manager = inst;
+    } else {
+      throw new Error("Module Manager Instance is null");
+    }
+  }
+  get events() {
+    return [];
+  }
+  createSubmoduleUI() {
+    const container = new ContainerBuilder3();
+    container.addSectionComponents(this.createModuleUI("all"));
+    container.addSeparatorComponents(new SeparatorBuilder2().setSpacing(SeparatorSpacingSize2.Large).setDivider(true));
+    for (const module of this.subModules) {
+      container.addSectionComponents(module.createModuleUI());
+    }
+    return container;
+  }
+  showModule() {
+    return {
+      components: [this.createSubmoduleUI()],
+      flags: [MessageFlags3.IsComponentsV2, MessageFlags3.Ephemeral]
+    };
+  }
+  enable(interaction) {
+    super.enable();
+    this.notifyChange(interaction);
+  }
+  async enableAll(interaction) {
+    this.subModules.forEach((module) => {
+      module.enable();
+    });
+    this.enable(interaction);
+  }
+  disable(interaction) {
+    super.disable();
+    this.notifyChange(interaction);
+  }
+  async disableAll(interaction) {
+    this.subModules.forEach((module) => {
+      module.disable();
+    });
+    this.disable(interaction);
+  }
+  notifyChange(interaction) {
+    if (!interaction) return;
+    interaction.update({
+      components: [this.createSubmoduleUI()]
+    });
+  }
+  isAnyEnabled() {
+    return Object.values(this.manager.modules).flat().some((m) => m.enabled);
+  }
+};
+export {
+  Module,
+  ModuleManager,
+  MultiModule
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@spatulox/discord-module",
+  "version": "0.1.0",
+  "description": "Automatic Module Manager for Discordjs",
+  "main": "dist/index.js",
+  "scripts": {
+    "type-check": "tsc --noEmit",
+    "build": "npm run type-check && rm -rf ./dist/ && tsup",
+    "dev": "npm run type-check && tsx  watch src/test/index.ts",
+    "patch": "npm run build && npm version patch",
+    "minor": "npm run build && npm version minor",
+    "major": "npm run build && npm version major",
+    "pub:patch": "npm run patch && npm publish --access public",
+    "pub:minor": "npm run minor && npm publish --access public",
+    "pub:major": "npm run major && npm publish --access public"
+  },
+  "dependencies": {
+    "discord.js": "^14.25.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.0",
+    "dotenv": "^17.3.1",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.5.3"
+  },
+  "keywords": [
+    "discordjs",
+    "discord",
+    "framwork",
+    "modules"
+  ],
+  "author": "Spatulox",
+  "license": "MIT"
+}