@stelliajs/framework 1.5.4 → 1.5.7

package/README.md

@@ -49,108 +49,149 @@ Recommended architecture for StelliaJS project.
 
 ### Simple client with environment
 
-```js
-import { GatewayIntentBits, Partials } from "discord.js";
+#### Client initialization
+```ts
 import { StelliaClient } from "@stelliajs/framework";
+import { GatewayIntentBits, Partials } from "discord.js";
+
+(async () => {
+    const client = new StelliaClient({
+        intents: [
+            GatewayIntentBits.Guilds,
+            GatewayIntentBits.GuildMessages,
+            GatewayIntentBits.MessageContent,
+            GatewayIntentBits.GuildMembers
+        ],
+        partials: [Partials.Message, Partials.GuildMember]
+    },
+    {
+        managers: {
+            autoCompletes: {
+                directoryPath: "./interactions/autoCompletes"
+            },
+            buttons: {
+                directoryPath: "./interactions/buttons"
+            },
+            commands: {
+                directoryPath: "./commands/slash"
+            },
+            contextMenus: {
+                directoryPath: "./commands/contextMenus"
+            },
+            events: {
+                directoryPath: "./events"
+            },
+            modals: {
+                directoryPath: "./interactions/modals"
+            },
+            selectMenus: {
+                directoryPath: "./interactions/selectMenus"
+            }
+        },
+        environment: {
+            areGuildsConfigurationEnabled: true
+        }
+    });
 
-const client = new StelliaClient(
-	{
-		intents: [
-			GatewayIntentBits.Guilds,
-			GatewayIntentBits.GuildMessages,
-			GatewayIntentBits.MessageContent,
-			GatewayIntentBits.GuildMembers
-		],
-		partials: [Partials.Message, Partials.GuildMember]
-	},
-	{
-		managers: {
-			autoCompletes: {
-				directoryPath: "./interactions/autoCompletes"
-			},
-			buttons: {
-				directoryPath: "./interactions/buttons"
-			},
-			commands: {
-				directoryPath: "./commands/slash"
-			},
-			contextMenus: {
-				directoryPath: "./commands/contextMenus"
-			},
-			events: {
-				directoryPath: "./events"
-			},
-			modals: {
-				directoryPath: "./interactions/modals"
-			},
-			selectMenus: {
-				directoryPath: "./interactions/selectMenus"
-			}
-		},
-		environment: {
-			areGuildsConfigurationEnabled: true
-		}
-	}
-);
-
-await client.connect(process.env.TOKEN);
+    await client.connect(process.env.TOKEN);
+})();
 ```
 
-### Simple event
+#### Environment model
+
+```ts
+import {
+    BaseGeneralConfiguration,
+    BaseGuildConfiguration,
+    GuildConfiguration,
+    GuildsConfiguration
+} from "@stelliajs/framework";
+import { Snowflake } from "discord.js";
+
+interface MyBotGeneralConfiguration extends BaseGeneralConfiguration {
+    botName: string;
+}
+interface MyBotSpecificGuildConfiguration extends BaseGuildConfiguration {
+    channels: {
+        logs: Snowflake;
+        welcome: Snowflake;
+    };
+}
+
+export interface MyBotGuildConfiguration extends GuildConfiguration {
+    general: MyBotGeneralConfiguration;
+    guild: MyBotSpecificGuildConfiguration;
+}
+
+export interface MyBotGuildsConfiguration extends GuildsConfiguration {
+    general: MyBotGeneralConfiguration;
+    guilds: {
+        [guildId: Snowflake]: MyBotSpecificGuildConfiguration;
+    };
+}
+```
 
-#### Ready event with environment
+### Interactions/Events with environment
 
-```js
-import { type StelliaClient, type EventStructure } from "@stelliajs/framework";
+#### Ready event
+
+```ts
+import { type EventStructure, type StelliaClient } from "@stelliajs/framework";
 import { Events } from "discord.js";
-import { type CustomGuildsConfiguration } from "@environments/environment.model.ts";
+import { type MyBotGuildsConfiguration } from "@environments/environment.model.ts";
 
 export default {
     data: {
         name: Events.ClientReady,
         once: true
     },
-    async execute(client: StelliaClient<true>, environment: CustomGuildsConfiguration) { // <true> ensures that the client is Ready
+    async execute(client: StelliaClient<true>, guildsConfiguration: MyBotGuildsConfiguration) { // <true> ensures that the client is Ready
         console.log(`Logged in as ${client.user.tag}`);
         await client.initializeCommands(); // Used to initialise registered commands
     }
-} as EventStructure;
+} satisfies EventStructure;
 ```
 
-#### InteractionCreate event with environment
+#### InteractionCreate event
 
-```js
+```ts
 import { type StelliaClient, type EventStructure } from "@stelliajs/framework";
 import { Events, type Interaction } from "discord.js";
-import { type CustomGuildsConfiguration } from "@environments/environment.model.ts";
+import { type MyBotGuildConfiguration } from "@environments/environment.model.ts";
 
 export default {
     data: {
         name: Events.InteractionCreate,
         once: false
     },
-    async execute(client: StelliaClient<true>, environment: CustomGuildsConfiguration, interaction: Interaction) {
+    async execute(client: StelliaClient<true>, guildConfiguration: MyBotGuildConfiguration, interaction: Interaction) {
         if (interaction.inCachedGuild()) {
             await client.handleInteraction(interaction); // Automatic interaction handling
         }
     }
-} as EventStructure;
+} satisfies EventStructure;
 ```
 
-### Simple command
+#### Command interaction
 
-```js
-import { type CommandStructure, ephemeralFollowUpResponse, type StelliaClient } from "@stelliajs/framework";
+```ts
+import { type CommandStructure, type StelliaClient } from "@stelliajs/framework";
 import { type ChatInputCommandInteraction, SlashCommandBuilder } from "discord.js";
-import { type CustomGuildsConfiguration } from "@environments/environment.model.ts";
+import { type MyBotGuildConfiguration } from "@environments/environment.model.ts";
 
 export default {
-    data: new SlashCommandBuilder()
-        .setName("ping"),
-    async execute(client: StelliaClient, environment: CustomGuildsConfiguration, interaction: ChatInputCommandInteraction<"cached">) { // All interactions are cached
-        await ephemeralFollowUpResponse(interaction, "Pong!", true); // Response is ephemeral and deleted after 60 seconds
+    data: {
+        command: new SlashCommandBuilder()
+            .setName("ping"),
+        reply: {
+            autoDefer: true, // Defer the reply to avoid the interaction failing after 3 seconds
+            ephemeral: true, // The reply will be visible only by the user who triggered the interaction
+        }
+    },
+    async execute(client: StelliaClient, guildConfiguration: MyBotGuildConfiguration, interaction: ChatInputCommandInteraction<"cached">) { // All interactions are cached
+        await interaction.editReply("Pong!");
     }
-} as CommandStructure;
+} satisfies CommandStructure;
 ```
 
 ## Help

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 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,4 +1,4 @@
-import * as fs from "node:fs";
+import fs from "node:fs";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { Client } from "discord.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(() => {
@@ -90,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,10 +5,12 @@ 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 initializeGuildsConfiguration;
     private readonly handleAutoCompleteInteraction;
     private readonly handleButtonInteraction;
     private readonly handleCommandInteraction;

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,7 +4,8 @@ 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 | null;
     getByRegex<AutoCompleteStructure>(id: InteractionCustomId): AutoCompleteStructure | null;

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);

package/dist/managers/BaseManager.d.ts

@@ -9,7 +9,7 @@ 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(): Promise<void>;

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,7 +5,8 @@ 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 | null;
     getByRegex<ButtonStructure>(id: InteractionCustomId): ButtonStructure | null;

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);

package/dist/managers/CommandManager.d.ts

@@ -4,7 +4,8 @@ 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 | null;
     getByRegex<CommandStructure>(id: InteractionCustomId): CommandStructure | null;

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);

package/dist/managers/ContextMenuManager.d.ts

@@ -4,7 +4,8 @@ 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 | null;
     getByRegex<ContextMenuStructure>(id: InteractionCustomId): ContextMenuStructure | null;

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);

package/dist/managers/EventManager.d.ts

@@ -5,7 +5,8 @@ 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 | null;
     getByRegex<EventStructure>(id: InteractionCustomId): EventStructure | null;
@@ -14,4 +15,5 @@ export declare class EventManager extends BaseManager {
     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 {
@@ -58,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);
@@ -78,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) {
@@ -89,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,7 +4,8 @@ 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 | null;
     getByRegex<ModalStructure>(id: InteractionCustomId): ModalStructure | null;

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);

package/dist/managers/SelectMenuManager.d.ts

@@ -4,7 +4,8 @@ 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 | null;
     getByRegex<SelectMenuStructure>(id: InteractionCustomId): SelectMenuStructure | null;

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);

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.4",
+	"version": "1.5.7",
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",
 	"scripts": {
@@ -23,19 +23,19 @@
 		"framework"
 	],
 	"dependencies": {
-		"discord.js": "^14.22.1",
-		"i18next": "^25.5.2",
+		"discord.js": "^14.24.0",
+		"i18next": "^25.6.0",
 		"log-symbols": "^7.0.1"
 	},
 	"devDependencies": {
-		"@eslint/js": "^9.36.0",
+		"@eslint/js": "^9.38.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"
+		"typescript-eslint": "^8.46.2"
 	},
 	"type": "module",
-	"packageManager": "pnpm@10.17.1"
+	"packageManager": "pnpm@10.19.0"
 }

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"]
-                }
-            }
-        }
-    }
-);