@stelliajs/framework 1.0.0

package/dist/client/StelliaClient.d.ts

@@ -0,0 +1,27 @@
+import { Client, type ClientOptions } from "discord.js";
+import { AutoCompleteManager, ButtonManager, CommandManager, ContextMenuManager, EventManager, type ManagerOptions, ModalManager, SelectMenuManager } from "../managers/index.js";
+import { type AnyInteraction } from "../typescript/index.js";
+export declare class StelliaClient<Ready extends boolean = boolean> extends Client<Ready> {
+    private readonly utils;
+    readonly autoCompletes: AutoCompleteManager;
+    readonly buttons: ButtonManager;
+    readonly commands: CommandManager;
+    readonly contextMenus: ContextMenuManager;
+    readonly events: EventManager;
+    readonly selectMenus: SelectMenuManager;
+    readonly modals: ModalManager;
+    constructor(clientOptions: ClientOptions, stelliaOptions: StelliaOptions);
+    connect: (token: string) => Promise<void>;
+    initializeCommands: () => Promise<void>;
+    handleInteraction: (interaction: AnyInteraction) => Promise<void>;
+}
+interface StelliaOptions {
+    autoCompletes: ManagerOptions;
+    buttons: ManagerOptions;
+    commands: ManagerOptions;
+    contextMenus: ManagerOptions;
+    events: ManagerOptions;
+    selectMenus: ManagerOptions;
+    modals: ManagerOptions;
+}
+export {};

package/dist/client/StelliaClient.js

@@ -0,0 +1,37 @@
+import { Client, Events } from "discord.js";
+import { AutoCompleteManager, ButtonManager, CommandManager, ContextMenuManager, EventManager, ModalManager, SelectMenuManager } from "../managers/index.js";
+import { StelliaUtils } from "./index.js";
+export class StelliaClient extends Client {
+    utils;
+    autoCompletes;
+    buttons;
+    commands;
+    contextMenus;
+    events;
+    selectMenus;
+    modals;
+    constructor(clientOptions, stelliaOptions) {
+        super(clientOptions);
+        this.utils = new StelliaUtils(this);
+        this.autoCompletes = new AutoCompleteManager(this, stelliaOptions.autoCompletes.directoryPath);
+        this.buttons = new ButtonManager(this, stelliaOptions.buttons.directoryPath);
+        this.commands = new CommandManager(this, stelliaOptions.commands.directoryPath);
+        this.contextMenus = new ContextMenuManager(this, stelliaOptions.contextMenus.directoryPath);
+        this.events = new EventManager(this, stelliaOptions.events.directoryPath);
+        this.selectMenus = new SelectMenuManager(this, stelliaOptions.selectMenus.directoryPath);
+        this.modals = new ModalManager(this, stelliaOptions.modals.directoryPath);
+    }
+    connect = async (token) => {
+        this.on(Events.Error, (error) => console.error(error));
+        await this.login(token);
+        process.on("unhandledRejection", (error) => {
+            console.error(`Unhandled promise rejection: ${error}`);
+        });
+    };
+    initializeCommands = async () => {
+        await this.utils.initializeCommands();
+    };
+    handleInteraction = async (interaction) => {
+        await this.utils.handleInteraction(interaction);
+    };
+}

package/dist/client/StelliaUtils.d.ts

@@ -0,0 +1,18 @@
+import { type StelliaClient } from "./index.js";
+import { AnyInteraction } from "../typescript/index.js";
+export declare class StelliaUtils {
+    readonly client: StelliaClient;
+    private readonly interactionHandlers;
+    constructor(client: StelliaClient);
+    initializeCommands: () => Promise<void>;
+    handleInteraction: (interaction: AnyInteraction) => Promise<void>;
+    private handleAutoCompleteInteraction;
+    private handleButtonInteraction;
+    private handleCommandInteraction;
+    private handleContextMenuInteraction;
+    private handleModalInteraction;
+    private handleSelectMenuInteraction;
+    private handleMessageContextMenuInteraction;
+    private handleUserContextMenuInteraction;
+    private getInteractionType;
+}

package/dist/client/StelliaUtils.js

@@ -0,0 +1,164 @@
+import { ApplicationCommandType, REST, Routes } from "discord.js";
+import { DISCORD_API_VERSION } from "../constants/index.js";
+import { InteractionType } from "../typescript/index.js";
+export class StelliaUtils {
+    client;
+    interactionHandlers;
+    constructor(client) {
+        this.client = client;
+        this.interactionHandlers = new Map([
+            [InteractionType.Autocomplete, this.handleAutoCompleteInteraction],
+            [InteractionType.Button, this.handleButtonInteraction],
+            [InteractionType.ChatInputCommand, this.handleCommandInteraction],
+            [InteractionType.ContextMenuCommand, this.handleContextMenuInteraction],
+            [InteractionType.ModalSubmit, this.handleModalInteraction],
+            [InteractionType.SelectMenu, this.handleSelectMenuInteraction]
+        ]);
+    }
+    initializeCommands = async () => {
+        const commands = [
+            ...Array.from(this.client.commands.getAll().values()).map((command) => command.data),
+            ...Array.from(this.client.contextMenus.getAll().values()).map((contextMenu) => contextMenu.data),
+        ];
+        if (this.client.isReady()) {
+            const rest = new REST({ version: DISCORD_API_VERSION }).setToken(this.client.token);
+            try {
+                await rest.put(Routes.applicationCommands(this.client.user.id), { body: commands });
+            }
+            catch (error) {
+                console.error(error);
+            }
+        }
+    };
+    handleInteraction = async (interaction) => {
+        if (interaction.inCachedGuild()) {
+            const interactionType = this.getInteractionType(interaction);
+            if (interactionType === InteractionType.Unknown) {
+                throw new Error("Unknown interaction type");
+            }
+            const handler = this.interactionHandlers.get(interactionType);
+            if (handler) {
+                await handler(interaction);
+            }
+        }
+    };
+    handleAutoCompleteInteraction = async (interaction) => {
+        try {
+            const interactionAutoComplete = interaction;
+            const autoComplete = this.client.autoCompletes.get(interactionAutoComplete.commandName);
+            if (!autoComplete)
+                return;
+            await autoComplete.execute(this.client, interactionAutoComplete);
+        }
+        catch (error) {
+            console.error(error);
+        }
+    };
+    handleButtonInteraction = async (interaction) => {
+        try {
+            const buttonInteraction = interaction;
+            const button = this.client.buttons.get(buttonInteraction.customId);
+            if (!button)
+                return;
+            await button.execute(this.client, buttonInteraction);
+        }
+        catch (error) {
+            console.error(error);
+        }
+    };
+    handleCommandInteraction = async (interaction) => {
+        try {
+            const interactionCommand = interaction;
+            const command = this.client.commands.get(interactionCommand.commandName);
+            if (!command)
+                return;
+            await command.execute(this.client, interactionCommand);
+        }
+        catch (error) {
+            console.error(error);
+        }
+    };
+    handleContextMenuInteraction = async (interaction) => {
+        try {
+            const interactionContextMenu = interaction;
+            if (interactionContextMenu.commandType === ApplicationCommandType.Message) {
+                const messageInteraction = interaction;
+                await this.handleMessageContextMenuInteraction(messageInteraction);
+            }
+            else if (interactionContextMenu.commandType === ApplicationCommandType.User) {
+                const userInteraction = interaction;
+                await this.handleUserContextMenuInteraction(userInteraction);
+            }
+        }
+        catch (error) {
+            console.error(error);
+        }
+    };
+    handleModalInteraction = async (interaction) => {
+        try {
+            const interactionModal = interaction;
+            const modal = this.client.modals.get(interactionModal.customId);
+            if (!modal)
+                return;
+            await modal.execute(this.client, interactionModal);
+        }
+        catch (error) {
+            console.error(error);
+        }
+    };
+    handleSelectMenuInteraction = async (interaction) => {
+        try {
+            const interactionSelectMenu = interaction;
+            const selectMenu = this.client.modals.get(interactionSelectMenu.customId);
+            if (!selectMenu)
+                return;
+            await selectMenu.execute(this.client, interactionSelectMenu);
+        }
+        catch (error) {
+            console.error(error);
+        }
+    };
+    handleMessageContextMenuInteraction = async (interaction) => {
+        try {
+            const messageContextMenu = this.client.contextMenus.get(interaction.commandName);
+            if (!messageContextMenu)
+                return;
+            await messageContextMenu.execute(this.client, interaction);
+        }
+        catch (error) {
+            console.error(error);
+        }
+    };
+    handleUserContextMenuInteraction = async (interaction) => {
+        try {
+            const userContextMenu = this.client.contextMenus.get(interaction.commandName);
+            if (!userContextMenu)
+                return;
+            await userContextMenu.execute(this.client, interaction);
+        }
+        catch (error) {
+            console.error(error);
+        }
+    };
+    getInteractionType(interaction) {
+        if (interaction.isAutocomplete()) {
+            return InteractionType.Autocomplete;
+        }
+        if (interaction.isButton()) {
+            return InteractionType.Button;
+        }
+        if (interaction.isChatInputCommand()) {
+            return InteractionType.ChatInputCommand;
+        }
+        if (interaction.isContextMenuCommand()) {
+            return InteractionType.ContextMenuCommand;
+        }
+        if (interaction.isModalSubmit()) {
+            return InteractionType.ModalSubmit;
+        }
+        if (interaction.isAnySelectMenu()) {
+            return InteractionType.SelectMenu;
+        }
+        return InteractionType.Unknown;
+    }
+}

package/dist/client/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./StelliaClient.js";
+export * from "./StelliaUtils.js";

package/dist/client/index.js

@@ -0,0 +1,2 @@
+export * from "./StelliaClient.js";
+export * from "./StelliaUtils.js";

package/dist/constants/apiVersion.d.ts

@@ -0,0 +1 @@
+export declare const DISCORD_API_VERSION = "10";

package/dist/constants/apiVersion.js

@@ -0,0 +1 @@
+export const DISCORD_API_VERSION = "10";

package/dist/constants/index.d.ts

@@ -0,0 +1 @@
+export * from "./apiVersion.js";

package/dist/constants/index.js

@@ -0,0 +1 @@
+export * from "./apiVersion.js";

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./client/index.js";
+export * from "./constants/index.js";
+export * from "./managers/index.js";
+export * from "./structures/index.js";
+export * from "./typescript/index.js";
+export * from "./utils/index.js";

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from "./client/index.js";
+export * from "./constants/index.js";
+export * from "./managers/index.js";
+export * from "./structures/index.js";
+export * from "./typescript/index.js";
+export * from "./utils/index.js";

package/dist/managers/AutoCompleteManager.d.ts

@@ -0,0 +1,11 @@
+import { Collection } from "discord.js";
+import { type StelliaClient } from "../client/index.js";
+import { BaseManager } from "./index.js";
+import { type CustomId } from "../typescript/index.js";
+export declare class AutoCompleteManager extends BaseManager {
+    private autoCompletes;
+    constructor(client: StelliaClient, directory: string);
+    loadData(): Promise<void>;
+    get<AutoCompleteStructure>(id: CustomId): AutoCompleteStructure | undefined;
+    getAll<AutoCompleteStructure>(): Collection<CustomId, AutoCompleteStructure>;
+}

package/dist/managers/AutoCompleteManager.js

@@ -0,0 +1,21 @@
+import { Collection } from "discord.js";
+import { BaseManager } from "./index.js";
+import { requiredFiles } from "../utils/index.js";
+export class AutoCompleteManager extends BaseManager {
+    autoCompletes = new Collection();
+    constructor(client, directory) {
+        super(client, directory);
+    }
+    async loadData() {
+        const autoCompletes = await requiredFiles(this.directoryPath);
+        this.autoCompletes = autoCompletes;
+    }
+    get(id) {
+        const autoComplete = this.autoCompletes.get(id) ?? undefined;
+        return autoComplete;
+    }
+    getAll() {
+        const autoCompletes = this.autoCompletes;
+        return autoCompletes;
+    }
+}

package/dist/managers/BaseManager.d.ts

@@ -0,0 +1,15 @@
+import { Collection } from "discord.js";
+import { type StelliaClient } from "../client/index.js";
+import { type CustomId } from "../typescript/index.js";
+import { type AnyInteractionStructure } from "../structures/index.js";
+export interface ManagerOptions {
+    directoryPath: string;
+}
+export declare abstract class BaseManager {
+    readonly client: StelliaClient;
+    readonly directoryPath: string;
+    constructor(client: StelliaClient, directory: string);
+    abstract loadData(): void;
+    abstract get<InteractionStructure extends AnyInteractionStructure>(id: CustomId): InteractionStructure | undefined;
+    abstract getAll<InteractionStructure extends AnyInteractionStructure>(): Collection<CustomId, InteractionStructure>;
+}

package/dist/managers/BaseManager.js

@@ -0,0 +1,9 @@
+export class BaseManager {
+    client;
+    directoryPath;
+    constructor(client, directory) {
+        this.client = client;
+        this.directoryPath = directory;
+        this.loadData();
+    }
+}

package/dist/managers/ButtonManager.d.ts

@@ -0,0 +1,12 @@
+import { Collection } from "discord.js";
+import { type StelliaClient } from "../client/index.js";
+import { BaseManager } from "./index.js";
+import { type ButtonStructure } from "../structures/index.js";
+import { type CustomId } from "../typescript/index.js";
+export declare class ButtonManager extends BaseManager {
+    buttons: Collection<CustomId, ButtonStructure>;
+    constructor(client: StelliaClient, directory: string);
+    loadData(): Promise<void>;
+    get<ButtonStructure>(id: CustomId): ButtonStructure | undefined;
+    getAll<ButtonStructure>(): Collection<CustomId, ButtonStructure>;
+}

package/dist/managers/ButtonManager.js

@@ -0,0 +1,21 @@
+import { Collection } from "discord.js";
+import { BaseManager } from "./index.js";
+import { requiredFiles } from "../utils/index.js";
+export class ButtonManager extends BaseManager {
+    buttons = new Collection();
+    constructor(client, directory) {
+        super(client, directory);
+    }
+    async loadData() {
+        const buttons = await requiredFiles(this.directoryPath);
+        this.buttons = buttons;
+    }
+    get(id) {
+        const button = this.buttons.get(id) ?? undefined;
+        return button;
+    }
+    getAll() {
+        const buttons = this.buttons;
+        return buttons;
+    }
+}

package/dist/managers/CommandManager.d.ts

@@ -0,0 +1,12 @@
+import { Collection } from "discord.js";
+import { type StelliaClient } from "../client/index.js";
+import { BaseManager } from "./index.js";
+import { type CommandStructure } from "../structures/index.js";
+import { type CustomId } from "../typescript/index.js";
+export declare class CommandManager extends BaseManager {
+    commands: Collection<CustomId, CommandStructure>;
+    constructor(client: StelliaClient, directory: string);
+    loadData(): Promise<void>;
+    get<CommandStructure>(id: CustomId): CommandStructure | undefined;
+    getAll<CommandStructure>(): Collection<CustomId, CommandStructure>;
+}

package/dist/managers/CommandManager.js

@@ -0,0 +1,21 @@
+import { Collection } from "discord.js";
+import { BaseManager } from "./index.js";
+import { requiredFiles } from "../utils/index.js";
+export class CommandManager extends BaseManager {
+    commands = new Collection();
+    constructor(client, directory) {
+        super(client, directory);
+    }
+    async loadData() {
+        const commands = await requiredFiles(this.directoryPath);
+        this.commands = commands;
+    }
+    get(id) {
+        const command = this.commands.get(id) ?? undefined;
+        return command;
+    }
+    getAll() {
+        const commands = this.commands;
+        return commands;
+    }
+}

package/dist/managers/ContextMenuManager.d.ts

@@ -0,0 +1,12 @@
+import { Collection } from "discord.js";
+import { type StelliaClient } from "../client/index.js";
+import { BaseManager } from "./index.js";
+import { type ContextMenuStructure } from "../structures/index.js";
+import { type CustomId } from "../typescript/index.js";
+export declare class ContextMenuManager extends BaseManager {
+    contextMenus: Collection<CustomId, ContextMenuStructure>;
+    constructor(client: StelliaClient, directory: string);
+    loadData(): Promise<void>;
+    get<ContextMenuStructure>(id: CustomId): ContextMenuStructure | undefined;
+    getAll<ContextMenuStructure>(): Collection<CustomId, ContextMenuStructure>;
+}

package/dist/managers/ContextMenuManager.js

@@ -0,0 +1,21 @@
+import { Collection } from "discord.js";
+import { BaseManager } from "./index.js";
+import { requiredFiles } from "../utils/index.js";
+export class ContextMenuManager extends BaseManager {
+    contextMenus = new Collection();
+    constructor(client, directory) {
+        super(client, directory);
+    }
+    async loadData() {
+        const contextMenus = await requiredFiles(this.directoryPath);
+        this.contextMenus = contextMenus;
+    }
+    get(id) {
+        const contextMenu = this.contextMenus.get(id) ?? undefined;
+        return contextMenu;
+    }
+    getAll() {
+        const contextMenus = this.contextMenus;
+        return contextMenus;
+    }
+}

package/dist/managers/EventManager.d.ts

@@ -0,0 +1,12 @@
+import { Collection } from "discord.js";
+import { type StelliaClient } from "../client/index.js";
+import { BaseManager } from "./index.js";
+import { type EventStructure } from "../structures/index.js";
+import { type CustomId } from "../typescript/index.js";
+export declare class EventManager extends BaseManager {
+    events: Collection<CustomId, EventStructure>;
+    constructor(client: StelliaClient, directoryPath: string);
+    loadData(): Promise<void>;
+    get<EventStructure>(id: CustomId): EventStructure | undefined;
+    getAll<EventStructure>(): Collection<CustomId, EventStructure>;
+}

package/dist/managers/EventManager.js

@@ -0,0 +1,30 @@
+import { Collection } from "discord.js";
+import { BaseManager } from "./index.js";
+import { requiredFiles } from "../utils/index.js";
+export class EventManager extends BaseManager {
+    events = new Collection();
+    constructor(client, directoryPath) {
+        super(client, directoryPath);
+    }
+    async loadData() {
+        const events = await requiredFiles(this.directoryPath);
+        this.events = events;
+        for (const event of this.events.values()) {
+            const { name, once } = event.data;
+            if (once) {
+                this.client.once(name, (...args) => event.execute(this.client, ...args));
+            }
+            else {
+                this.client.on(name, (...args) => event.execute(this.client, ...args));
+            }
+        }
+    }
+    get(id) {
+        const event = this.events.get(id) ?? undefined;
+        return event;
+    }
+    getAll() {
+        const events = this.events;
+        return events;
+    }
+}

package/dist/managers/ModalManager.d.ts

@@ -0,0 +1,12 @@
+import { Collection } from "discord.js";
+import { type StelliaClient } from "../client/index.js";
+import { BaseManager } from "./index.js";
+import { type ModalStructure } from "../structures/index.js";
+import { type CustomId } from "../typescript/index.js";
+export declare class ModalManager extends BaseManager {
+    modals: Collection<CustomId, ModalStructure>;
+    constructor(client: StelliaClient, directory: string);
+    loadData(): Promise<void>;
+    get<ModalStructure>(id: CustomId): ModalStructure | undefined;
+    getAll<ModalStructure>(): Collection<CustomId, ModalStructure>;
+}

package/dist/managers/ModalManager.js

@@ -0,0 +1,21 @@
+import { Collection } from "discord.js";
+import { BaseManager } from "./index.js";
+import { requiredFiles } from "../utils/index.js";
+export class ModalManager extends BaseManager {
+    modals = new Collection();
+    constructor(client, directory) {
+        super(client, directory);
+    }
+    async loadData() {
+        const modals = await requiredFiles(this.directoryPath);
+        this.modals = modals;
+    }
+    get(id) {
+        const modal = this.modals.get(id) ?? undefined;
+        return modal;
+    }
+    getAll() {
+        const modals = this.modals;
+        return modals;
+    }
+}

package/dist/managers/SelectMenuManager.d.ts

@@ -0,0 +1,12 @@
+import { Collection } from "discord.js";
+import { type StelliaClient } from "../client/index.js";
+import { BaseManager } from "./index.js";
+import { type SelectMenuStructure } from "../structures/index.js";
+import { type CustomId } from "../typescript/index.js";
+export declare class SelectMenuManager extends BaseManager {
+    selectMenus: Collection<CustomId, SelectMenuStructure>;
+    constructor(client: StelliaClient, directory: string);
+    loadData(): Promise<void>;
+    get<SelectMenuStructure>(id: CustomId): SelectMenuStructure | undefined;
+    getAll<SelectMenuStructure>(): Collection<CustomId, SelectMenuStructure>;
+}

package/dist/managers/SelectMenuManager.js

@@ -0,0 +1,21 @@
+import { Collection } from "discord.js";
+import { BaseManager } from "./index.js";
+import { requiredFiles } from "../utils/index.js";
+export class SelectMenuManager extends BaseManager {
+    selectMenus = new Collection();
+    constructor(client, directory) {
+        super(client, directory);
+    }
+    async loadData() {
+        const selectMenus = await requiredFiles(this.directoryPath);
+        this.selectMenus = selectMenus;
+    }
+    get(id) {
+        const selectMenu = this.selectMenus.get(id) ?? undefined;
+        return selectMenu;
+    }
+    getAll() {
+        const selectMenus = this.selectMenus;
+        return selectMenus;
+    }
+}

package/dist/managers/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./BaseManager.js";
+export * from "./AutoCompleteManager.js";
+export * from "./ButtonManager.js";
+export * from "./CommandManager.js";
+export * from "./ContextMenuManager.js";
+export * from "./EventManager.js";
+export * from "./ModalManager.js";
+export * from "./SelectMenuManager.js";

package/dist/managers/index.js

@@ -0,0 +1,8 @@
+export * from "./BaseManager.js";
+export * from "./AutoCompleteManager.js";
+export * from "./ButtonManager.js";
+export * from "./CommandManager.js";
+export * from "./ContextMenuManager.js";
+export * from "./EventManager.js";
+export * from "./ModalManager.js";
+export * from "./SelectMenuManager.js";

package/dist/structures/Event.d.ts

@@ -0,0 +1,11 @@
+import { type Awaitable, type ClientEvents } from "discord.js";
+import { type StelliaClient } from "../client/index.js";
+type EventArguments<Event extends keyof ClientEvents> = ClientEvents[Event];
+export interface EventStructure<Event extends keyof ClientEvents = keyof ClientEvents> {
+    data: {
+        name: keyof ClientEvents;
+        once: boolean;
+    };
+    execute(client: StelliaClient, ...args: EventArguments<Event>): Awaitable<unknown>;
+}
+export {};

package/dist/structures/Event.js

@@ -0,0 +1 @@
+export {};

package/dist/structures/Interaction.d.ts

@@ -0,0 +1,32 @@
+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";
+export interface AutoCompleteStructure {
+    data: DefaultDataStructure;
+    execute(client: StelliaClient, interaction: AutocompleteInteraction<"cached">): Awaitable<unknown>;
+}
+export interface ButtonStructure {
+    data: DefaultDataStructure;
+    execute(client: StelliaClient, interaction: ButtonInteraction<"cached">): Awaitable<unknown>;
+}
+export interface CommandStructure {
+    data: SlashCommandBuilder;
+    execute(client: StelliaClient, interaction: ChatInputCommandInteraction<"cached">): Awaitable<unknown>;
+}
+export interface ContextMenuStructure {
+    data: ContextMenuCommandBuilder;
+    execute(client: StelliaClient, interaction: MessageContextMenuCommandInteraction<"cached"> | UserContextMenuCommandInteraction<"cached">): Awaitable<unknown>;
+}
+export interface ModalStructure {
+    data: DefaultDataStructure;
+    execute(client: StelliaClient, interaction: ModalSubmitInteraction<"cached">): Awaitable<unknown>;
+}
+export interface SelectMenuStructure {
+    data: DefaultDataStructure;
+    execute(client: StelliaClient, interaction: AnySelectMenuInteraction<"cached">): Awaitable<unknown>;
+}
+export type AnyInteractionStructure = AutoCompleteStructure | ButtonStructure | CommandStructure | ContextMenuStructure | ModalStructure | SelectMenuStructure;
+interface DefaultDataStructure {
+    name: string;
+    once: boolean;
+}
+export {};

package/dist/structures/Interaction.js

@@ -0,0 +1 @@
+export {};

package/dist/structures/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Event.js";
+export * from "./Interaction.js";

package/dist/structures/index.js

@@ -0,0 +1,2 @@
+export * from "./Event.js";
+export * from "./Interaction.js";

package/dist/typescript/index.d.ts

@@ -0,0 +1 @@
+export * from "./types.js";

package/dist/typescript/index.js

@@ -0,0 +1 @@
+export * from "./types.js";

package/dist/typescript/types.d.ts

@@ -0,0 +1,39 @@
+import { type AnySelectMenuInteraction, type AutocompleteInteraction, type ButtonInteraction, type ChatInputCommandInteraction, type ContextMenuCommandInteraction, type ModalSubmitInteraction, type UserContextMenuCommandInteraction } from "discord.js";
+export type CustomId = string;
+export type AnyInteraction = AutocompleteInteraction<"cached"> | ButtonInteraction<"cached"> | ChatInputCommandInteraction<"cached"> | ContextMenuCommandInteraction<"cached"> | ModalSubmitInteraction<"cached"> | AnySelectMenuInteraction<"cached"> | UserContextMenuCommandInteraction<"cached">;
+export declare enum InteractionType {
+    Autocomplete = "Autocomplete",
+    Button = "Button",
+    ChatInputCommand = "ChatInputCommand",
+    ContextMenuCommand = "ContextMenuCommand",
+    ModalSubmit = "ModalSubmit",
+    SelectMenu = "SelectMenu",
+    Unknown = "Unknown"
+}
+export type InteractionData = {
+    commandName: string;
+    commandOptions?: CommandOptions;
+    autoCompletes?: AutoCompletes;
+    buttons?: Buttons;
+    modals?: Modals;
+    selectMenus?: SelectMenus;
+};
+type CommandOptions = {
+    [key: string]: string;
+};
+type AutoCompletes = {
+    [key: string]: string;
+};
+type Buttons = {
+    [key: string]: string;
+};
+type Modals = {
+    [key: string]: {
+        customId: string;
+        [key: string]: string;
+    };
+};
+type SelectMenus = {
+    [key: string]: string;
+};
+export {};

package/dist/typescript/types.js

@@ -0,0 +1,10 @@
+export var InteractionType;
+(function (InteractionType) {
+    InteractionType["Autocomplete"] = "Autocomplete";
+    InteractionType["Button"] = "Button";
+    InteractionType["ChatInputCommand"] = "ChatInputCommand";
+    InteractionType["ContextMenuCommand"] = "ContextMenuCommand";
+    InteractionType["ModalSubmit"] = "ModalSubmit";
+    InteractionType["SelectMenu"] = "SelectMenu";
+    InteractionType["Unknown"] = "Unknown";
+})(InteractionType || (InteractionType = {}));

package/dist/utils/ephemeralReponse.d.ts

@@ -0,0 +1,3 @@
+import { type BaseMessageOptions, type RepliableInteraction } from "discord.js";
+export declare const ephemeralFollowUpResponse: (interaction: RepliableInteraction, data: string | BaseMessageOptions, automaticDeletion?: boolean) => Promise<void>;
+export declare const ephemeralReplyResponse: (interaction: RepliableInteraction, data: BaseMessageOptions, automaticDeletion?: boolean) => Promise<void>;

package/dist/utils/ephemeralReponse.js

@@ -0,0 +1,38 @@
+export const ephemeralFollowUpResponse = async (interaction, data, automaticDeletion = false) => {
+    if (!interaction.deferred) {
+        await interaction.deferReply({ ephemeral: true });
+    }
+    if (typeof data === "string") {
+        await interaction.followUp({ content: data, ephemeral: true });
+    }
+    else {
+        await interaction.followUp({ ...data, ephemeral: true });
+    }
+    if (automaticDeletion) {
+        setTimeout(() => {
+            try {
+                interaction.deleteReply();
+            }
+            catch { }
+        }, 60 * 1000);
+    }
+};
+export const ephemeralReplyResponse = async (interaction, data, automaticDeletion = false) => {
+    if (!interaction.deferred) {
+        await interaction.deferReply({ ephemeral: true });
+    }
+    if (typeof data === "string") {
+        await interaction.reply({ content: data, ephemeral: true });
+    }
+    else {
+        await interaction.reply({ ...data, ephemeral: true });
+    }
+    if (automaticDeletion) {
+        setTimeout(() => {
+            try {
+                interaction.deleteReply();
+            }
+            catch { }
+        }, 60 * 1000);
+    }
+};

package/dist/utils/files.d.ts

@@ -0,0 +1,4 @@
+import { Collection } from "discord.js";
+import { type AnyInteractionStructure } from "../structures/index.js";
+import { type CustomId } from "../typescript/index.js";
+export declare const requiredFiles: <InteractionStructure extends AnyInteractionStructure>(directoryPath: string) => Promise<Collection<CustomId, InteractionStructure>>;

package/dist/utils/files.js

@@ -0,0 +1,35 @@
+import { Collection } from "discord.js";
+import { readdirSync, statSync } from "fs";
+import path from "path";
+export const requiredFiles = async (directoryPath) => {
+    const collection = new Collection();
+    const filesPath = getAllFilesPath(directoryPath).filter((file) => file.endsWith(".ts"));
+    for (const filePath of filesPath) {
+        const data = await loadInteraction(filePath);
+        collection.set(data.data.name, data);
+    }
+    return collection;
+};
+const loadInteraction = async (filePath) => {
+    try {
+        const module = await import(`file://${filePath}`);
+        const data = module.default;
+        return data;
+    }
+    catch (error) {
+        throw error;
+    }
+};
+const getAllFilesPath = (dirPath, arrayOfFiles = []) => {
+    const files = readdirSync(dirPath);
+    files.forEach((file) => {
+        if (statSync(dirPath + "/" + file).isDirectory()) {
+            arrayOfFiles = getAllFilesPath(dirPath + "/" + file, arrayOfFiles);
+        }
+        else {
+            const __dirname = path.resolve();
+            arrayOfFiles.push(path.join(__dirname, dirPath, "/", file));
+        }
+    });
+    return arrayOfFiles;
+};

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./ephemeralReponse.js";
+export * from "./files.js";

package/dist/utils/index.js

@@ -0,0 +1,2 @@
+export * from "./ephemeralReponse.js";
+export * from "./files.js";

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@stelliajs/framework",
+  "version": "1.0.0",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsc && tsc-alias"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/stelliajs/framework.git"
+  },
+  "author": "Tweenty_",
+  "license": "ISC",
+  "dependencies": {
+    "discord-api-types": "^0.37.92",
+    "discord.js": "^14.15.3"
+  },
+  "devDependencies": {
+    "ts-node": "^10.9.2",
+    "tsc-alias": "^1.8.10"
+  },
+  "type": "module"
+}