@stelliajs/framework 1.1.2 → 1.2.0-dev-1

package/dist/client/StelliaClient.d.ts

@@ -1,22 +1,27 @@
 import { Client, type ClientOptions } from "discord.js";
 import { type ManagerOptions } from "../managers/index.js";
-import { type AnyInteraction, type Managers } from "../typescript/index.js";
+import { type AnyInteraction, type Environment, type EnvironmentConfiguration, type Managers } from "../typescript/index.js";
 export declare class StelliaClient<Ready extends boolean = boolean> extends Client<Ready> {
     private readonly utils;
     readonly managers: Managers;
+    readonly environment: Environment;
     constructor(clientOptions: ClientOptions, stelliaOptions?: StelliaOptions);
     connect: (token: string) => Promise<void>;
     initializeCommands: () => Promise<void>;
+    getEnvironment: <CustomEnvironment extends EnvironmentConfiguration>() => Promise<CustomEnvironment>;
     handleInteraction: (interaction: AnyInteraction) => Promise<void>;
     private areManagersLoaded;
 }
 interface StelliaOptions {
-    autoCompletes?: ManagerOptions;
-    buttons?: ManagerOptions;
-    commands?: ManagerOptions;
-    contextMenus?: ManagerOptions;
-    events?: ManagerOptions;
-    selectMenus?: ManagerOptions;
-    modals?: ManagerOptions;
+    managers: {
+        autoCompletes?: ManagerOptions;
+        buttons?: ManagerOptions;
+        commands?: ManagerOptions;
+        contextMenus?: ManagerOptions;
+        events?: ManagerOptions;
+        selectMenus?: ManagerOptions;
+        modals?: ManagerOptions;
+    };
+    environment?: Environment;
 }
 export {};

package/dist/client/StelliaClient.js

@@ -1,33 +1,40 @@
 import { Client } from "discord.js";
 import { AutoCompleteManager, ButtonManager, CommandManager, ContextMenuManager, EventManager, ModalManager, SelectMenuManager } from "../managers/index.js";
 import { StelliaUtils } from "./index.js";
+import path from "path";
+import * as fs from "node:fs";
+import { pathToFileURL } from 'url';
 export class StelliaClient extends Client {
     utils;
     managers = {};
+    environment;
     constructor(clientOptions, stelliaOptions) {
         super(clientOptions);
-        this.utils = new StelliaUtils(this);
-        if (stelliaOptions?.autoCompletes?.directoryPath) {
-            this.managers.autoCompletes = new AutoCompleteManager(this, stelliaOptions.autoCompletes.directoryPath);
+        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?.buttons?.directoryPath) {
-            this.managers.buttons = new ButtonManager(this, stelliaOptions.buttons.directoryPath);
+        if (stelliaOptions?.managers.commands?.directoryPath) {
+            this.managers.commands = new CommandManager(this, stelliaOptions.managers.commands.directoryPath);
         }
-        if (stelliaOptions?.commands?.directoryPath) {
-            this.managers.commands = new CommandManager(this, stelliaOptions.commands.directoryPath);
+        if (stelliaOptions?.managers.contextMenus?.directoryPath) {
+            this.managers.contextMenus = new ContextMenuManager(this, stelliaOptions.managers.contextMenus.directoryPath);
         }
-        if (stelliaOptions?.contextMenus?.directoryPath) {
-            this.managers.contextMenus = new ContextMenuManager(this, stelliaOptions.contextMenus.directoryPath);
+        if (stelliaOptions?.managers.events?.directoryPath) {
+            this.managers.events = new EventManager(this, stelliaOptions.managers.events.directoryPath);
         }
-        if (stelliaOptions?.events?.directoryPath) {
-            this.managers.events = new EventManager(this, stelliaOptions.events.directoryPath);
+        if (stelliaOptions?.managers.selectMenus?.directoryPath) {
+            this.managers.selectMenus = new SelectMenuManager(this, stelliaOptions.managers.selectMenus.directoryPath);
         }
-        if (stelliaOptions?.selectMenus?.directoryPath) {
-            this.managers.selectMenus = new SelectMenuManager(this, stelliaOptions.selectMenus.directoryPath);
+        if (stelliaOptions?.managers.modals?.directoryPath) {
+            this.managers.modals = new ModalManager(this, stelliaOptions.managers.modals.directoryPath);
         }
-        if (stelliaOptions?.modals?.directoryPath) {
-            this.managers.modals = new ModalManager(this, stelliaOptions.modals.directoryPath);
+        if (stelliaOptions?.environment) {
+            this.environment = stelliaOptions.environment;
         }
+        this.utils = new StelliaUtils(this);
         process.on("unhandledRejection", (error) => {
             console.error(`Unhandled promise rejection: ${error}`);
         });
@@ -46,6 +53,34 @@ export class StelliaClient extends Client {
     initializeCommands = async () => {
         await this.utils.initializeCommands();
     };
+    getEnvironment = async () => {
+        const chosenEnvironment = process.argv.find(arg => arg.startsWith("--config"))?.split("=")[1];
+        if (!chosenEnvironment) {
+            throw new Error("Environment not provided");
+        }
+        const srcPath = path.dirname(path.resolve(process.argv[1]));
+        const filePath = path.join(srcPath, "..", "stellia.json");
+        return new Promise((resolve, reject) => {
+            fs.readFile(filePath, async (err, data) => {
+                if (err) {
+                    return reject(err);
+                }
+                try {
+                    const environments = JSON.parse(data.toString()).environments;
+                    if (!Object.keys(environments).includes(chosenEnvironment)) {
+                        return reject(new Error("Invalid environment"));
+                    }
+                    const environmentPath = environments[chosenEnvironment];
+                    const environmentAbsolutePath = pathToFileURL(path.join(srcPath, "..", environmentPath.file)).href;
+                    const environmentFile = await import(environmentAbsolutePath);
+                    resolve(environmentFile.environment);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+    };
     handleInteraction = async (interaction) => {
         await this.utils.handleInteraction(interaction);
     };

package/dist/client/StelliaUtils.d.ts

@@ -1,8 +1,9 @@
 import { type StelliaClient } from "./index.js";
-import { AnyInteraction } from "../typescript/index.js";
+import { type AnyInteraction } from "../typescript/index.js";
 export declare class StelliaUtils {
     readonly client: StelliaClient;
     private readonly interactionHandlers;
+    private environment;
     constructor(client: StelliaClient);
     initializeCommands: () => Promise<void>;
     handleInteraction: (interaction: AnyInteraction) => Promise<void>;

package/dist/client/StelliaUtils.js

@@ -4,6 +4,7 @@ import { InteractionType } from "../typescript/index.js";
 export class StelliaUtils {
     client;
     interactionHandlers;
+    environment;
     constructor(client) {
         this.client = client;
         this.interactionHandlers = new Map([
@@ -14,6 +15,13 @@ export class StelliaUtils {
             [InteractionType.ModalSubmit, this.handleModalInteraction],
             [InteractionType.SelectMenu, this.handleSelectMenuInteraction]
         ]);
+        if (this.client.environment.isEnvironmentsEnabled) {
+            this.client.getEnvironment()
+                .then((environment) => {
+                this.environment = environment;
+            })
+                .catch((error) => console.error(error));
+        }
     }
     initializeCommands = async () => {
         const commands = this.client.managers.commands?.getAll().values();
@@ -50,6 +58,10 @@ export class StelliaUtils {
             const autoComplete = autoCompleteManager.getByCustomId(interactionAutoComplete.commandName);
             if (!autoComplete)
                 return;
+            if (this.client.environment.isEnvironmentsEnabled) {
+                await autoComplete.execute(this.client, this.environment, interactionAutoComplete);
+                return;
+            }
             await autoComplete.execute(this.client, interactionAutoComplete);
         }
         catch (error) {
@@ -65,6 +77,10 @@ export class StelliaUtils {
             const button = buttonManager.getByCustomId(buttonInteraction.customId) || buttonManager.getByRegex(buttonInteraction.customId);
             if (!button)
                 return;
+            if (this.client.environment.isEnvironmentsEnabled) {
+                await button.execute(this.client, this.environment, buttonInteraction);
+                return;
+            }
             await button.execute(this.client, buttonInteraction);
         }
         catch (error) {
@@ -80,6 +96,10 @@ export class StelliaUtils {
             const command = commandManager.getByCustomId(interactionCommand.commandName);
             if (!command)
                 return;
+            if (this.client.environment.isEnvironmentsEnabled) {
+                await command.execute(this.client, this.environment, interactionCommand);
+                return;
+            }
             await command.execute(this.client, interactionCommand);
         }
         catch (error) {
@@ -111,6 +131,10 @@ export class StelliaUtils {
             const modal = modalManager.getByCustomId(interactionModal.customId) || modalManager.getByRegex(interactionModal.customId);
             if (!modal)
                 return;
+            if (this.client.environment.isEnvironmentsEnabled) {
+                await modal.execute(this.client, this.environment, interactionModal);
+                return;
+            }
             await modal.execute(this.client, interactionModal);
         }
         catch (error) {
@@ -126,6 +150,10 @@ export class StelliaUtils {
             const selectMenu = selectMenuManager.getByCustomId(interactionSelectMenu.customId) || selectMenuManager.getByRegex(interactionSelectMenu.customId);
             if (!selectMenu)
                 return;
+            if (this.client.environment.isEnvironmentsEnabled) {
+                await selectMenu.execute(this.client, this.environment, interactionSelectMenu);
+                return;
+            }
             await selectMenu.execute(this.client, interactionSelectMenu);
         }
         catch (error) {
@@ -140,6 +168,10 @@ export class StelliaUtils {
             const messageContextMenu = contextMenuManager.getByCustomId(interaction.commandName);
             if (!messageContextMenu)
                 return;
+            if (this.client.environment.isEnvironmentsEnabled) {
+                await messageContextMenu.execute(this.client, this.environment, interaction);
+                return;
+            }
             await messageContextMenu.execute(this.client, interaction);
         }
         catch (error) {
@@ -154,6 +186,10 @@ export class StelliaUtils {
             const userContextMenu = contextMenuManager.getByCustomId(interaction.commandName);
             if (!userContextMenu)
                 return;
+            if (this.client.environment.isEnvironmentsEnabled) {
+                await userContextMenu.execute(this.client, this.environment, interaction);
+                return;
+            }
             await userContextMenu.execute(this.client, interaction);
         }
         catch (error) {

package/dist/structures/Interaction.d.ts

@@ -1,30 +1,38 @@
 import { type AnySelectMenuInteraction, type AutocompleteInteraction, type Awaitable, type ButtonInteraction, type ChatInputCommandInteraction, type ContextMenuCommandBuilder, type MessageContextMenuCommandInteraction, type ModalSubmitInteraction, type SlashCommandBuilder, type UserContextMenuCommandInteraction } from "discord.js";
 import { type StelliaClient } from "../client/index.js";
+import { type EnvironmentConfiguration } from "../typescript/index.js";
+import { type EventStructure } from "./Event.js";
 export interface AutoCompleteStructure {
     data: DefaultDataStructure;
     execute(client: StelliaClient, interaction: AutocompleteInteraction<"cached">): Awaitable<unknown>;
+    execute<CustomEnvironment extends EnvironmentConfiguration>(client: StelliaClient, environment: CustomEnvironment, interaction: AutocompleteInteraction<"cached">): Awaitable<unknown>;
 }
 export interface ButtonStructure {
     data: DefaultDataStructure;
     execute(client: StelliaClient, interaction: ButtonInteraction<"cached">): Awaitable<unknown>;
+    execute<CustomEnvironment extends EnvironmentConfiguration>(client: StelliaClient, environment: CustomEnvironment, interaction: ButtonInteraction<"cached">): Awaitable<unknown>;
 }
 export interface CommandStructure {
     data: SlashCommandBuilder;
     execute(client: StelliaClient, interaction: ChatInputCommandInteraction<"cached">): Awaitable<unknown>;
+    execute<CustomEnvironment extends EnvironmentConfiguration>(client: StelliaClient, environment: CustomEnvironment, interaction: ChatInputCommandInteraction<"cached">): Awaitable<unknown>;
 }
 export interface ContextMenuStructure {
     data: ContextMenuCommandBuilder;
     execute(client: StelliaClient, interaction: MessageContextMenuCommandInteraction<"cached"> | UserContextMenuCommandInteraction<"cached">): Awaitable<unknown>;
+    execute<CustomEnvironment extends EnvironmentConfiguration>(client: StelliaClient, environment: CustomEnvironment, interaction: MessageContextMenuCommandInteraction<"cached"> | UserContextMenuCommandInteraction<"cached">): Awaitable<unknown>;
 }
 export interface ModalStructure {
     data: DefaultDataStructure;
     execute(client: StelliaClient, interaction: ModalSubmitInteraction<"cached">): Awaitable<unknown>;
+    execute<CustomEnvironment extends EnvironmentConfiguration>(client: StelliaClient, environment: CustomEnvironment, interaction: ModalSubmitInteraction<"cached">): Awaitable<unknown>;
 }
 export interface SelectMenuStructure {
     data: DefaultDataStructure;
     execute(client: StelliaClient, interaction: AnySelectMenuInteraction<"cached">): Awaitable<unknown>;
+    execute<CustomEnvironment extends EnvironmentConfiguration>(client: StelliaClient, environment: CustomEnvironment, interaction: AnySelectMenuInteraction<"cached">): Awaitable<unknown>;
 }
-export type AnyInteractionStructure = AutoCompleteStructure | ButtonStructure | CommandStructure | ContextMenuStructure | ModalStructure | SelectMenuStructure;
+export type AnyInteractionStructure = AutoCompleteStructure | ButtonStructure | CommandStructure | ContextMenuStructure | EventStructure | ModalStructure | SelectMenuStructure;
 interface DefaultDataStructure {
     name: string | RegExp;
     once: boolean;

package/dist/typescript/types.d.ts

@@ -22,3 +22,9 @@ export interface Managers {
     selectMenus?: SelectMenuManager;
     modals?: ModalManager;
 }
+export interface Environment {
+    isEnvironmentsEnabled: boolean;
+}
+export interface EnvironmentConfiguration {
+    [key: string]: unknown;
+}

package/dist/utils/ephemeralReponse.js

@@ -1,12 +1,13 @@
+import { MessageFlags } from "discord.js";
 export const ephemeralFollowUpResponse = async (interaction, data, automaticDeletion = false) => {
     if (!interaction.deferred) {
-        await interaction.deferReply({ ephemeral: true });
+        await interaction.deferReply({ flags: MessageFlags.Ephemeral });
     }
     if (typeof data === "string") {
-        await interaction.followUp({ content: data, ephemeral: true });
+        await interaction.followUp({ content: data, flags: MessageFlags.Ephemeral });
     }
     else {
-        await interaction.followUp({ ...data, ephemeral: true });
+        await interaction.followUp({ ...data, flags: MessageFlags.Ephemeral });
     }
     if (automaticDeletion) {
         setTimeout(() => {
@@ -19,13 +20,13 @@ export const ephemeralFollowUpResponse = async (interaction, data, automaticDele
 };
 export const ephemeralReplyResponse = async (interaction, data, automaticDeletion = false) => {
     if (!interaction.deferred) {
-        await interaction.deferReply({ ephemeral: true });
+        await interaction.deferReply({ flags: MessageFlags.Ephemeral });
     }
     if (typeof data === "string") {
-        await interaction.reply({ content: data, ephemeral: true });
+        await interaction.reply({ content: data, flags: MessageFlags.Ephemeral });
     }
     else {
-        await interaction.reply({ ...data, ephemeral: true });
+        await interaction.reply({ ...data, flags: MessageFlags.Ephemeral });
     }
     if (automaticDeletion) {
         setTimeout(() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stelliajs/framework",
-  "version": "1.1.2",
+  "version": "1.2.0-dev-1",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "scripts": {
@@ -15,8 +15,8 @@
   "description": "A framework for simplify the creation of discord bots",
   "keywords": ["discord", "bot", "discordjs", "typescript", "framework"],
   "dependencies": {
-    "discord-api-types": "^0.37.115",
-    "discord.js": "^14.17.2"
+    "discord-api-types": "^0.37.119",
+    "discord.js": "^14.17.3"
   },
   "devDependencies": {
     "ts-node": "^10.9.2",