zumito-framework 1.1.76 → 1.1.77

package/dist/ZumitoFramework.d.ts

@@ -7,6 +7,7 @@ import { FrameworkSettings } from './types/FrameworkSettings.js';
 import { Module } from './types/Module.js';
 import { StatusManager } from './managers/StatusManager.js';
 import { TranslationManager } from './TranslationManager.js';
+import { EventManager } from './managers/EventManager.js';
 /**
  * @class ZumitoFramework
  * @description The main class of the framework.
@@ -99,6 +100,13 @@ export declare class ZumitoFramework {
      * @see {@link https://nodejs.org/api/events.html#events_class_eventemitter}
      */
     eventEmitter: EventEmitter;
+    /**
+     * Event manager for the framework.
+     * All events related to the framework and discord.js are handled here.
+     * @type {EventManager}
+     * @private
+     */
+    eventManager: EventManager;
     /**
      * @constructor
      * @param {FrameworkSettings} settings - The settings to use for the framework.

package/dist/ZumitoFramework.js

@@ -17,6 +17,7 @@ import cors from 'cors';
 import express from 'express';
 import http from 'http';
 import path from 'path';
+import { EventManager } from './managers/EventManager.js';
 // import better-logging
 betterLogging(console);
 /**
@@ -111,6 +112,13 @@ export class ZumitoFramework {
      * @see {@link https://nodejs.org/api/events.html#events_class_eventemitter}
      */
     eventEmitter = new EventEmitter();
+    /**
+     * Event manager for the framework.
+     * All events related to the framework and discord.js are handled here.
+     * @type {EventManager}
+     * @private
+     */
+    eventManager;
     /**
      * @constructor
      * @param {FrameworkSettings} settings - The settings to use for the framework.
@@ -123,6 +131,7 @@ export class ZumitoFramework {
         this.events = new Map();
         this.translations = new TranslationManager();
         this.models = [];
+        this.eventManager = new EventManager();
         if (settings.logLevel) {
             console.logLevel = settings.logLevel;
         }
@@ -145,8 +154,10 @@ export class ZumitoFramework {
      */
     async initialize() {
         await this.initializeDatabase();
-        this.initializeDiscordClient();
+        await this.initializeDiscordClient();
         this.startApiServer();
+        this.eventManager.addEventEmitter('discord', this.client);
+        this.eventManager.addEventEmitter('framework', this.eventEmitter);
         await this.registerModules();
         await this.refreshSlashCommands();
         if (this.settings.statusOptions) {
@@ -301,14 +312,17 @@ export class ZumitoFramework {
      * Logs in to the Discord API using the provided token and logs a message when the client is ready.
      * @private
      */
-    initializeDiscordClient() {
+    async initializeDiscordClient() {
         this.client = new Client({
             intents: this.settings.discordClientOptions.intents,
         });
         this.client.login(this.settings.discordClientOptions.token);
-        this.client.on('ready', () => {
-            // Bot emoji
-            console.log('[🤖🟢] Discord client ready');
+        await new Promise((resolve) => {
+            this.client.on('ready', () => {
+                // Bot emoji
+                console.log('[🤖🟢] Discord client ready');
+                resolve();
+            });
         });
     }
     /**

package/dist/baseModule/events/discord/InteractionCreate.d.ts

@@ -0,0 +1,8 @@
+import { Command } from '../../../types/Command.js';
+import { EventParameters } from '../../../types/EventParameters.js';
+import { FrameworkEvent } from '../../../types/FrameworkEvent.js';
+export declare class InteractionCreate extends FrameworkEvent {
+    once: boolean;
+    execute({ interaction, client, framework, }: EventParameters): Promise<void>;
+    getTransMethod(commandInstance: Command, framework: any, guildSettings: any): (key: string, params?: any) => any;
+}

package/dist/baseModule/events/discord/InteractionCreate.js

@@ -0,0 +1,128 @@
+import { CommandType } from '../../../types/CommandType.js';
+import { FrameworkEvent } from '../../../types/FrameworkEvent.js';
+export class InteractionCreate extends FrameworkEvent {
+    once = false;
+    async execute({ interaction, client, framework, }) {
+        let guildSettings;
+        if (interaction.guildId) {
+            guildSettings = await framework.getGuildSettings(interaction.guildId);
+        }
+        if (interaction.isCommand()) {
+            if (!framework.commands.has(interaction.commandName))
+                return;
+            const commandInstance = framework.commands.get(interaction.commandName);
+            const args = new Map();
+            commandInstance.args.forEach((arg) => {
+                const option = interaction.options.get(arg.name);
+                if (option) {
+                    switch (arg.type) {
+                        case 'user':
+                            args.set(arg.name, option.user);
+                            break;
+                        case 'member':
+                            args.set(arg.name, option.member);
+                            break;
+                        default:
+                            args.set(arg.name, option.value ||
+                                option.user ||
+                                option.role ||
+                                option.channel ||
+                                option.options ||
+                                option.message ||
+                                option.member ||
+                                option.focused ||
+                                option.autocomplete ||
+                                option.attachment);
+                            break;
+                    }
+                }
+            });
+            if (![CommandType.any, CommandType.separated, CommandType.slash,].includes(commandInstance.type))
+                return;
+            const trans = this.getTransMethod(commandInstance, framework, guildSettings);
+            if (commandInstance.type === CommandType.separated ||
+                commandInstance.type === CommandType.slash) {
+                await commandInstance.executeSlashCommand({
+                    client, interaction, args, framework, guildSettings, trans,
+                });
+            }
+            else {
+                await commandInstance.execute({
+                    client, interaction, args, framework, guildSettings, trans,
+                });
+            }
+        }
+        else if (interaction.isButton()) {
+            interaction = interaction;
+            const path = interaction.customId.split('.');
+            const commandInstance = framework.commands.get(path[0]);
+            if (!commandInstance)
+                throw new Error(`Command ${path[0]} not found or button id bad formatted`);
+            // If the command has impements ButtonPress class then execute the method
+            if (commandInstance.constructor.prototype.hasOwnProperty('buttonPressed')) {
+                commandInstance.buttonPressed({
+                    path,
+                    interaction,
+                    client,
+                    framework,
+                    guildSettings,
+                });
+            }
+        }
+        else if (interaction.isStringSelectMenu()) {
+            const path = interaction.customId.split('.');
+            const commandInstance = framework.commands.get(path[0]);
+            if (!commandInstance)
+                throw new Error(`Command ${path[0]} not found or select menu id bad formatted`);
+            const trans = (key, params) => {
+                if (key.startsWith('$')) {
+                    return framework.translations.get(key.replace('$', ''), guildSettings.lang, params);
+                }
+                else {
+                    return framework.translations.get('command.' + commandInstance.name + '.' + key, guildSettings.lang, params);
+                }
+            };
+            if (commandInstance.selectMenu) {
+                commandInstance.selectMenu({
+                    path,
+                    interaction,
+                    client,
+                    framework,
+                    guildSettings,
+                    trans,
+                });
+            }
+        }
+        else if (interaction.isModalSubmit()) {
+            const path = interaction.customId.split('.');
+            const commandInstance = framework.commands.get(path[0]);
+            if (!commandInstance) {
+                throw new Error(`Command ${path[0]} not found or modal id bad formatted`);
+            }
+            if (commandInstance.modalSubmit) {
+                commandInstance.modalSubmit({
+                    path,
+                    interaction,
+                    client,
+                    framework,
+                    guildSettings,
+                });
+            }
+            else {
+                framework.eventManager.emitEvent('modalSubmit', 'framework', {
+                    path, interaction, client, framework, guildSettings,
+                });
+            }
+        }
+    }
+    getTransMethod(commandInstance, framework, guildSettings) {
+        return (key, params) => {
+            if (key.startsWith('$')) {
+                return framework.translations.get(key.replace('$', ''), guildSettings.lang, params);
+            }
+            else {
+                return framework.translations.get('command.' + commandInstance.name + '.' + key, guildSettings.lang, params);
+            }
+        };
+    }
+}

package/dist/baseModule/events/discord/MessageCreate.d.ts

@@ -0,0 +1,16 @@
+import { ActionRowBuilder, EmbedBuilder } from 'discord.js';
+import { EventParameters } from '../../../types/EventParameters.js';
+import { FrameworkEvent } from '../../../types/FrameworkEvent.js';
+export declare class MessageCreate extends FrameworkEvent {
+    once: boolean;
+    execute({ message, framework }: EventParameters): Promise<import("discord.js").Message<boolean>>;
+    autocorrect(str: string, words: string[]): any;
+    getErrorEmbed(error: any, parse: any): {
+        embeds: EmbedBuilder[];
+        components: ActionRowBuilder<import("@discordjs/builders").AnyComponentBuilder>[];
+        allowedMentions: {
+            repliedUser: boolean;
+        };
+    };
+    parseError(error: any): any;
+}

package/dist/baseModule/events/discord/MessageCreate.js

@@ -0,0 +1,269 @@
+import { ActionRowBuilder, ButtonBuilder, ButtonStyle, ChannelType, EmbedBuilder, PermissionsBitField, } from 'discord.js';
+import ErrorStackParser from 'error-stack-parser';
+import { FrameworkEvent } from '../../../types/FrameworkEvent.js';
+import { ZumitoFramework } from '../../../ZumitoFramework.js';
+import leven from 'leven';
+import path from 'path';
+import { InteractionIdGenerator } from '../../../utils/InteractionIdGenerator.js';
+export class MessageCreate extends FrameworkEvent {
+    once = false;
+    async execute({ message, framework }) {
+        const channel = message.channel;
+        const prefix = framework.settings.defaultPrefix;
+        const args = ZumitoFramework.splitCommandLine(message.content.slice(prefix.length));
+        const command = args.shift().toLowerCase();
+        let commandInstance;
+        if (message.content.startsWith(prefix)) {
+            if (!framework.commands.has(command)) {
+                const commandNames = Array.from(framework.commands.keys());
+                const correctedCommand = this.autocorrect(command, commandNames);
+                if (framework.commands.has(correctedCommand)) {
+                    commandInstance = framework.commands.get(correctedCommand);
+                }
+                else {
+                    return; // Command not found
+                }
+            }
+            else {
+                commandInstance = framework.commands.get(command);
+            }
+            if (message.guild == null && commandInstance.dm == false)
+                return;
+            if (commandInstance.adminOnly ||
+                commandInstance.userPermissions.length > 0) {
+                let denied = false;
+                if (framework.memberHasPermission(message.member, message.channel, PermissionsBitField.Flags.Administrator) ||
+                    message.member.id != message.guild.ownerId) {
+                    if (commandInstance.userPermissions.length > 0) {
+                        commandInstance.userPermissions.forEach((permission) => {
+                            if (!framework.memberHasPermission(message.member, message.channel, permission)) {
+                                denied = true;
+                            }
+                        });
+                    }
+                }
+                if (denied) {
+                    return message.reply({
+                        content: 'You do not have permission to use this command.',
+                        allowedMentions: {
+                            repliedUser: false,
+                        },
+                    });
+                }
+            }
+            if (message.channel.isTextBased) {
+                const channel = message.channel;
+                // Check command is nsfw and if channel is allowed
+                if (commandInstance.nsfw &&
+                    !channel.nsfw &&
+                    !channel
+                        .permissionsFor(message.member)
+                        .has(PermissionsBitField.Flags.Administrator) &&
+                    message.member.id != message.guild.ownerId) {
+                    return message.reply({
+                        content: 'This command is nsfw and this channel is not nsfw.',
+                        allowedMentions: {
+                            repliedUser: false,
+                        },
+                    });
+                }
+            }
+            try {
+                const guildSettings = await framework.getGuildSettings(message.guildId);
+                const parsedArgs = new Map();
+                for (let i = 0; i < args.length; i++) {
+                    const arg = args[i];
+                    const type = commandInstance.args[i]?.type;
+                    if (type) {
+                        if (type == 'member' || type == 'user') {
+                            const member = await message.guild.members.cache.get(arg.replace(/[<@!>]/g, ''));
+                            if (member) {
+                                if (type == 'user') {
+                                    parsedArgs.set(commandInstance.args[i].name, member.user);
+                                }
+                                else {
+                                    parsedArgs.set(commandInstance.args[i].name, member);
+                                }
+                            }
+                            else {
+                                return message.reply({
+                                    content: 'Invalid user.',
+                                    allowedMentions: {
+                                        repliedUser: false,
+                                    },
+                                });
+                            }
+                        }
+                        else if (type == 'string') {
+                            parsedArgs.set(commandInstance.args?.[i]?.name || i.toString(), arg);
+                        }
+                    }
+                }
+                const interactionIdGenerator = new InteractionIdGenerator(undefined, commandInstance.name);
+                await commandInstance.execute({
+                    message,
+                    args: parsedArgs,
+                    client: framework.client,
+                    framework: framework,
+                    guildSettings: guildSettings,
+                    trans: (key, params) => {
+                        if (key.startsWith('$')) {
+                            return framework.translations.get(key.replace('$', ''), guildSettings.lang, params);
+                        }
+                        else {
+                            return framework.translations.get('command.' + commandInstance.name + '.' + key, guildSettings.lang, params);
+                        }
+                    },
+                });
+                if (!message.channel.isDMBased && !message.deletable) {
+                    return; // TODO: test if this works
+                    // false = settings.deleteCommands
+                    try {
+                        message.delete().catch(function () {
+                            console.error("can't delete user command");
+                        });
+                    }
+                    catch (err) {
+                        console.error(err.name, err.message);
+                    }
+                }
+            }
+            catch (error) {
+                const content = await this.getErrorEmbed({
+                    name: error.name,
+                    message: error.message,
+                    command: commandInstance,
+                    args: args,
+                    stack: error.stack,
+                }, true);
+                try {
+                    message.reply(content);
+                }
+                catch (e) {
+                    if (channel.type !== ChannelType.GuildStageVoice) {
+                        channel.send(content);
+                    }
+                }
+            }
+        }
+    }
+    autocorrect(str, words) {
+        let distance, bestWord, i, word, min;
+        const dictionary = words || [];
+        const len = dictionary.length;
+        for (i = 0; i < len; i++) {
+            word = dictionary[i];
+            distance = leven(str, word);
+            if (distance === 0) {
+                return word;
+            }
+            else if (min === undefined || distance < min) {
+                min = distance;
+                bestWord = word;
+            }
+        }
+        return bestWord;
+    }
+    getErrorEmbed(error, parse) {
+        let parsedError;
+        if (parse) {
+            parsedError = this.parseError(error);
+        }
+        else {
+            parsedError = error;
+        }
+        const embed = new EmbedBuilder()
+            .setTitle('Error')
+            .setDescription('An error has occured while executing this command.')
+            .setTimestamp()
+            .addFields([
+            {
+                name: 'Command:',
+                value: error.command.name || 'Not defined',
+            },
+        ])
+            .addFields([
+            {
+                name: 'Arguments:',
+                value: error.args.toString() || 'None',
+            },
+        ])
+            .addFields([
+            {
+                name: 'Error name:',
+                value: error.name || 'Not defined',
+            },
+        ])
+            .addFields([
+            {
+                name: 'Error message:',
+                value: error.message || 'Not defined',
+            },
+        ]);
+        if (error.possibleSolutions !== undefined) {
+            error.possibleSolutions.forEach((solution) => {
+                embed.addFields([
+                    {
+                        name: 'Posible solution:',
+                        value: solution,
+                    },
+                ]);
+            });
+        }
+        const stackFrames = ErrorStackParser.parse(error).filter((e) => !e.fileName.includes('node_modules') &&
+            !e.fileName.includes('node:internal'));
+        let stack = '';
+        const path1 = path.resolve('./');
+        const path2 = path1.replaceAll('\\', '/');
+        stackFrames.forEach((frame) => {
+            stack += `[${frame.fileName
+                .replace(path1, '')
+                .replace(path2, '')
+                .replace('file://', '')}:${frame.lineNumber}](https://zumito.ga/redirect?url=vscode://file/${frame.fileName.replace('file://', '')}:${frame.lineNumber}) ${frame.functionName}()\n`;
+        });
+        if (error.stack !== undefined) {
+            embed.addFields([
+                {
+                    name: 'Call stack:',
+                    value: stack || error.stack || error.stack.toString(),
+                },
+            ]);
+        }
+        if (error.details !== undefined) {
+            error.details.forEach((detail) => {
+                embed.addFields([
+                    {
+                        name: 'Detail:',
+                        value: detail,
+                    },
+                ]);
+            });
+        }
+        const body = `\n\n\n---\nComand:\`\`\`${error.command.name || 'not defined'}\`\`\`\nArguments:\`\`\`${error.args.toString() || 'none'}\`\`\`\nError:\`\`\`${error.name || 'not defined'}\`\`\`\nError message:\`\`\`${error.message || 'not defined'}\`\`\`\n`;
+        const requestUrl = `https://github.com/ZumitoTeam/Zumito/issues/new?body=${encodeURIComponent(body)}`;
+        const row = new ActionRowBuilder().addComponents(new ButtonBuilder()
+            .setStyle(ButtonStyle.Link)
+            .setLabel('Report error')
+            .setEmoji('975645505302437978')
+            .setURL(requestUrl));
+        return {
+            embeds: [embed],
+            components: [row],
+            allowedMentions: {
+                repliedUser: false,
+            },
+        };
+    }
+    parseError(error) {
+        error.possibleSolutions = [];
+        if (/(?:^|(?<= ))(EmbedBuilder|Discord|ActionRowBuilder|ButtonBuilder|MessageSelectMenu)(?:(?= )|$) is not defined/gm.test(error.message)) {
+            error.possibleSolutions.push('const { ' +
+                error.message.split(' ')[0] +
+                " } = require('discord.js');");
+        }
+        else if (error.message.includes('A custom id and url cannot both be specified')) {
+            error.possibleSolutions.push('Remove .setCustomId(...) or .setURL(...)');
+        }
+        return error;
+    }
+}

package/dist/baseModule/index.js

@@ -1,6 +1,7 @@
+/* eslint-disable check-file/filename-naming-convention */
 import { Module } from '../types/Module.js';
-import { InteractionCreate } from './events/discord/interactionCreate.js';
-import { MessageCreate } from './events/discord/messageCreate.js';
+import { InteractionCreate } from './events/discord/InteractionCreate.js';
+import { MessageCreate } from './events/discord/MessageCreate.js';
 import { Guild } from './models/Guild.js';
 export class baseModule extends Module {
     constructor(modulePath, framework) {
@@ -10,7 +11,7 @@ export class baseModule extends Module {
         this.events.set('interactionCreate', new InteractionCreate());
         this.events.set('messageCreate', new MessageCreate());
         this.events.forEach((event) => {
-            this.registerDiscordEvent(event);
+            this.registerEvent(event, 'discord');
         });
     }
     async registerModels() {

package/dist/managers/EventManager.d.ts

@@ -0,0 +1,8 @@
+export declare class EventManager {
+    eventEmitters: Map<string, any>;
+    addEventEmitter(name: string, eventEmitter: any): void;
+    getEventEmitter(name: string): any;
+    removeEventEmitter(name: string): void;
+    emitEvent(eventName: string, eventEmitterName: string, ...args: any): void;
+    addEventListener(eventEmitterName: string, eventName: string, callback: any, params?: any): void;
+}

package/dist/managers/EventManager.js

@@ -0,0 +1,27 @@
+export class EventManager {
+    eventEmitters = new Map();
+    addEventEmitter(name, eventEmitter) {
+        this.eventEmitters.set(name, eventEmitter);
+    }
+    getEventEmitter(name) {
+        return this.eventEmitters.get(name);
+    }
+    removeEventEmitter(name) {
+        this.eventEmitters.delete(name);
+    }
+    emitEvent(eventName, eventEmitterName, ...args) {
+        const eventEmitter = this.getEventEmitter(eventEmitterName);
+        if (!eventEmitter)
+            throw new Error(`EventEmitter ${eventEmitterName} not found`);
+        eventEmitter.emit(eventName, ...args);
+    }
+    addEventListener(eventEmitterName, eventName, callback, params) {
+        const eventEmitter = this.getEventEmitter(eventEmitterName);
+        if (!eventEmitter)
+            throw new Error(`EventEmitter ${eventEmitterName} not found`);
+        const method = params?.once ? 'once' : 'on';
+        eventEmitter[method](eventName, (...args) => {
+            callback(...args);
+        });
+    }
+}

package/dist/types/Module.d.ts

@@ -16,7 +16,8 @@ export declare abstract class Module {
     onErrorLoadingCommand(error: Error): void;
     getCommands(): Map<string, Command>;
     registerEvents(): Promise<void>;
-    registerDiscordEvent(frameworkEvent: FrameworkEvent): void;
+    registerEventsFolder(folder: string): Promise<void>;
+    registerEvent(frameworkEvent: FrameworkEvent, emitterName: string): void;
     parseEventArgs(args: any[]): any;
     getEvents(): Map<string, FrameworkEvent>;
     registerTranslations(subpath?: string): Promise<void>;

package/dist/types/Module.js

@@ -3,7 +3,7 @@ import chalk from 'chalk';
 import boxen from 'boxen';
 import * as fs from 'fs';
 import path from 'path';
-import { ButtonInteraction, CommandInteraction, StringSelectMenuInteraction, } from 'discord.js';
+import { ButtonInteraction, CommandInteraction, ModalSubmitInteraction, StringSelectMenuInteraction, } from 'discord.js';
 export class Module {
     path;
     framework;
@@ -90,42 +90,40 @@ export class Module {
             return;
         const files = fs.readdirSync(path.join(this.path, 'events'));
         for (const file of files) {
-            if (file == 'discord') {
-                const moduleFileNames = fs.readdirSync(path.join(this.path, 'events', 'discord'));
-                for (const moduleFileName of moduleFileNames) {
-                    if (moduleFileName.endsWith('.js') ||
-                        moduleFileName.endsWith('.ts')) {
-                        let event = await import('file://' +
-                            path.join(this.path, 'events', 'discord', moduleFileName)).catch((e) => {
-                            console.error(`[🔄🔴 ] Error loading ${moduleFileName.slice(0, -3)} event on module ${this.constructor.name}`);
-                            console.log(boxen(e + '\n' + e.name + '\n' + e.stack, {
-                                padding: 1,
-                            }));
-                        });
-                        event = Object.values(event)[0];
-                        event = new event();
-                        this.events.set(event.constructor.name.toLowerCase(), event);
-                        this.registerDiscordEvent(event);
-                    }
-                }
+            // if file is folder
+            if (fs.lstatSync(path.join(this.path, 'events', file)).isDirectory()) {
+                console.log('registering events folder ' + file);
+                this.registerEventsFolder(file);
+            }
+        }
+    }
+    async registerEventsFolder(folder) {
+        const folderPath = path.join(this.path, 'events', folder);
+        if (!fs.existsSync(folderPath))
+            throw new Error(`Folder ${folder} doesn't exist`);
+        const files = fs.readdirSync(folderPath);
+        for (const file of files) {
+            if (file.endsWith('.js') || file.endsWith('.ts')) {
+                let event = await import('file://' + path.join(folderPath, file)).catch((e) => {
+                    console.error(`[🔄🔴 ] Error loading ${file.slice(0, -3)} event on module ${this.constructor.name}`);
+                });
+                event = Object.values(event)[0];
+                event = new event();
+                this.events.set(event.constructor.name.toLowerCase(), event);
+                this.registerEvent(event, folder);
             }
         }
     }
-    registerDiscordEvent(frameworkEvent) {
+    registerEvent(frameworkEvent, emitterName) {
         if (frameworkEvent.disabled)
             return;
+        const once = frameworkEvent.once;
         const eventName = frameworkEvent.constructor.name.charAt(0).toLowerCase() +
             frameworkEvent.constructor.name.slice(1);
-        const emitter = this.framework.client;
-        const once = frameworkEvent.once; // A simple variable which returns if the event should run once
-        // Try catch block to throw an error if the code in try{} doesn't work
-        try {
-            emitter[once ? 'once' : 'on'](eventName, (...args) => frameworkEvent.execute(this.parseEventArgs(args))); // Run the event using the above defined emitter (client)
-        }
-        catch (error) {
-            console.log(error, error.message, error, name);
-            console.error(error.stack); // If there is an error, console log the error stack message
-        }
+        this.framework.eventManager.addEventListener(emitterName, eventName, (...args) => {
+            const finalArgs = this.parseEventArgs(args);
+            frameworkEvent.execute(finalArgs);
+        }, { once });
     }
     parseEventArgs(args) {
         const finalArgs = {
@@ -137,7 +135,8 @@ export class Module {
         });
         const interaction = args.find((arg) => arg instanceof StringSelectMenuInteraction ||
             arg instanceof CommandInteraction ||
-            arg instanceof ButtonInteraction);
+            arg instanceof ButtonInteraction ||
+            arg instanceof ModalSubmitInteraction);
         if (interaction) {
             finalArgs['interaction'] = interaction;
         }

package/dist/utils/InteractionIdGenerator.d.ts

@@ -0,0 +1,13 @@
+export interface SelectMenuIdParams {
+    id: string;
+    params?: string[];
+}
+export declare class InteractionIdGenerator {
+    module: string;
+    command: string;
+    constructor(module?: string, command?: string);
+    protected generatePrefix(): string;
+    generateSelectMenuId(id: string, params?: string[]): string;
+    generateButtonId(id: string, params?: string[]): string;
+    generateModalId(id: string, params?: string[]): string;
+}

package/dist/utils/InteractionIdGenerator.js

@@ -0,0 +1,40 @@
+export class InteractionIdGenerator {
+    module;
+    command;
+    constructor(module, command) {
+        this.module = module;
+        this.command = command;
+    }
+    generatePrefix() {
+        const components = [];
+        if (this.module)
+            components.push(this.module);
+        if (this.command)
+            components.push(this.command);
+        return components.join('.');
+    }
+    generateSelectMenuId(id, params) {
+        let components = [this.generatePrefix()];
+        if (id)
+            components.push(id);
+        if (params)
+            components = components.concat(params);
+        return components.join('.');
+    }
+    generateButtonId(id, params) {
+        let components = [this.generatePrefix()];
+        if (id)
+            components.push(id);
+        if (params)
+            components = components.concat(params);
+        return components.join('.');
+    }
+    generateModalId(id, params) {
+        let components = [this.generatePrefix()];
+        if (id)
+            components.push(id);
+        if (params)
+            components = components.concat(params);
+        return components.join('.');
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zumito-framework",
-  "version": "1.1.76",
+  "version": "1.1.77",
   "description": "Discord.js bot framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",