@stelliajs/framework 1.5.3 → 1.5.6

package/README.md

@@ -11,7 +11,6 @@ Recommended architecture for StelliaJS project.
 
 ```
 .
-├── dist // Build folder
 ├── src/
 │   ├── commands/
 │   │   ├── contextMenus/
@@ -41,7 +40,7 @@ Recommended architecture for StelliaJS project.
 │   └── index.ts
 ├── .env
 ├── package.json
-├── package-lock.json
+├── pnpm-lock.yaml
 ├── stellia.json
 └── tsconfig.json
 ```

package/dist/client/StelliaClient.d.ts

@@ -2,20 +2,23 @@ import { Client, type ClientOptions, type Interaction } from "discord.js";
 import { type ManagerOptions } from "../managers/index.js";
 import { type ClientEnvironment, type GuildConfiguration, type GuildsConfiguration, type Managers } from "../typescript/index.js";
 export declare class StelliaClient<Ready extends boolean = boolean> extends Client<Ready> {
-    private readonly utils;
+    private utils;
     readonly managers: Managers;
-    readonly environment: ClientEnvironment;
-    constructor(clientOptions: ClientOptions, stelliaOptions?: StelliaOptions);
+    readonly environment?: ClientEnvironment;
+    private constructor();
+    static create(clientOptions: ClientOptions, stelliaOptions?: StelliaOptions): Promise<StelliaClient>;
     connect: (token: string) => Promise<void>;
     initializeCommands: () => Promise<void>;
     getGuildsConfiguration: <CustomGuildsConfiguration extends GuildsConfiguration>() => Promise<CustomGuildsConfiguration>;
     getGuildConfiguration: <CustomGuildConfiguration extends GuildConfiguration>(guildId: string) => CustomGuildConfiguration | undefined;
     handleInteraction: (interaction: Interaction<"cached">) => Promise<void>;
-    private areManagersLoaded;
-    private static convertFilePathToProduction;
+    private initializeAsyncFields;
+    private initializeManagers;
+    private readonly areManagersLoaded;
+    private static readonly convertFilePathToProduction;
 }
 interface StelliaOptions {
-    managers: {
+    managers?: {
         autoCompletes?: ManagerOptions;
         buttons?: ManagerOptions;
         commands?: ManagerOptions;

package/dist/client/StelliaClient.js

@@ -1,6 +1,6 @@
-import * as fs from "node:fs";
-import path from "path";
-import { pathToFileURL } from "url";
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
 import { Client } from "discord.js";
 import { StelliaUtils } from "./index.js";
 import { AutoCompleteManager, ButtonManager, CommandManager, ContextMenuManager, EventManager, ModalManager, SelectMenuManager } from "../managers/index.js";
@@ -14,28 +14,6 @@ export class StelliaClient extends Client {
         if (stelliaOptions?.environment) {
             this.environment = stelliaOptions.environment;
         }
-        if (stelliaOptions?.managers.autoCompletes?.directoryPath) {
-            this.managers.autoCompletes = new AutoCompleteManager(this, stelliaOptions.managers.autoCompletes.directoryPath);
-        }
-        if (stelliaOptions?.managers.buttons?.directoryPath) {
-            this.managers.buttons = new ButtonManager(this, stelliaOptions.managers.buttons.directoryPath);
-        }
-        if (stelliaOptions?.managers.commands?.directoryPath) {
-            this.managers.commands = new CommandManager(this, stelliaOptions.managers.commands.directoryPath);
-        }
-        if (stelliaOptions?.managers.contextMenus?.directoryPath) {
-            this.managers.contextMenus = new ContextMenuManager(this, stelliaOptions.managers.contextMenus.directoryPath);
-        }
-        if (stelliaOptions?.managers.events?.directoryPath) {
-            this.managers.events = new EventManager(this, stelliaOptions.managers.events.directoryPath);
-        }
-        if (stelliaOptions?.managers.selectMenus?.directoryPath) {
-            this.managers.selectMenus = new SelectMenuManager(this, stelliaOptions.managers.selectMenus.directoryPath);
-        }
-        if (stelliaOptions?.managers.modals?.directoryPath) {
-            this.managers.modals = new ModalManager(this, stelliaOptions.managers.modals.directoryPath);
-        }
-        this.utils = new StelliaUtils(this);
         process.on("unhandledRejection", (error) => {
             logger.error(`Unhandled promise rejection: ${error.stack}`);
         });
@@ -43,6 +21,11 @@ export class StelliaClient extends Client {
             logger.error(`Uncaught exception: ${error.stack}`);
         });
     }
+    static async create(clientOptions, stelliaOptions) {
+        const client = new StelliaClient(clientOptions, stelliaOptions);
+        await client.initializeAsyncFields(stelliaOptions);
+        return client;
+    }
     connect = async (token) => {
         if (!this.areManagersLoaded()) {
             setTimeout(() => {
@@ -67,24 +50,20 @@ export class StelliaClient extends Client {
         return new Promise((resolve, reject) => {
             fs.readFile(filePath, async (err, data) => {
                 if (err) {
-                    return reject(err);
+                    return reject(new Error("stellia.json file not found"));
                 }
-                try {
-                    const environments = JSON.parse(data.toString()).environments;
-                    if (!Object.keys(environments).includes(chosenEnvironment)) {
-                        return reject(new Error("Invalid environment"));
-                    }
-                    const environmentData = environments[chosenEnvironment];
-                    const environmentPath = environmentData.production
-                        ? StelliaClient.convertFilePathToProduction(environmentData.file)
-                        : environmentData.file;
-                    const environmentAbsolutePath = pathToFileURL(path.join(srcPath, "..", environmentPath)).href;
-                    const environmentFile = await import(environmentAbsolutePath);
-                    resolve(environmentFile.environment);
-                }
-                catch (error) {
-                    reject(error);
+                const environments = JSON.parse(data.toString()).environments;
+                if (!Object.keys(environments).includes(chosenEnvironment)) {
+                    return reject(new Error("Invalid environment"));
                 }
+                const environmentData = environments[chosenEnvironment];
+                const environmentPath = environmentData.production
+                    ? StelliaClient.convertFilePathToProduction(environmentData.file)
+                    : environmentData.file;
+                const environmentAbsolutePath = pathToFileURL(path.join(srcPath, "..", environmentPath)).href;
+                import(environmentAbsolutePath)
+                    .then((environmentFile) => resolve(environmentFile.environment))
+                    .catch(() => reject(new Error("Error parsing stellia.json file")));
             });
         });
     };
@@ -94,6 +73,38 @@ export class StelliaClient extends Client {
     handleInteraction = async (interaction) => {
         await this.utils.handleInteraction(interaction);
     };
+    async initializeAsyncFields(stelliaOptions) {
+        this.utils = await StelliaUtils.create(this);
+        await this.initializeManagers(stelliaOptions?.managers);
+    }
+    ;
+    async initializeManagers(managers) {
+        if (!managers) {
+            return;
+        }
+        if (managers.autoCompletes?.directoryPath) {
+            this.managers.autoCompletes = await AutoCompleteManager.create(this, managers.autoCompletes.directoryPath);
+        }
+        if (managers.buttons?.directoryPath) {
+            this.managers.buttons = await ButtonManager.create(this, managers.buttons.directoryPath);
+        }
+        if (managers.commands?.directoryPath) {
+            this.managers.commands = await CommandManager.create(this, managers.commands.directoryPath);
+        }
+        if (managers.contextMenus?.directoryPath) {
+            this.managers.contextMenus = await ContextMenuManager.create(this, managers.contextMenus.directoryPath);
+        }
+        if (managers.events?.directoryPath) {
+            this.managers.events = await EventManager.create(this, managers.events.directoryPath);
+        }
+        if (managers.selectMenus?.directoryPath) {
+            this.managers.selectMenus = await SelectMenuManager.create(this, managers.selectMenus.directoryPath);
+        }
+        if (managers.modals?.directoryPath) {
+            this.managers.modals = await ModalManager.create(this, managers.modals.directoryPath);
+        }
+    }
+    ;
     areManagersLoaded = () => {
         const managers = Object.values(this.managers);
         return managers.length === 0

package/dist/client/StelliaUtils.d.ts

@@ -5,17 +5,19 @@ export declare class StelliaUtils {
     readonly client: StelliaClient;
     private readonly interactionHandlers;
     private guildsConfiguration;
-    constructor(client: StelliaClient);
+    private constructor();
+    static create(client: StelliaClient): Promise<StelliaUtils>;
     initializeCommands: () => Promise<void>;
     getGuildConfiguration: <CustomGuildConfiguration extends GuildConfiguration>(guildId: string) => CustomGuildConfiguration | undefined;
     handleInteraction: (interaction: Interaction<"cached">) => Promise<void>;
-    private handleAutoCompleteInteraction;
-    private handleButtonInteraction;
-    private handleCommandInteraction;
-    private handleContextMenuInteraction;
-    private handleModalInteraction;
-    private handleSelectMenuInteraction;
-    private handleMessageContextMenuInteraction;
-    private handleUserContextMenuInteraction;
+    private initializeGuildsConfiguration;
+    private readonly handleAutoCompleteInteraction;
+    private readonly handleButtonInteraction;
+    private readonly handleCommandInteraction;
+    private readonly handleContextMenuInteraction;
+    private readonly handleModalInteraction;
+    private readonly handleSelectMenuInteraction;
+    private readonly handleMessageContextMenuInteraction;
+    private readonly handleUserContextMenuInteraction;
     private getInteractionType;
 }

package/dist/client/StelliaUtils.js

@@ -16,16 +16,14 @@ export class StelliaUtils {
             [InteractionType.ModalSubmit, this.handleModalInteraction],
             [InteractionType.SelectMenu, this.handleSelectMenuInteraction]
         ]);
-        if (this.client.environment.areGuildsConfigurationEnabled) {
-            this.client
-                .getGuildsConfiguration()
-                .then((guildsConfiguration) => {
-                this.guildsConfiguration = guildsConfiguration;
-                logger.success("Guilds configuration loaded successfully for interactions");
-            })
-                .catch((error) => logger.error(`Error while loading guilds configuration: ${error.stack}`));
-        }
     }
+    ;
+    static async create(client) {
+        const utils = new StelliaUtils(client);
+        await utils.initializeGuildsConfiguration();
+        return utils;
+    }
+    ;
     initializeCommands = async () => {
         const commands = this.client.managers.commands?.getAll().values();
         const contextMenus = this.client.managers.contextMenus?.getAll().values();
@@ -44,7 +42,7 @@ export class StelliaUtils {
         }
     };
     getGuildConfiguration = (guildId) => {
-        if (!this.client.environment.areGuildsConfigurationEnabled || !this.guildsConfiguration) {
+        if (!this.client.environment?.areGuildsConfigurationEnabled || !this.guildsConfiguration) {
             return undefined;
         }
         const { guilds, general } = this.guildsConfiguration;
@@ -66,6 +64,19 @@ export class StelliaUtils {
             }
         }
     };
+    async initializeGuildsConfiguration() {
+        if (this.client.environment?.areGuildsConfigurationEnabled) {
+            try {
+                const guildsConfiguration = await this.client.getGuildsConfiguration();
+                this.guildsConfiguration = guildsConfiguration;
+                logger.success("Guilds configuration loaded successfully for interactions");
+            }
+            catch (error) {
+                logger.error(`Error while loading guilds configuration: ${error.stack}`);
+            }
+        }
+    }
+    ;
     handleAutoCompleteInteraction = async (interaction) => {
         try {
             const autoCompleteInteraction = interaction;
@@ -75,7 +86,7 @@ export class StelliaUtils {
             const autoComplete = autoCompleteManager.getByCustomId(autoCompleteInteraction.commandName);
             if (!autoComplete)
                 return;
-            if (this.client.environment.areGuildsConfigurationEnabled) {
+            if (this.client.environment?.areGuildsConfigurationEnabled) {
                 const autoCompleteWithGuildConfiguration = autoComplete;
                 const guildConfiguration = this.getGuildConfiguration(autoCompleteInteraction.guildId);
                 await autoCompleteWithGuildConfiguration.execute(this.client, guildConfiguration, autoCompleteInteraction);
@@ -102,7 +113,7 @@ export class StelliaUtils {
             if (button.data.reply.autoDefer && !buttonInteraction.deferred) {
                 await buttonInteraction.deferReply({ flags: button.data.reply.ephemeral ? MessageFlags.Ephemeral : undefined });
             }
-            if (this.client.environment.areGuildsConfigurationEnabled) {
+            if (this.client.environment?.areGuildsConfigurationEnabled) {
                 const buttonWithGuildConfiguration = button;
                 const guildConfiguration = this.getGuildConfiguration(buttonInteraction.guildId);
                 await buttonWithGuildConfiguration.execute(this.client, guildConfiguration, buttonInteraction);
@@ -128,7 +139,7 @@ export class StelliaUtils {
             if (command.data.reply.autoDefer && !commandInteraction.deferred) {
                 await commandInteraction.deferReply({ flags: command.data.reply.ephemeral ? MessageFlags.Ephemeral : undefined });
             }
-            if (this.client.environment.areGuildsConfigurationEnabled) {
+            if (this.client.environment?.areGuildsConfigurationEnabled) {
                 const commandWithGuildConfiguration = command;
                 const guildConfiguration = this.getGuildConfiguration(commandInteraction.guildId);
                 await commandWithGuildConfiguration.execute(this.client, guildConfiguration, commandInteraction);
@@ -171,7 +182,7 @@ export class StelliaUtils {
             if (modal.data.reply.autoDefer && !modalInteraction.deferred) {
                 await modalInteraction.deferReply({ flags: modal.data.reply.ephemeral ? MessageFlags.Ephemeral : undefined });
             }
-            if (this.client.environment.areGuildsConfigurationEnabled) {
+            if (this.client.environment?.areGuildsConfigurationEnabled) {
                 const modalWithGuildConfiguration = modal;
                 const guildConfiguration = this.getGuildConfiguration(modalInteraction.guildId);
                 await modalWithGuildConfiguration.execute(this.client, guildConfiguration, modalInteraction);
@@ -198,7 +209,7 @@ export class StelliaUtils {
             if (selectMenu.data.reply.autoDefer && !selectMenuInteraction.deferred) {
                 await selectMenuInteraction.deferReply({ flags: selectMenu.data.reply.ephemeral ? MessageFlags.Ephemeral : undefined });
             }
-            if (this.client.environment.areGuildsConfigurationEnabled) {
+            if (this.client.environment?.areGuildsConfigurationEnabled) {
                 const selectMenuWithGuildConfiguration = selectMenu;
                 const guildConfiguration = this.getGuildConfiguration(selectMenuInteraction.guildId);
                 await selectMenuWithGuildConfiguration.execute(this.client, guildConfiguration, selectMenuInteraction);
@@ -223,7 +234,7 @@ export class StelliaUtils {
             if (messageContextMenu.data.reply.autoDefer && !interaction.deferred) {
                 await interaction.deferReply({ flags: messageContextMenu.data.reply.ephemeral ? MessageFlags.Ephemeral : undefined });
             }
-            if (this.client.environment.areGuildsConfigurationEnabled) {
+            if (this.client.environment?.areGuildsConfigurationEnabled) {
                 const messageContextMenuWithGuildConfiguration = messageContextMenu;
                 const guildConfiguration = this.getGuildConfiguration(interaction.guildId);
                 await messageContextMenuWithGuildConfiguration.execute(this.client, guildConfiguration, interaction);
@@ -248,7 +259,7 @@ export class StelliaUtils {
             if (userContextMenu.data.reply.autoDefer && !interaction.deferred) {
                 await interaction.deferReply({ flags: userContextMenu.data.reply.ephemeral ? MessageFlags.Ephemeral : undefined });
             }
-            if (this.client.environment.areGuildsConfigurationEnabled) {
+            if (this.client.environment?.areGuildsConfigurationEnabled) {
                 const userContextMenuWithGuildConfiguration = userContextMenu;
                 const guildConfiguration = this.getGuildConfiguration(interaction.guildId);
                 await userContextMenuWithGuildConfiguration.execute(this.client, guildConfiguration, interaction);

package/dist/managers/AutoCompleteManager.d.ts

@@ -4,9 +4,10 @@ import { BaseManager } from "./index.js";
 import { type InteractionCustomId, type StructureCustomId } from "../typescript/index.js";
 export declare class AutoCompleteManager extends BaseManager {
     private interactions;
-    constructor(client: StelliaClient, directory: string);
+    private constructor();
+    static create(client: StelliaClient, directory: string): Promise<AutoCompleteManager>;
     loadData(): Promise<void>;
-    getByCustomId<AutoCompleteStructure>(id: InteractionCustomId): AutoCompleteStructure | undefined;
-    getByRegex<AutoCompleteStructure>(id: InteractionCustomId): AutoCompleteStructure | undefined;
+    getByCustomId<AutoCompleteStructure>(id: InteractionCustomId): AutoCompleteStructure | null;
+    getByRegex<AutoCompleteStructure>(id: InteractionCustomId): AutoCompleteStructure | null;
     getAll<AutoCompleteStructure>(): Collection<StructureCustomId, AutoCompleteStructure>;
 }

package/dist/managers/AutoCompleteManager.js

@@ -3,8 +3,13 @@ import { BaseManager } from "./index.js";
 import { requiredFiles } from "../utils/index.js";
 export class AutoCompleteManager extends BaseManager {
     interactions = new Collection();
-    constructor(client, directory) {
-        super(client, directory);
+    constructor(client, directoryPath) {
+        super(client, directoryPath);
+    }
+    static async create(client, directory) {
+        const manager = new AutoCompleteManager(client, directory);
+        await manager.loadData();
+        return manager;
     }
     async loadData() {
         const autoCompletes = await requiredFiles(this.directoryPath);
@@ -12,11 +17,18 @@ export class AutoCompleteManager extends BaseManager {
         this.setManagerLoaded();
     }
     getByCustomId(id) {
-        const autoComplete = this.interactions.get(id) ?? undefined;
+        const autoComplete = this.interactions.get(id) ?? null;
         return autoComplete;
     }
     getByRegex(id) {
-        return undefined;
+        let autoComplete = null;
+        for (const [customId, action] of this.interactions.entries()) {
+            if (customId instanceof RegExp && customId.test(id)) {
+                autoComplete = action;
+                break;
+            }
+        }
+        return autoComplete;
     }
     getAll() {
         const autoCompletes = this.interactions;

package/dist/managers/BaseManager.d.ts

@@ -9,11 +9,11 @@ export declare abstract class BaseManager {
     readonly client: StelliaClient;
     readonly directoryPath: string;
     private isLoaded;
-    constructor(client: StelliaClient, directory: string);
+    protected constructor(client: StelliaClient, directory: string);
     isManagerLoaded(): boolean;
     setManagerLoaded(): void;
-    abstract loadData(): void;
-    abstract getByCustomId<InteractionStructure extends AnyInteractionStructure>(id: InteractionCustomId): InteractionStructure | undefined;
-    abstract getByRegex<InteractionStructure extends AnyInteractionStructure>(id: InteractionCustomId): InteractionStructure | undefined;
+    abstract loadData(): Promise<void>;
+    abstract getByCustomId<InteractionStructure extends AnyInteractionStructure>(id: InteractionCustomId): InteractionStructure | null;
+    abstract getByRegex<InteractionStructure extends AnyInteractionStructure>(id: InteractionCustomId): InteractionStructure | null;
     abstract getAll<InteractionStructure extends AnyInteractionStructure>(): Collection<StructureCustomId, InteractionStructure>;
 }

package/dist/managers/BaseManager.js

@@ -5,7 +5,6 @@ export class BaseManager {
     constructor(client, directory) {
         this.client = client;
         this.directoryPath = directory;
-        this.loadData();
     }
     isManagerLoaded() {
         return this.isLoaded;

package/dist/managers/ButtonManager.d.ts

@@ -5,9 +5,10 @@ import { type ButtonStructure } from "../structures/index.js";
 import { type InteractionCustomId, type StructureCustomId } from "../typescript/index.js";
 export declare class ButtonManager extends BaseManager {
     interactions: Collection<StructureCustomId, ButtonStructure>;
-    constructor(client: StelliaClient, directory: string);
+    private constructor();
+    static create(client: StelliaClient, directory: string): Promise<ButtonManager>;
     loadData(): Promise<void>;
-    getByCustomId<ButtonStructure>(id: InteractionCustomId): ButtonStructure | undefined;
-    getByRegex<ButtonStructure>(id: InteractionCustomId): ButtonStructure | undefined;
+    getByCustomId<ButtonStructure>(id: InteractionCustomId): ButtonStructure | null;
+    getByRegex<ButtonStructure>(id: InteractionCustomId): ButtonStructure | null;
     getAll<ButtonStructure>(): Collection<StructureCustomId, ButtonStructure>;
 }

package/dist/managers/ButtonManager.js

@@ -3,8 +3,13 @@ import { BaseManager } from "./index.js";
 import { requiredFiles } from "../utils/index.js";
 export class ButtonManager extends BaseManager {
     interactions = new Collection();
-    constructor(client, directory) {
-        super(client, directory);
+    constructor(client, directoryPath) {
+        super(client, directoryPath);
+    }
+    static async create(client, directory) {
+        const manager = new ButtonManager(client, directory);
+        await manager.loadData();
+        return manager;
     }
     async loadData() {
         const buttons = await requiredFiles(this.directoryPath);
@@ -12,11 +17,11 @@ export class ButtonManager extends BaseManager {
         this.setManagerLoaded();
     }
     getByCustomId(id) {
-        const button = this.interactions.get(id) ?? undefined;
+        const button = this.interactions.get(id) ?? null;
         return button;
     }
     getByRegex(id) {
-        let button;
+        let button = null;
         for (const [customId, action] of this.interactions.entries()) {
             if (customId instanceof RegExp && customId.test(id)) {
                 button = action;

package/dist/managers/CommandManager.d.ts

@@ -4,9 +4,10 @@ import { BaseManager } from "./index.js";
 import { type InteractionCustomId, type StructureCustomId } from "../typescript/index.js";
 export declare class CommandManager extends BaseManager {
     private interactions;
-    constructor(client: StelliaClient, directory: string);
+    private constructor();
+    static create(client: StelliaClient, directory: string): Promise<CommandManager>;
     loadData(): Promise<void>;
-    getByCustomId<CommandStructure>(id: InteractionCustomId): CommandStructure | undefined;
-    getByRegex<CommandStructure>(id: InteractionCustomId): CommandStructure | undefined;
+    getByCustomId<CommandStructure>(id: InteractionCustomId): CommandStructure | null;
+    getByRegex<CommandStructure>(id: InteractionCustomId): CommandStructure | null;
     getAll<CommandStructure>(): Collection<StructureCustomId, CommandStructure>;
 }

package/dist/managers/CommandManager.js

@@ -3,8 +3,13 @@ import { BaseManager } from "./index.js";
 import { requiredFiles } from "../utils/index.js";
 export class CommandManager extends BaseManager {
     interactions = new Collection();
-    constructor(client, directory) {
-        super(client, directory);
+    constructor(client, directoryPath) {
+        super(client, directoryPath);
+    }
+    static async create(client, directory) {
+        const manager = new CommandManager(client, directory);
+        await manager.loadData();
+        return manager;
     }
     async loadData() {
         const commands = await requiredFiles(this.directoryPath);
@@ -12,11 +17,18 @@ export class CommandManager extends BaseManager {
         this.setManagerLoaded();
     }
     getByCustomId(id) {
-        const command = this.interactions.get(id) ?? undefined;
+        const command = this.interactions.get(id) ?? null;
         return command;
     }
     getByRegex(id) {
-        return undefined;
+        let command = null;
+        for (const [customId, action] of this.interactions.entries()) {
+            if (customId instanceof RegExp && customId.test(id)) {
+                command = action;
+                break;
+            }
+        }
+        return command;
     }
     getAll() {
         const commands = this.interactions;

package/dist/managers/ContextMenuManager.d.ts

@@ -4,9 +4,10 @@ import { BaseManager } from "./index.js";
 import { type InteractionCustomId, type StructureCustomId } from "../typescript/index.js";
 export declare class ContextMenuManager extends BaseManager {
     private interactions;
-    constructor(client: StelliaClient, directory: string);
+    private constructor();
+    static create(client: StelliaClient, directory: string): Promise<ContextMenuManager>;
     loadData(): Promise<void>;
-    getByCustomId<ContextMenuStructure>(id: InteractionCustomId): ContextMenuStructure | undefined;
-    getByRegex<ContextMenuStructure>(id: InteractionCustomId): ContextMenuStructure | undefined;
+    getByCustomId<ContextMenuStructure>(id: InteractionCustomId): ContextMenuStructure | null;
+    getByRegex<ContextMenuStructure>(id: InteractionCustomId): ContextMenuStructure | null;
     getAll<ContextMenuStructure>(): Collection<StructureCustomId, ContextMenuStructure>;
 }

package/dist/managers/ContextMenuManager.js

@@ -3,8 +3,13 @@ import { BaseManager } from "./index.js";
 import { requiredFiles } from "../utils/index.js";
 export class ContextMenuManager extends BaseManager {
     interactions = new Collection();
-    constructor(client, directory) {
-        super(client, directory);
+    constructor(client, directoryPath) {
+        super(client, directoryPath);
+    }
+    static async create(client, directory) {
+        const manager = new ContextMenuManager(client, directory);
+        await manager.loadData();
+        return manager;
     }
     async loadData() {
         const contextMenus = await requiredFiles(this.directoryPath);
@@ -12,11 +17,18 @@ export class ContextMenuManager extends BaseManager {
         this.setManagerLoaded();
     }
     getByCustomId(id) {
-        const contextMenu = this.interactions.get(id) ?? undefined;
+        const contextMenu = this.interactions.get(id) ?? null;
         return contextMenu;
     }
     getByRegex(id) {
-        return undefined;
+        let contextMenu = null;
+        for (const [customId, action] of this.interactions.entries()) {
+            if (customId instanceof RegExp && customId.test(id)) {
+                contextMenu = action;
+                break;
+            }
+        }
+        return contextMenu;
     }
     getAll() {
         const contextMenus = this.interactions;

package/dist/managers/EventManager.d.ts

@@ -5,13 +5,15 @@ import { type InteractionCustomId, type StructureCustomId } from "../typescript/
 export declare class EventManager extends BaseManager {
     private interactions;
     private guildsConfiguration;
-    constructor(client: StelliaClient, directoryPath: string);
+    private constructor();
+    static create(client: StelliaClient, directoryPath: string): Promise<EventManager>;
     loadData(): Promise<void>;
-    getByCustomId<EventStructure>(id: InteractionCustomId): EventStructure | undefined;
-    getByRegex<EventStructure>(id: InteractionCustomId): EventStructure | undefined;
+    getByCustomId<EventStructure>(id: InteractionCustomId): EventStructure | null;
+    getByRegex<EventStructure>(id: InteractionCustomId): EventStructure | null;
     getAll<EventStructure>(): Collection<StructureCustomId, EventStructure>;
     private loadEventWithGuildConfiguration;
-    private eventHandler;
+    private readonly eventHandler;
     private loadEventWithoutGuildConfiguration;
     private getGuildConfiguration;
+    private initializeGuildsConfiguration;
 }

package/dist/managers/EventManager.js

@@ -7,21 +7,19 @@ export class EventManager extends BaseManager {
     guildsConfiguration;
     constructor(client, directoryPath) {
         super(client, directoryPath);
-        if (this.client.environment.areGuildsConfigurationEnabled) {
-            this.client
-                .getGuildsConfiguration()
-                .then((guildsConfiguration) => {
-                this.guildsConfiguration = guildsConfiguration;
-                logger.success("Guilds configuration loaded successfully for event");
-            })
-                .catch((error) => logger.error(`Error while loading guilds configuration: ${error.stack}`));
-        }
     }
+    static async create(client, directoryPath) {
+        const manager = new EventManager(client, directoryPath);
+        await manager.loadData();
+        await manager.initializeGuildsConfiguration();
+        return manager;
+    }
+    ;
     async loadData() {
         const events = await requiredFiles(this.directoryPath);
         this.interactions = events;
         for (const eventStructure of this.interactions.values()) {
-            if (this.client.environment.areGuildsConfigurationEnabled) {
+            if (this.client.environment?.areGuildsConfigurationEnabled) {
                 await this.loadEventWithGuildConfiguration(eventStructure);
             }
             else {
@@ -31,11 +29,18 @@ export class EventManager extends BaseManager {
         this.setManagerLoaded();
     }
     getByCustomId(id) {
-        const event = this.interactions.get(id) ?? undefined;
+        const event = this.interactions.get(id) ?? null;
         return event;
     }
     getByRegex(id) {
-        return undefined;
+        let event = null;
+        for (const [customId, action] of this.interactions.entries()) {
+            if (customId instanceof RegExp && customId.test(id)) {
+                event = action;
+                break;
+            }
+        }
+        return event;
     }
     getAll() {
         const events = this.interactions;
@@ -51,6 +56,7 @@ export class EventManager extends BaseManager {
             this.client.on(name, (...args) => this.eventHandler(event, ...args));
         }
     }
+    ;
     eventHandler = (event, ...args) => {
         const mainArgument = args[0];
         const guildConfiguration = this.getGuildConfiguration(mainArgument);
@@ -71,6 +77,7 @@ export class EventManager extends BaseManager {
             this.client.on(name, (...args) => event.execute(this.client, ...args));
         }
     }
+    ;
     getGuildConfiguration(mainArgument) {
         if (mainArgument && typeof mainArgument === "object") {
             if ("guildId" in mainArgument && mainArgument.guildId) {
@@ -82,4 +89,18 @@ export class EventManager extends BaseManager {
         }
         return undefined;
     }
+    ;
+    async initializeGuildsConfiguration() {
+        if (this.client.environment?.areGuildsConfigurationEnabled) {
+            try {
+                const guildsConfiguration = await this.client.getGuildsConfiguration();
+                this.guildsConfiguration = guildsConfiguration;
+                logger.success("Guilds configuration loaded successfully for events");
+            }
+            catch (error) {
+                logger.error(`Error while loading guilds configuration: ${error.stack}`);
+            }
+        }
+    }
+    ;
 }

package/dist/managers/ModalManager.d.ts

@@ -4,9 +4,10 @@ import { BaseManager } from "./index.js";
 import { type InteractionCustomId, type StructureCustomId } from "../typescript/index.js";
 export declare class ModalManager extends BaseManager {
     private interactions;
-    constructor(client: StelliaClient, directory: string);
+    private constructor();
+    static create(client: StelliaClient, directory: string): Promise<ModalManager>;
     loadData(): Promise<void>;
-    getByCustomId<ModalStructure>(id: InteractionCustomId): ModalStructure | undefined;
-    getByRegex<ModalStructure>(id: InteractionCustomId): ModalStructure | undefined;
+    getByCustomId<ModalStructure>(id: InteractionCustomId): ModalStructure | null;
+    getByRegex<ModalStructure>(id: InteractionCustomId): ModalStructure | null;
     getAll<ModalStructure>(): Collection<StructureCustomId, ModalStructure>;
 }

package/dist/managers/ModalManager.js

@@ -3,8 +3,13 @@ import { BaseManager } from "./index.js";
 import { requiredFiles } from "../utils/index.js";
 export class ModalManager extends BaseManager {
     interactions = new Collection();
-    constructor(client, directory) {
-        super(client, directory);
+    constructor(client, directoryPath) {
+        super(client, directoryPath);
+    }
+    static async create(client, directory) {
+        const manager = new ModalManager(client, directory);
+        await manager.loadData();
+        return manager;
     }
     async loadData() {
         const modals = await requiredFiles(this.directoryPath);
@@ -12,11 +17,11 @@ export class ModalManager extends BaseManager {
         this.setManagerLoaded();
     }
     getByCustomId(id) {
-        const modal = this.interactions.get(id) ?? undefined;
+        const modal = this.interactions.get(id) ?? null;
         return modal;
     }
     getByRegex(id) {
-        let modal;
+        let modal = null;
         for (const [customId, action] of this.interactions.entries()) {
             if (customId instanceof RegExp && customId.test(id)) {
                 modal = action;

package/dist/managers/SelectMenuManager.d.ts

@@ -4,9 +4,10 @@ import { BaseManager } from "./index.js";
 import { type InteractionCustomId, type StructureCustomId } from "../typescript/index.js";
 export declare class SelectMenuManager extends BaseManager {
     private interactions;
-    constructor(client: StelliaClient, directory: string);
+    private constructor();
+    static create(client: StelliaClient, directory: string): Promise<SelectMenuManager>;
     loadData(): Promise<void>;
-    getByCustomId<SelectMenuStructure>(id: InteractionCustomId): SelectMenuStructure | undefined;
-    getByRegex<SelectMenuStructure>(id: InteractionCustomId): SelectMenuStructure | undefined;
+    getByCustomId<SelectMenuStructure>(id: InteractionCustomId): SelectMenuStructure | null;
+    getByRegex<SelectMenuStructure>(id: InteractionCustomId): SelectMenuStructure | null;
     getAll<SelectMenuStructure>(): Collection<StructureCustomId, SelectMenuStructure>;
 }

package/dist/managers/SelectMenuManager.js

@@ -3,8 +3,13 @@ import { BaseManager } from "./index.js";
 import { requiredFiles } from "../utils/index.js";
 export class SelectMenuManager extends BaseManager {
     interactions = new Collection();
-    constructor(client, directory) {
-        super(client, directory);
+    constructor(client, directoryPath) {
+        super(client, directoryPath);
+    }
+    static async create(client, directory) {
+        const manager = new SelectMenuManager(client, directory);
+        await manager.loadData();
+        return manager;
     }
     async loadData() {
         const selectMenus = await requiredFiles(this.directoryPath);
@@ -12,18 +17,18 @@ export class SelectMenuManager extends BaseManager {
         this.setManagerLoaded();
     }
     getByCustomId(id) {
-        const selectMenu = this.interactions.get(id) ?? undefined;
+        const selectMenu = this.interactions.get(id) ?? null;
         return selectMenu;
     }
     getByRegex(id) {
-        let button;
+        let selectMenu = null;
         for (const [customId, action] of this.interactions.entries()) {
             if (customId instanceof RegExp && customId.test(id)) {
-                button = action;
+                selectMenu = action;
                 break;
             }
         }
-        return button;
+        return selectMenu;
     }
     getAll() {
         const selectMenus = this.interactions;

package/dist/utils/files.js

@@ -1,5 +1,5 @@
-import { readdirSync, statSync } from "fs";
-import path from "path";
+import { readdirSync, statSync } from "node:fs";
+import path from "node:path";
 import { Collection } from "discord.js";
 export const requiredFiles = async (directoryPath) => {
     const collection = new Collection();
@@ -12,18 +12,13 @@ export const requiredFiles = async (directoryPath) => {
     return collection;
 };
 const loadInteraction = async (filePath) => {
-    try {
-        const module = await import(`file://${filePath}`);
-        const data = module.default;
-        return data;
-    }
-    catch (error) {
-        throw error;
-    }
+    const module = await import(`file://${filePath}`);
+    const data = module.default;
+    return data;
 };
 const getAllFilesPath = (dirPath, arrayOfFiles = []) => {
     const files = readdirSync(dirPath);
-    files.forEach((file) => {
+    for (const file of files) {
         if (statSync(dirPath + "/" + file).isDirectory()) {
             arrayOfFiles = getAllFilesPath(dirPath + "/" + file, arrayOfFiles);
         }
@@ -31,6 +26,6 @@ const getAllFilesPath = (dirPath, arrayOfFiles = []) => {
             const __dirname = path.resolve();
             arrayOfFiles.push(path.join(__dirname, dirPath, "/", file));
         }
-    });
+    }
     return arrayOfFiles;
 };

package/dist/utils/logger.js

@@ -1,15 +1,16 @@
 import logSymbols from "log-symbols";
+const prefix = "[StelliaJS]";
 export const logger = {
     info: (message) => {
-        console.log(`${logSymbols.info} ${message}`);
+        console.log(`${logSymbols.info} ${prefix} ${message}`);
     },
     success: (message) => {
-        console.log(`${logSymbols.success} ${message}`);
+        console.log(`${logSymbols.success} ${prefix} ${message}`);
     },
     warn: (message) => {
-        console.warn(`${logSymbols.warning} ${message}`);
+        console.warn(`${logSymbols.warning} ${prefix} ${message}`);
     },
     error: (message) => {
-        console.error(`${logSymbols.error} ${message}`);
+        console.error(`${logSymbols.error} ${prefix} ${message}`);
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@stelliajs/framework",
-	"version": "1.5.3",
+	"version": "1.5.6",
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",
 	"scripts": {
@@ -23,19 +23,19 @@
 		"framework"
 	],
 	"dependencies": {
-		"discord.js": "^14.21.0",
-		"i18next": "^25.3.4",
+		"discord.js": "^14.22.1",
+		"i18next": "^25.5.2",
 		"log-symbols": "^7.0.1"
 	},
 	"devDependencies": {
-        "@eslint/js": "^9.33.0",
-        "eslint-config-prettier": "^10.1.8",
-        "eslint-import-resolver-typescript": "^4.4.4",
-        "eslint-plugin-import": "^2.32.0",
-        "prettier": "^3.6.2",
-        "tsc-alias": "^1.8.16",
-        "typescript-eslint": "^8.39.1"
+		"@eslint/js": "^9.36.0",
+		"eslint-config-prettier": "^10.1.8",
+		"eslint-import-resolver-typescript": "^4.4.4",
+		"eslint-plugin-import": "^2.32.0",
+		"prettier": "^3.6.2",
+		"tsc-alias": "^1.8.16",
+		"typescript-eslint": "^8.44.1"
 	},
 	"type": "module",
-	"packageManager": "pnpm@10.14.0"
+	"packageManager": "pnpm@10.17.1"
 }

package/.prettierrc

@@ -1,8 +0,0 @@
-{
-  "semi": true,
-  "singleQuote": false,
-  "useTabs": true,
-  "tabWidth": 2,
-  "trailingComma": "none",
-  "printWidth": 100
-}

package/eslint.config.mjs

@@ -1,68 +0,0 @@
-import js from "@eslint/js";
-import ts from "typescript-eslint";
-import importPlugin from "eslint-plugin-import";
-import prettierConfig from "eslint-config-prettier";
-
-export default ts.config(
-    js.configs.recommended,
-    ts.configs.recommended,
-    importPlugin.flatConfigs.recommended,
-    importPlugin.flatConfigs.typescript,
-    prettierConfig,
-    {
-        languageOptions: {
-            parserOptions: {
-                project: "./tsconfig.json",
-                sourceType: "module",
-                ecmaVersion: "latest"
-            }
-        },
-        rules: {
-            "import/namespace": "off",
-            "@typescript-eslint/explicit-function-return-type": "off",
-            "@typescript-eslint/no-unused-vars": ["warn", { argsIgnorePattern: "^_" }],
-            "@typescript-eslint/no-explicit-any": "warn",
-            "import/order": [
-                "error",
-                {
-                    groups: [
-                        "builtin",
-                        "external",
-                        "internal",
-                        ["parent", "sibling", "index"],
-                        "object",
-                        "type"
-                    ],
-                    pathGroups: [
-                        {
-                            pattern: "@/**",
-                            group: "internal"
-                        }
-                    ],
-                    pathGroupsExcludedImportTypes: ["builtin"],
-                    alphabetize: {
-                        order: "asc",
-                        caseInsensitive: true
-                    }
-                }
-            ],
-            "import/newline-after-import": ["error", { count: 1 }],
-            "import/no-unresolved": "error",
-            "import/no-duplicates": "error",
-            "no-console": "off",
-            "no-var": "error",
-            "prefer-const": "error"
-        },
-        settings: {
-            "import/resolver": {
-                typescript: {
-                    alwaysTryTypes: true,
-                    project: "./tsconfig.json"
-                },
-                node: {
-                    extensions: [".js", ".ts"]
-                }
-            }
-        }
-    }
-);