@stelliajs/framework 1.2.3 → 1.3.0-dev-1

package/README.md

@@ -3,7 +3,7 @@
 ## About
 
 StelliaJS is built using Discord JS V14 and TypeScript. It allows you to quickly set up a new bot with a simple and complete architecture.
-A CLI is available to help you set up a project with StelliaJS : [link to the CLI](https://github.com/StelliaJS/cli)
+A CLI is currently being developed and will soon be available for even greater convenience.
 
 ## Architecture
 Recommended architecture for StelliaJS project.
@@ -19,10 +19,6 @@ Recommended architecture for StelliaJS project.
 │   │       │   ├── ban.ts
 │   │       │   └── mute.ts
 │   │       └── ping.ts
-│   ├── environments/
-│   │   ├── environment.development.ts
-│   │   ├── environment.model.ts
-│   │   └── environment.ts
 │   ├── events/
 │   │   ├── ready.ts
 │   │   └── interactionCreate.ts
@@ -40,17 +36,16 @@ Recommended architecture for StelliaJS project.
 ├── .env
 ├── package.json
 ├── package-lock.json
-├── stellia.json
 └── tsconfig.json
 ```
-
 ## Examples
 
-### Simple client with environment
+### Simple client
 
 ```js
 import { StelliaClient } from "@stelliajs/framework";
-import { GatewayIntentBits, Partials } from "discord.js";
+import { GatewayIntentBits } from "discord-api-types/v10";
+import { Partials } from "discord.js";
 
 const client = new StelliaClient({
     intents: [
@@ -61,31 +56,26 @@ const client = new StelliaClient({
     ],
     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"
-        }
+    autoCompletes: {
+        directoryPath: "./interactions/autoCompletes"
+    },
+    buttons: {
+        directoryPath: "./interactions/buttons"
+    },
+    commands: {
+        directoryPath: "./commands/slash"
+    },
+    contextMenus: {
+        directoryPath: "./commands/contextMenus"
+    },
+    events: {
+        directoryPath: "./events"
+    },
+    modals: {
+        directoryPath: "./interactions/modals"
     },
-    environment: {
-        areEnvironmentsEnabled: true
+    selectMenus: {
+        directoryPath: "./interactions/selectMenus"
     }
 });
 
@@ -94,36 +84,34 @@ await client.connect(process.env.TOKEN);
 
 ### Simple event
 
-#### Ready event with environment
+#### Ready event
 ```js
 import { type StelliaClient, type EventStructure } from "@stelliajs/framework";
 import { Events } from "discord.js";
-import { type CustomEnvironment } from "@environments/environment.model.ts";
 
 export default {
     data: {
         name: Events.ClientReady,
         once: true
     },
-    async execute(client: StelliaClient<true>, environment: CustomEnvironment) { // <true> ensures that the client is Ready
+    async execute(client: StelliaClient<true>) { // <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;
 ```
 
-#### InteractionCreate event with environment
+#### InteractionCreate event
 ```js
 import { type StelliaClient, type EventStructure } from "@stelliajs/framework";
 import { Events, type Interaction } from "discord.js";
-import { type CustomEnvironment } from "@environments/environment.model.ts";
 
 export default {
     data: {
         name: Events.InteractionCreate,
         once: false
     },
-    async execute(client: StelliaClient<true>, environment: CustomEnvironment, interaction: Interaction) {
+    async execute(client: StelliaClient<true>, interaction: Interaction) {
         if (interaction.inCachedGuild()) {
             await client.handleInteraction(interaction); // Automatic interaction handling
         }
@@ -136,12 +124,11 @@ export default {
 ```js
 import { type CommandStructure, ephemeralFollowUpResponse, type StelliaClient } from "@stelliajs/framework";
 import { type ChatInputCommandInteraction, SlashCommandBuilder } from "discord.js";
-import { type CustomEnvironment } from "@environments/environment.model.ts";
 
 export default {
     data: new SlashCommandBuilder()
         .setName("ping"),
-    async execute(client: StelliaClient, environment: CustomEnvironment, interaction: ChatInputCommandInteraction<"cached">) { // All interactions are cached
+    async execute(client: StelliaClient, interaction: ChatInputCommandInteraction<"cached">) { // All interactions are cached
         await ephemeralFollowUpResponse(interaction, "Pong!", true); // Response is ephemeral and deleted after 60 seconds
     }
 } as CommandStructure;

package/dist/client/StelliaUtils.js

@@ -52,18 +52,21 @@ export class StelliaUtils {
     };
     handleAutoCompleteInteraction = async (interaction) => {
         try {
-            const interactionAutoComplete = interaction;
+            const autoCompleteInteraction = interaction;
             const autoCompleteManager = this.client.managers.autoCompletes;
             if (!autoCompleteManager)
                 return;
-            const autoComplete = autoCompleteManager.getByCustomId(interactionAutoComplete.commandName);
+            const autoComplete = autoCompleteManager.getByCustomId(autoCompleteInteraction.commandName);
             if (!autoComplete)
                 return;
             if (this.client.environment.areEnvironmentsEnabled) {
-                await autoComplete.execute(this.client, this.environment, interactionAutoComplete);
-                return;
+                const autoCompleteWithEnv = autoComplete;
+                await autoCompleteWithEnv.execute(this.client, this.environment, autoCompleteInteraction);
+            }
+            else {
+                const autoCompleteWithoutEnv = autoComplete;
+                await autoCompleteWithoutEnv.execute(this.client, autoCompleteInteraction);
             }
-            await autoComplete.execute(this.client, interactionAutoComplete);
         }
         catch (error) {
             console.error(error);
@@ -79,10 +82,13 @@ export class StelliaUtils {
             if (!button)
                 return;
             if (this.client.environment.areEnvironmentsEnabled) {
-                await button.execute(this.client, this.environment, buttonInteraction);
-                return;
+                const buttonWithEnv = button;
+                await buttonWithEnv.execute(this.client, this.environment, buttonInteraction);
+            }
+            else {
+                const buttonWithoutEnv = button;
+                await buttonWithoutEnv.execute(this.client, buttonInteraction);
             }
-            await button.execute(this.client, buttonInteraction);
         }
         catch (error) {
             console.error(error);
@@ -90,18 +96,21 @@ export class StelliaUtils {
     };
     handleCommandInteraction = async (interaction) => {
         try {
-            const interactionCommand = interaction;
+            const commandInteraction = interaction;
             const commandManager = this.client.managers.commands;
             if (!commandManager)
                 return;
-            const command = commandManager.getByCustomId(interactionCommand.commandName);
+            let command = commandManager.getByCustomId(commandInteraction.commandName);
             if (!command)
                 return;
             if (this.client.environment.areEnvironmentsEnabled) {
-                await command.execute(this.client, this.environment, interactionCommand);
-                return;
+                const commandWithEnv = command;
+                await commandWithEnv.execute(this.client, this.environment, commandInteraction);
+            }
+            else {
+                const commandWithoutEnv = command;
+                await commandWithoutEnv.execute(this.client, commandInteraction);
             }
-            await command.execute(this.client, interactionCommand);
         }
         catch (error) {
             console.error(error);
@@ -125,18 +134,21 @@ export class StelliaUtils {
     };
     handleModalInteraction = async (interaction) => {
         try {
-            const interactionModal = interaction;
+            const modalInteraction = interaction;
             const modalManager = this.client.managers.modals;
             if (!modalManager)
                 return;
-            const modal = modalManager.getByCustomId(interactionModal.customId) || modalManager.getByRegex(interactionModal.customId);
+            const modal = modalManager.getByCustomId(modalInteraction.customId) || modalManager.getByRegex(modalInteraction.customId);
             if (!modal)
                 return;
             if (this.client.environment.areEnvironmentsEnabled) {
-                await modal.execute(this.client, this.environment, interactionModal);
-                return;
+                const modalWithEnv = modal;
+                await modalWithEnv.execute(this.client, this.environment, modalInteraction);
+            }
+            else {
+                const modalWithoutEnv = modal;
+                await modalWithoutEnv.execute(this.client, modalInteraction);
             }
-            await modal.execute(this.client, interactionModal);
         }
         catch (error) {
             console.error(error);
@@ -144,18 +156,21 @@ export class StelliaUtils {
     };
     handleSelectMenuInteraction = async (interaction) => {
         try {
-            const interactionSelectMenu = interaction;
+            const selectMenuInteraction = interaction;
             const selectMenuManager = this.client.managers.selectMenus;
             if (!selectMenuManager)
                 return;
-            const selectMenu = selectMenuManager.getByCustomId(interactionSelectMenu.customId) || selectMenuManager.getByRegex(interactionSelectMenu.customId);
+            const selectMenu = selectMenuManager.getByCustomId(selectMenuInteraction.customId) || selectMenuManager.getByRegex(selectMenuInteraction.customId);
             if (!selectMenu)
                 return;
             if (this.client.environment.areEnvironmentsEnabled) {
-                await selectMenu.execute(this.client, this.environment, interactionSelectMenu);
-                return;
+                const selectMenuWithEnv = selectMenu;
+                await selectMenuWithEnv.execute(this.client, this.environment, selectMenuInteraction);
+            }
+            else {
+                const modalWithoutEnv = selectMenu;
+                await modalWithoutEnv.execute(this.client, selectMenuInteraction);
             }
-            await selectMenu.execute(this.client, interactionSelectMenu);
         }
         catch (error) {
             console.error(error);
@@ -170,10 +185,13 @@ export class StelliaUtils {
             if (!messageContextMenu)
                 return;
             if (this.client.environment.areEnvironmentsEnabled) {
-                await messageContextMenu.execute(this.client, this.environment, interaction);
-                return;
+                const messageContextMenuWithEnv = messageContextMenu;
+                await messageContextMenuWithEnv.execute(this.client, this.environment, interaction);
+            }
+            else {
+                const messageContextMenuWithoutEnv = messageContextMenu;
+                await messageContextMenuWithoutEnv.execute(this.client, interaction);
             }
-            await messageContextMenu.execute(this.client, interaction);
         }
         catch (error) {
             console.error(error);
@@ -188,10 +206,13 @@ export class StelliaUtils {
             if (!userContextMenu)
                 return;
             if (this.client.environment.areEnvironmentsEnabled) {
-                await userContextMenu.execute(this.client, this.environment, interaction);
-                return;
+                const userContextMenuWithEnv = userContextMenu;
+                await userContextMenuWithEnv.execute(this.client, this.environment, interaction);
+            }
+            else {
+                const userContextMenuWithoutEnv = userContextMenu;
+                await userContextMenuWithoutEnv.execute(this.client, interaction);
             }
-            await userContextMenu.execute(this.client, interaction);
         }
         catch (error) {
             console.error(error);

package/dist/managers/EventManager.js

@@ -9,12 +9,13 @@ export class EventManager extends BaseManager {
     async loadData() {
         const events = await requiredFiles(this.directoryPath);
         this.interactions = events;
-        for (const event of this.interactions.values()) {
-            const { name, once } = event.data;
+        for (const eventStructure of this.interactions.values()) {
+            const { name, once } = eventStructure.data;
             if (this.client.environment.areEnvironmentsEnabled) {
                 const environment = await this.client.getEnvironment();
+                const event = eventStructure;
                 if (name == Events.ClientReady) {
-                    this.client.once(name, () => event.execute(this.client, environment));
+                    this.client.once(Events.ClientReady, () => event.execute(this.client, environment));
                     continue;
                 }
                 if (once) {
@@ -25,6 +26,7 @@ export class EventManager extends BaseManager {
                 }
             }
             else {
+                const event = eventStructure;
                 if (name == Events.ClientReady) {
                     this.client.once(name, () => event.execute(this.client));
                     continue;

package/dist/structures/Event.d.ts

@@ -1,14 +1,19 @@
 import { type Awaitable, type ClientEvents } from "discord.js";
 import { type StelliaClient } from "../client/index.js";
-import type { EnvironmentConfiguration } from "../typescript/types.js";
-export interface EventStructure<Event extends keyof ClientEvents = keyof ClientEvents> {
-    data: {
-        name: Event;
-        once: boolean;
-    };
-    execute(client: StelliaClient): Awaitable<unknown>;
-    execute(...args: ClientEvents[Event]): Awaitable<unknown>;
+import { type EnvironmentConfiguration } from "../typescript/types.js";
+export interface EventStructureWithEnvironment extends EventInteractionStructure {
+    execute(client: StelliaClient, environment: EnvironmentConfiguration, ...args: ClientEvents[Event]): Awaitable<unknown>;
+}
+export interface EventStructureWithoutEnvironment extends EventInteractionStructure {
     execute(client: StelliaClient, ...args: ClientEvents[Event]): Awaitable<unknown>;
-    execute<CustomEnvironment extends EnvironmentConfiguration>(client: StelliaClient, environment: CustomEnvironment): Awaitable<unknown>;
-    execute<CustomEnvironment extends EnvironmentConfiguration>(client: StelliaClient, environment: CustomEnvironment, ...args: ClientEvents[Event]): Awaitable<unknown>;
 }
+export type EventStructure = EventStructureWithEnvironment | EventStructureWithoutEnvironment;
+interface EventInteractionStructure {
+    data: EventDataStructure;
+}
+interface EventDataStructure {
+    name: Event;
+    once: boolean;
+}
+type Event = keyof ClientEvents;
+export {};

package/dist/structures/Interaction.d.ts

@@ -1,39 +1,64 @@
-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 AnySelectMenuInteraction, type AutocompleteInteraction, type Awaitable, type ButtonInteraction, type ChatInputCommandInteraction, type ContextMenuCommandType, type MessageContextMenuCommandInteraction, type ModalSubmitInteraction, type SlashCommandOptionsOnlyBuilder, 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;
+export interface AutoCompleteStructureWithEnvironment extends MessageInteractionStructure {
+    execute(client: StelliaClient, environment: EnvironmentConfiguration, interaction: AutocompleteInteraction<"cached">): Awaitable<unknown>;
+}
+export interface AutoCompleteStructureWithoutEnvironment extends MessageInteractionStructure {
     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;
+export type AutoCompleteStructure = AutoCompleteStructureWithEnvironment | AutoCompleteStructureWithoutEnvironment;
+export interface ButtonStructureWithEnvironment extends MessageInteractionStructure {
+    execute(client: StelliaClient, environment: EnvironmentConfiguration, interaction: ButtonInteraction<"cached">): Awaitable<unknown>;
+}
+export interface ButtonStructureWithoutEnvironment extends MessageInteractionStructure {
     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;
+export type ButtonStructure = ButtonStructureWithEnvironment | ButtonStructureWithoutEnvironment;
+export interface CommandStructureWithEnvironment extends CommandInteractionStructure {
+    execute(client: StelliaClient, environment: EnvironmentConfiguration, interaction: ChatInputCommandInteraction<"cached">): Awaitable<unknown>;
+}
+export interface CommandStructureWithoutEnvironment extends CommandInteractionStructure {
     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;
+export type CommandStructure = CommandStructureWithEnvironment | CommandStructureWithoutEnvironment;
+export interface ContextMenuStructureWithEnvironment extends ContextMenuInteractionStructure {
+    execute(client: StelliaClient, environment: EnvironmentConfiguration, interaction: MessageContextMenuCommandInteraction<"cached"> | UserContextMenuCommandInteraction<"cached">): Awaitable<unknown>;
+}
+export interface ContextMenuStructureWithoutEnvironment extends ContextMenuInteractionStructure {
     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;
+export type ContextMenuStructure = ContextMenuStructureWithEnvironment | ContextMenuStructureWithoutEnvironment;
+export interface ModalStructureWithEnvironment extends MessageInteractionStructure {
+    execute(client: StelliaClient, environment: EnvironmentConfiguration, interaction: ModalSubmitInteraction<"cached">): Awaitable<unknown>;
+}
+export interface ModalStructureWithoutEnvironment extends MessageInteractionStructure {
     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;
+export type ModalStructure = ModalStructureWithEnvironment | ModalStructureWithoutEnvironment;
+export interface SelectMenuStructureWithEnvironment extends MessageInteractionStructure {
+    execute(client: StelliaClient, environment: EnvironmentConfiguration, interaction: AnySelectMenuInteraction<"cached">): Awaitable<unknown>;
+}
+export interface SelectMenuStructureWithoutEnvironment extends MessageInteractionStructure {
     execute(client: StelliaClient, interaction: AnySelectMenuInteraction<"cached">): Awaitable<unknown>;
-    execute<CustomEnvironment extends EnvironmentConfiguration>(client: StelliaClient, environment: CustomEnvironment, interaction: AnySelectMenuInteraction<"cached">): Awaitable<unknown>;
 }
+export type SelectMenuStructure = SelectMenuStructureWithEnvironment | SelectMenuStructureWithoutEnvironment;
 export type AnyInteractionStructure = AutoCompleteStructure | ButtonStructure | CommandStructure | ContextMenuStructure | EventStructure | ModalStructure | SelectMenuStructure;
-interface DefaultDataStructure {
+interface CommandInteractionStructure {
+    data: SlashCommandOptionsOnlyBuilder;
+}
+interface ContextMenuInteractionStructure {
+    data: ContextMenuDataStructure;
+}
+interface ContextMenuDataStructure {
+    name: string;
+    type: ContextMenuCommandType;
+}
+interface MessageInteractionStructure {
+    data: MessageDataStructure;
+}
+interface MessageDataStructure {
     name: string | RegExp;
     once: boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stelliajs/framework",
-  "version": "1.2.3",
+  "version": "1.3.0-dev-1",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "scripts": {
@@ -15,12 +15,13 @@
   "description": "A framework for simplify the creation of discord bots",
   "keywords": ["discord", "bot", "discordjs", "typescript", "framework"],
   "dependencies": {
-    "discord-api-types": "^0.37.119",
-    "discord.js": "^14.18.0"
+    "discord-api-types": "^0.38.2",
+    "discord.js": "^14.19.3"
   },
   "devDependencies": {
     "ts-node": "^10.9.2",
-    "tsc-alias": "^1.8.10"
+    "tsc-alias": "^1.8.15"
   },
-  "type": "module"
+  "type": "module",
+  "packageManager": "pnpm@10.10.0"
 }