zumito-framework 1.1.33 → 1.1.35

package/dist/TranslationManager.js

@@ -4,7 +4,12 @@ export class TranslationManager {
     defaultLanguage = 'en';
     constructor() { }
     get(key, language, params) {
-        return this.translations.get(key).get(language, params);
+        if (this.translations.has(key)) {
+            return this.translations.get(key).get(language, params);
+        }
+        else {
+            return key;
+        }
     }
     set(key, language, text) {
         if (!this.translations.has(key)) {

package/dist/ZumitoFramework.d.ts

@@ -46,4 +46,5 @@ export declare class ZumitoFramework {
     private initializeDiscordClient;
     static splitCommandLine(commandLine: any): any;
     memberHasPermission(member: GuildMember, channel: TextChannel, permission: bigint): Promise<boolean>;
+    getGuildSettings(guildId: string): Promise<any>;
 }

package/dist/ZumitoFramework.js

@@ -13,6 +13,7 @@ import mongoose from "mongoose";
 import cookieParser from 'cookie-parser';
 import cors from 'cors';
 import http from 'http';
+import * as url from 'url';
 /**
  * @class ZumitoFramework
  * @classdesc The main class of the framework.
@@ -28,7 +29,7 @@ export class ZumitoFramework {
     modules;
     commands;
     events;
-    translations = new TranslationManager();
+    translations;
     routes;
     models;
     database;
@@ -54,9 +55,12 @@ export class ZumitoFramework {
         this.events = new Map();
         this.translations = new TranslationManager();
         this.models = new Map();
+        if (settings.logLevel) {
+            console.logLevel = settings.logLevel;
+        }
         this.initialize().then(() => {
             if (callback)
-                callback();
+                callback(this);
         }).catch(err => {
             console.error(err, err.message, err.stack, err.name);
         });
@@ -75,7 +79,7 @@ export class ZumitoFramework {
         }
         this.initializeDiscordClient();
         this.startApiServer();
-        this.registerModules();
+        await this.registerModules();
     }
     startApiServer() {
         this.app = express();
@@ -108,7 +112,7 @@ export class ZumitoFramework {
             }
         });
     }
-    registerModules() {
+    async registerModules() {
         let modulesFolder;
         if (fs.existsSync(`${process.cwd()}/modules`)) {
             modulesFolder = `${process.cwd()}/modules`;
@@ -118,10 +122,12 @@ export class ZumitoFramework {
         }
         else
             return;
-        this.registerModule(path.resolve(), 'baseModule', baseModule);
-        fs.readdirSync(modulesFolder).forEach(file => {
-            this.registerModule(modulesFolder, file);
-        });
+        const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
+        await this.registerModule(__dirname, 'baseModule', baseModule);
+        let files = fs.readdirSync(modulesFolder);
+        for (let file of files) {
+            await this.registerModule(modulesFolder, file);
+        }
         this.models.forEach((modelDefiniton, modelName) => {
             const schema = new mongoose.Schema(modelDefiniton);
             this.models.set(modelName, mongoose.model(modelName, schema));
@@ -147,12 +153,18 @@ export class ZumitoFramework {
         try {
             moduleInstance = new module(path.join(modulesFolder, moduleName), this);
             await moduleInstance.initialize();
-            this.modules.set(moduleInstance.constructor.name, moduleInstance);
+            this.modules.set(moduleName || moduleInstance.constructor.name, moduleInstance);
         }
         catch (err) {
             console.error(`[📦🔴] Error loading module ${moduleName}: ${err.message}`);
+            console.error(err.stack);
         }
         // Register module commands
+        if (moduleInstance.getCommands()) {
+            moduleInstance.getCommands().forEach((command) => {
+                this.commands.set(command.name, command);
+            });
+        }
         this.commands = new Map([...this.commands, ...moduleInstance.getCommands()]);
         // Register module events
         this.events = new Map([...this.events, ...moduleInstance.getEvents()]);
@@ -210,6 +222,13 @@ export class ZumitoFramework {
         let memberPermission = await channel.permissionsFor(member);
         return memberPermission.has(permission);
     }
+    async getGuildSettings(guildId) {
+        let guild = await this.models.get('Guild').findOne({ guild_id: guildId });
+        if (guild == null) {
+            guild = await this.models.get('Guild').create({ guild_id: guildId });
+        }
+        return guild;
+    }
 }
 function MergeRecursive(obj1, obj2) {
     for (var p in obj2) {

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

@@ -3,6 +3,10 @@ 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;
@@ -17,10 +21,10 @@ export class InteractionCreate extends FrameworkEvent {
             if (![CommandType.any, CommandType.separated, CommandType.slash].includes(commandInstance.type))
                 return;
             if (commandInstance.type === CommandType.separated || commandInstance.type === CommandType.slash) {
-                await commandInstance.executeSlashCommand({ client, interaction, args, framework });
+                await commandInstance.executeSlashCommand({ client, interaction, args, framework, guildSettings });
             }
             else {
-                await commandInstance.execute({ client, interaction, args, framework });
+                await commandInstance.execute({ client, interaction, args, framework, guildSettings });
             }
         }
         else if (interaction.isButton()) {
@@ -29,7 +33,7 @@ export class InteractionCreate extends FrameworkEvent {
             let path = interaction.customId.split('.');
             const command = framework.commands.get(path[0]);
             if (command.selectMenu) {
-                command.selectMenu({ path, interaction, client, framework });
+                command.selectMenu({ path, interaction, client, framework, guildSettings });
             }
         }
     }

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

@@ -1,6 +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, client, framework }: EventParameters): Promise<import("discord.js").Message<boolean>>;
+    autocorrect(str: string, words: string[]): any;
+    getErrorEmbed(error: any, parse: any): {
+        embeds: EmbedBuilder[];
+        components: ActionRowBuilder<import("discord.js").AnyComponentBuilder>[];
+        allowedMentions: {
+            repliedUser: boolean;
+        };
+    };
+    parseError(error: any): any;
 }

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

@@ -1,6 +1,10 @@
-import { PermissionsBitField } from "discord.js";
+import { ActionRowBuilder, ButtonBuilder, ButtonStyle, EmbedBuilder, PermissionsBitField } from "discord.js";
 import { FrameworkEvent } from "../../../types/FrameworkEvent.js";
 import { ZumitoFramework } from "../../../ZumitoFramework.js";
+import leven from 'leven';
+import ErrorStackParser from 'error-stack-parser';
+import * as url from 'url';
+import path from "path";
 export class MessageCreate extends FrameworkEvent {
     once = false;
     async execute({ message, client, framework }) {
@@ -12,9 +16,7 @@ export class MessageCreate extends FrameworkEvent {
         if (message.content.startsWith(prefix)) {
             if (!framework.commands.has(command)) {
                 let commandNames = Array.from(framework.commands.keys());
-                var autocorrect = await import('autocorrect');
-                autocorrect = autocorrect({ words: commandNames });
-                var correctedCommand = autocorrect(command);
+                var correctedCommand = this.autocorrect(command, commandNames);
                 if (framework.commands.has(correctedCommand)) {
                     commandInstance = framework.commands.get(correctedCommand);
                 }
@@ -27,11 +29,11 @@ export class MessageCreate extends FrameworkEvent {
             }
             if (message.guild == null && commandInstance.dm == false)
                 return;
-            if (commandInstance.adminOnly || commandInstance.permissions.length > 0) {
+            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.permissions.length > 0) {
-                        commandInstance.permissions.forEach(permission => {
+                    if (commandInstance.userPermissions.length > 0) {
+                        commandInstance.userPermissions.forEach(permission => {
                             if (!framework.memberHasPermission(message.member, message.channel, permission)) {
                                 denied = true;
                             }
@@ -60,18 +62,17 @@ export class MessageCreate extends FrameworkEvent {
                 }
             }
             try {
+                let guildSettings = await framework.getGuildSettings(message.guildId);
                 let parsedArgs = new Map();
                 args.forEach(function (arg, index) {
-                    parsedArgs.set(commandInstance.args?.[index]?.name || index, {
-                        name: commandInstance.args?.[index]?.name || index,
-                        value: arg
-                    });
+                    parsedArgs.set(commandInstance.args?.[index]?.name || index, arg);
                 });
                 await commandInstance.execute({
                     message,
                     args: parsedArgs,
                     client: framework.client,
                     framework: framework,
+                    guildSettings: guildSettings,
                 });
                 if (!message.channel.isDMBased && !message.deletable && (false)) { // false = settings.deleteCommands
                     try {
@@ -86,19 +87,121 @@ export class MessageCreate extends FrameworkEvent {
                 }
             }
             catch (error) {
-                // let content = await getErrorEmbed({
-                //     name: error.name,
-                //     message: error.message,
-                //     comid: com,
-                //     args: args,
-                //     stack: error.stack,
-                // }, true);
-                // try {
-                //     message.reply(content);
-                // } catch (e) {
-                //     channel.send(content);
-                // }
+                let content = await this.getErrorEmbed({
+                    name: error.name,
+                    message: error.message,
+                    command: commandInstance,
+                    args: args,
+                    stack: error.stack,
+                }, true);
+                try {
+                    message.reply(content);
+                }
+                catch (e) {
+                    channel.send(content);
+                }
             }
         }
     }
+    autocorrect(str, words) {
+        var distance, bestWord, i, word, min;
+        var dictionary = words || [];
+        var 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;
+        }
+        let 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
+                    }]);
+            });
+        }
+        let stackFrames = ErrorStackParser.parse(error).filter(e => !e.fileName.includes('node_modules') && !e.fileName.includes('node:internal'));
+        let stack = '';
+        const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
+        let path1 = path.resolve('./');
+        let 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/fernandomema/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.d.ts

@@ -2,5 +2,5 @@ import { Module } from "../types/Module.js";
 import { ZumitoFramework } from "../ZumitoFramework.js";
 export declare class baseModule extends Module {
     constructor(modulePath: string, framework: ZumitoFramework);
-    asyncregisterEvents(): any;
+    registerEvents(): Promise<any>;
 }

package/dist/baseModule/index.js

@@ -5,7 +5,7 @@ export class baseModule extends Module {
     constructor(modulePath, framework) {
         super(modulePath, framework);
     }
-    asyncregisterEvents() {
+    async registerEvents() {
         this.events.set('interactionCreate', new InteractionCreate());
         this.events.set('messageCreate', new MessageCreate());
         this.events.forEach(event => {

package/dist/baseModule/models/errors.json

@@ -0,0 +1,14 @@
+{
+    "id": "string",
+    "command": {
+        "command": "string",
+        "args": {
+            "type": "array"
+        }
+    },
+    "error": {
+        "title": "string",
+        "message": "string",
+        "stacktrace": "string"
+    }
+}

package/dist/baseModule/models/guild.json

@@ -0,0 +1,23 @@
+{
+    "guild_id": {
+        "type": "string",
+        "index": true,
+        "unique": true
+    },
+    "lang": {
+        "type": "string",
+        "default": "en"
+    },
+    "prefix": {
+        "type": "string",
+        "default": "z-"
+    },
+    "public": {
+        "type": "boolean",
+        "default": false
+    },
+    "deleteCommands": {
+        "type": "boolean",
+        "default": false
+    }
+}

package/dist/types/Command.d.ts

@@ -3,15 +3,15 @@ import { SelectMenuParameters } from "./SelectMenuParameters.js";
 export declare abstract class Command {
     name: string;
     categories: string[];
-    aliases?: string[];
-    examples?: string[];
-    permissions?: bigint[];
-    botPermissions?: string[];
-    hidden?: boolean;
-    adminOnly?: boolean;
-    nsfw?: boolean;
-    cooldown?: number;
-    slashCommand?: boolean;
+    aliases: string[];
+    examples: string[];
+    userPermissions: bigint[];
+    botPermissions: string[];
+    hidden: boolean;
+    adminOnly: boolean;
+    nsfw: boolean;
+    cooldown: number;
+    slashCommand: boolean;
     dm: boolean;
     args: CommandArgDefinition[];
     type: string;
@@ -19,5 +19,5 @@ export declare abstract class Command {
     abstract execute({ message, interaction, args, client, framework }: CommandParameters): void;
     executePrefixCommand({ message, interaction, args, client, framework }: CommandParameters): void;
     executeSlashCommand({ message, interaction, args, client, framework }: CommandParameters): void;
-    selectMenu({ path, interaction, client, framework }: SelectMenuParameters): void;
+    abstract selectMenu({ path, interaction, client, framework }: SelectMenuParameters): void;
 }

package/dist/types/Command.js

@@ -4,7 +4,7 @@ export class Command {
     categories = [];
     aliases = [];
     examples = [];
-    permissions = [];
+    userPermissions = [];
     botPermissions = [];
     hidden = false;
     adminOnly = false;
@@ -22,5 +22,4 @@ export class Command {
     executeSlashCommand({ message, interaction, args, client, framework }) {
         this.execute({ message, interaction, args, client, framework });
     }
-    selectMenu({ path, interaction, client, framework }) { }
 }

package/dist/types/CommandParameters.d.ts

@@ -14,4 +14,5 @@ export interface CommandParameters {
     args: Map<String, any>;
     client: Client;
     framework: ZumitoFramework;
+    guildSettings?: any;
 }

package/dist/types/Commands.js

@@ -1,4 +1,4 @@
-import { CommandType } from "./CommandType";
+import { CommandType } from "./CommandType.js";
 export class Command {
     name = this.constructor.name.toLowerCase();
     categories = [];

package/dist/types/Module.d.ts

@@ -10,8 +10,8 @@ export declare abstract class Module {
     constructor(path: any, framework: any);
     initialize(): Promise<void>;
     registerCommands(): Promise<void>;
-    onCommandCreated(filePath: string): void;
-    onCommandChanged(filePath: string): void;
+    onCommandCreated(filePath: string): Promise<void>;
+    onCommandChanged(filePath: string): Promise<void>;
     onErrorLoadingCommand(error: Error): void;
     getCommands(): Map<string, Command>;
     registerEvents(): Promise<void>;

package/dist/types/Module.js

@@ -1,7 +1,9 @@
 import * as chokidar from 'chokidar';
+import chalk from 'chalk';
 import boxen from "boxen";
 import * as fs from 'fs';
 import path from 'path';
+import { SelectMenuInteraction } from "discord.js";
 export class Module {
     path;
     framework;
@@ -16,41 +18,63 @@ export class Module {
         await this.registerCommands();
         await this.registerEvents();
         await this.registerTranslations();
+        await this.registerModels();
+        // console.error('[🔄🔴 ] Error initializing module ' + this.constructor.name);
+        // console.log(boxen(e + '\n' + e.stack, { padding: 1 }));
     }
     async registerCommands() {
-        if (!fs.existsSync(path.join(this.path, 'commands')))
-            return;
-        let files = fs.readdirSync(path.join(this.path, 'commands'));
-        for (let file of files) {
-            if (file.endsWith('.js') || file.endsWith('.ts')) {
-                let command = await import('file://' + path.join(this.path, 'commands', file));
-                command = Object.values(command)[0];
-                command = new command();
-                this.commands.set(command.constructor.name.toLowerCase(), command);
+        if (fs.existsSync(path.join(this.path, 'commands'))) {
+            let files = fs.readdirSync(path.join(this.path, 'commands'));
+            for (let file of files) {
+                if (file.endsWith('.js') || file.endsWith('.ts')) {
+                    let command = await import('file://' + path.join(this.path, 'commands', file)).catch(e => {
+                        console.error(`[🔄🔴 ] Error loading ${file.slice(0, -3)} command on module ${this.constructor.name}`);
+                        console.error(e + '\n' + e.name + '\n' + e.stack);
+                    });
+                    command = Object.values(command)[0];
+                    command = new command();
+                    this.commands.set(command.constructor.name.toLowerCase(), command);
+                }
+            }
+            ;
+            // register watcher
+            if (process.env.DEBUG) {
+                /*
+                    Debug only cause in prod environment commands should't be changed.
+                    Appart from that, esm module cache invalidation is not working properly
+                    and can cause memory leaks and crashes.
+                */
+                chokidar.watch(path.resolve(path.join(this.path, 'commands')), { ignored: /^\./, persistent: true, ignoreInitial: true })
+                    .on('add', this.onCommandCreated.bind(this))
+                    .on('change', this.onCommandChanged.bind(this))
+                    //.on('unlink', function(path) {console.log('File', path, 'has been removed');})
+                    .on('error', this.onErrorLoadingCommand.bind(this));
             }
-        }
-        ;
-        // register watcher
-        if (process.env.DEBUG) {
-            chokidar.watch(path.resolve(path.join(this.path, 'commands')), { ignored: /^\./, persistent: true, ignoreInitial: true })
-                .on('add', this.onCommandCreated.bind(this))
-                .on('change', this.onCommandChanged.bind(this))
-                //.on('unlink', function(path) {console.log('File', path, 'has been removed');})
-                .on('error', this.onErrorLoadingCommand.bind(this));
         }
     }
-    onCommandCreated(filePath) {
-        console.log(filePath);
-        // GRreen dot emoji
-        // try {
-        //     delete require.cache[path.resolve(path.join(this.path, 'commands', path))];
-        //     console.debug('[🔄🟢 ] Command ' + chalk.blue(path.replace(/^.*[\\\/]/, '').split('.').slice(0, -1).join('.')) + ' reloaded');
-        // } catch(e) {
-        //     console.error('[🔄🔴 ] Error reloading command ' + chalk.blue(path.replace(/^.*[\\\/]/, '').split('.').slice(0, -1).join('.')));
-        //     console.log(boxen(e + '\n' + e.stack, { padding: 1 }));
-        // }
+    async onCommandCreated(filePath) {
+        if (filePath.endsWith('.js') || filePath.endsWith('.ts')) {
+            let command = await import('file://' + filePath).catch(e => {
+                console.error('[🆕🔴 ] Error loading command ' + chalk.blue(filePath.replace(/^.*[\\\/]/, '').split('.').slice(0, -1).join('.')));
+                console.log(e + '\n' + e.name + '\n' + e.stack);
+            });
+            command = Object.values(command)[0];
+            command = new command();
+            this.commands.set(command.constructor.name.toLowerCase(), command);
+            console.debug('[🆕🟢 ] Command ' + chalk.blue(filePath.replace(/^.*[\\\/]/, '').split('.').slice(0, -1).join('.')) + ' loaded');
+        }
     }
-    onCommandChanged(filePath) {
+    async onCommandChanged(filePath) {
+        if (filePath.endsWith('.js') || filePath.endsWith('.ts')) {
+            let command = await import('file://' + filePath + '?update=' + Date.now().toString()).catch(e => {
+                console.error('[🔄🔴 ] Error reloading command ' + chalk.blue(filePath.replace(/^.*[\\\/]/, '').split('.').slice(0, -1).join('.')));
+                console.log(boxen(e + '\n' + e.name + '\n' + e.stack, { padding: 1 }));
+            });
+            command = Object.values(command)[0];
+            command = new command();
+            this.commands.set(command.constructor.name.toLowerCase(), command);
+            console.debug('[🔄🟢 ] Command ' + chalk.blue(filePath.replace(/^.*[\\\/]/, '').split('.').slice(0, -1).join('.')) + ' reloaded');
+        }
     }
     onErrorLoadingCommand(error) {
         console.error('[🔄🔴 ] Error reloading command');
@@ -68,7 +92,10 @@ export class Module {
                 let moduleFileNames = fs.readdirSync(path.join(this.path, 'events', 'discord'));
                 for (let moduleFileName of moduleFileNames) {
                     if (moduleFileName.endsWith('.js') || moduleFileName.endsWith('.ts')) {
-                        let event = await import('file://' + path.join(this.path, 'events', 'discord', moduleFileName));
+                        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);
@@ -101,6 +128,10 @@ export class Module {
         args.forEach(arg => {
             finalArgs[arg.constructor.name.toLowerCase()] = arg;
         });
+        let selectMenuInteraction = args.find((arg) => arg instanceof SelectMenuInteraction);
+        if (selectMenuInteraction) {
+            finalArgs['interaction'] = selectMenuInteraction;
+        }
         return finalArgs;
     }
     getEvents() {
@@ -112,7 +143,6 @@ export class Module {
         let files = fs.readdirSync(path.join(this.path, 'translations'));
         for (let file of files) {
             if (file.endsWith('.json')) {
-                console.log('load ' + file);
                 let json = await import('file://' + `${this.path}/translations/${file}`, {
                     assert: {
                         type: "json",
@@ -122,7 +152,7 @@ export class Module {
                     console.log(boxen(e + '\n' + e.name + '\n' + e.stack, { padding: 1 }));
                 });
                 let lang = file.slice(0, -5);
-                this.parseTranslation('', lang, json);
+                this.parseTranslation('', lang, json.default);
             }
         }
     }
@@ -143,7 +173,6 @@ export class Module {
         for (let file of files) {
             if (file.endsWith('.json')) {
                 let modelName = file.slice(0, -5).charAt(0).toUpperCase() + file.slice(0, -5).slice(1);
-                console.log('load ' + file);
                 let modelDefiniton = await import('file://' + `${this.path}/models/${file}`, {
                     assert: {
                         type: "json",

package/dist/types/SelectMenuParameters.d.ts

@@ -1,8 +1,9 @@
-import { Client, Interaction } from "discord.js";
+import { Client, SelectMenuInteraction } from "discord.js";
 import { ZumitoFramework } from "../ZumitoFramework.js";
 export interface SelectMenuParameters {
     path: string[];
-    interaction: Interaction;
+    interaction: SelectMenuInteraction;
     client: Client;
     framework: ZumitoFramework;
+    guildSettings?: any;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zumito-framework",
-  "version": "1.1.33",
+  "version": "1.1.35",
   "description": "Discord.js bot framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,7 +15,7 @@
   },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "tsc",
+    "build": "tsc-esm",
     "publish": "npm publish",
     "docs": "typedoc --out docs src"
   },
@@ -30,16 +30,17 @@
     "chokidar": "^3.5.3",
     "cookie-parser": "^1.4.6",
     "cors": "^2.8.5",
-    "discord.js": "^14.2.0",
+    "discord.js": "^14.3.0",
+    "error-stack-parser": "^2.1.4",
     "express": "^4.18.1",
+    "leven": "^4.0.0",
     "mongoose": "^6.5.2",
-    "plop": "^3.1.1",
-    "zumito-framework": "^1.1.16"
+    "plop": "^3.1.1"
   },
   "devDependencies": {
     "@types/node": "^18.7.16",
-    "typedoc": "^0.23.10",
-    "typescript": "^4.7.4"
+    "typedoc": "^0.23.14",
+    "typescript": "^4.8.2"
   },
   "type": "module"
 }

package/plop-templates/command.js.hbs

@@ -1,10 +1,17 @@
 import { Command, CommandParameters } from "zumito-framework";
 
-export class {{command.charAt(0).toUpperCase() + command.slice(1)}} extends Command {
+export class {{capitalize command}} extends Command {
 
-    execute({ message, interaction, args, client, framework }: CommandParameters): void {
-        (message || interaction).reply({
+    execute({ message, interaction, args, client, framework, guildSettings }: CommandParameters): void {
+        (message || interaction!).reply({
             content: "Message content",
         });
     }
+
+    async selectMenu({ path, interaction, client, framework }: SelectMenuParameters): Promise<void> {
+        await interaction.deferUpdate();
+        await interaction.editReply({ 
+            content: "Select menu content",
+        });
+    }
 }

package/plopfile.js

@@ -1,4 +1,7 @@
 module.exports = function (plop) {
+	plop.setHelper('capitalize', function (text) {
+        return text.charAt(0).toUpperCase() + text.slice(1);
+    });
 	// create your generators here
 	plop.setGenerator('command', {
 		description: 'this is a skeleton command file',