zumito-framework 1.2.17 → 1.2.18

package/dist/ZumitoFramework.d.ts

@@ -2,7 +2,7 @@ import { Client, GuildMember, TextChannel } from 'discord.js';
 import { DatabaseModel } from './definitions/DatabaseModel.js';
 import { EventEmitter } from "tseep";
 import { FrameworkEvent } from './definitions/FrameworkEvent.js';
-import { FrameworkSettings } from './definitions/FrameworkSettings.js';
+import { FrameworkSettings } from './definitions/settings/FrameworkSettings.js';
 import { StatusManager } from './services/StatusManager.js';
 import { TranslationManager } from './services/TranslationManager.js';
 import { EventManager } from './services/EventManager.js';

package/dist/ZumitoFramework.js

@@ -138,6 +138,8 @@ export class ZumitoFramework {
         this.models = [];
         this.eventManager = new EventManager();
         ServiceContainer.addService(TranslationManager, [], true, this.translations);
+        ServiceContainer.addService(CommandManager, [], true, this.commands);
+        ServiceContainer.addService(EventManager, [], true, this.eventManager);
         if (settings.logLevel) {
             console.logLevel = settings.logLevel;
         }
@@ -247,7 +249,7 @@ export class ZumitoFramework {
         }
         const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
         if (this.settings.bundles && this.settings.bundles.length > 0) {
-            for (let bundle of this.settings.bundles) {
+            for (const bundle of this.settings.bundles) {
                 await this.registerBundle(bundle.path, bundle.options);
             }
         }

package/dist/definitions/ErrorType.d.ts

@@ -1,5 +1,6 @@
 export declare enum ErrorType {
     CommandInstance = 1,
     CommandLoad = 2,
-    CommandRun = 3
+    CommandRun = 3,
+    Other = 4
 }

package/dist/definitions/ErrorType.js

@@ -3,4 +3,5 @@ export var ErrorType;
     ErrorType[ErrorType["CommandInstance"] = 1] = "CommandInstance";
     ErrorType[ErrorType["CommandLoad"] = 2] = "CommandLoad";
     ErrorType[ErrorType["CommandRun"] = 3] = "CommandRun";
+    ErrorType[ErrorType["Other"] = 4] = "Other";
 })(ErrorType || (ErrorType = {}));

package/dist/definitions/FrameworkSettings.d.ts

@@ -1,19 +1,4 @@
-import { ModuleParameters } from "./parameters/ModuleParameters";
-import { StatusManagerOptions } from "./StatusManagerOptions";
-export interface FrameworkSettings {
-    database: any;
-    logLevel?: number;
-    debug?: boolean;
-    discordClientOptions: {
-        intents?: number;
-        token: string;
-        clientId: string;
-    };
-    defaultPrefix?: string;
-    statusOptions?: StatusManagerOptions;
-    srcMode?: 'multiBundle' | 'monoBundle' | undefined;
-    bundles?: {
-        path: string;
-        options?: ModuleParameters;
-    }[];
-}
+/**
+ * @deprecated
+ */
+export { FrameworkSettings } from "./settings/FrameworkSettings";

package/dist/definitions/commands/Command.d.ts

@@ -1,6 +1,6 @@
 import { CommandArgDefinition } from './CommandArgDefinition.js';
-import { CommandParameters } from './CommandParameters.js';
-import { SelectMenuParameters } from '../parameters/SelectMenuParameters.js';
+import { CommandParameters, PrefixCommandParameters, SlashCommandParameters } from './CommandParameters.js';
+import { CommandBinds } from './CommandBinds.js';
 /**
  * @name Command
  * @description Base class for all commands
@@ -201,19 +201,15 @@ export declare abstract class Command {
      * @see {@link CommandType}
      */
     type: string;
+    parent?: string;
+    binds?: CommandBinds;
     /**
      * @name execute
      * @description The function that is executed when the command is called.
      * @param {CommandParameters} parameters The parameters of the command.
-     * @param {Message} parameters.message The message that triggered the command.
-     * @param {CommandInteraction} parameters.interaction The interaction that triggered the command.
-     * @param {string[]} parameters.args The arguments of the command.
-     * @param {Client} parameters.client The client.
-     * @param {Framework} parameters.framework The framework.
-     * @param {trans} (key: string, options?: any) => string Translation shorthand function.
      */
-    abstract execute({ message, interaction, args, client, framework, }: CommandParameters): void;
-    executePrefixCommand({ message, interaction, args, client, framework, trans, }: CommandParameters): void;
-    executeSlashCommand({ message, interaction, args, client, framework, trans, }: CommandParameters): void;
-    abstract selectMenu({ path, interaction, client, framework, trans, }: SelectMenuParameters): void;
+    abstract execute(parameters: CommandParameters): Promise<void>;
+    executePrefixCommand({ message, args, client, framework, trans, }: PrefixCommandParameters): Promise<void>;
+    executeSlashCommand({ interaction, args, client, framework, trans, }: SlashCommandParameters): Promise<void>;
+    isSubCommand(): boolean;
 }

package/dist/definitions/commands/Command.js

@@ -199,10 +199,15 @@ export class Command {
      * @see {@link CommandType}
      */
     type = CommandType.prefix;
-    executePrefixCommand({ message, interaction, args, client, framework, trans, }) {
-        this.execute({ message, interaction, args, client, framework, trans });
+    parent;
+    binds;
+    async executePrefixCommand({ message, args, client, framework, trans, }) {
+        await this.execute({ message, args, client, framework, trans });
     }
-    executeSlashCommand({ message, interaction, args, client, framework, trans, }) {
-        this.execute({ message, interaction, args, client, framework, trans });
+    async executeSlashCommand({ interaction, args, client, framework, trans, }) {
+        await this.execute({ interaction, args, client, framework, trans });
+    }
+    isSubCommand() {
+        return this.parent !== undefined;
     }
 }

package/dist/definitions/commands/CommandBinds.d.ts

@@ -0,0 +1,4 @@
+import { SelectMenuParameters } from '../parameters/SelectMenuParameters.js';
+export declare type CommandBinds = {
+    selectMenu?: (params: SelectMenuParameters) => Promise<void>;
+};

package/dist/definitions/commands/CommandBinds.js

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

package/dist/definitions/commands/CommandParameters.d.ts

@@ -8,9 +8,7 @@ import { ZumitoFramework } from '../../ZumitoFramework.js';
  * @property {interaction} interaction - The interaction that triggered the command.
  * @property {args} args - The arguments passed to the command.
  */
-export interface CommandParameters {
-    message?: Message;
-    interaction?: CommandInteraction;
+export interface BaseCommandParameters {
     args: Map<string, any>;
     /**
      * Discord client instance
@@ -29,3 +27,12 @@ export interface CommandParameters {
     guildSettings?: any;
     trans: (key: string, params?: any) => string;
 }
+export declare type SlashCommandParameters = BaseCommandParameters & {
+    interaction: CommandInteraction;
+    message?: null;
+};
+export declare type PrefixCommandParameters = BaseCommandParameters & {
+    message: Message;
+    interaction?: null;
+};
+export declare type CommandParameters = PrefixCommandParameters | SlashCommandParameters;

package/dist/definitions/parameters/EventParameters.d.ts

@@ -3,6 +3,12 @@ import { ZumitoFramework } from '../../ZumitoFramework.js';
 export interface EventParameters {
     message?: Message;
     interaction?: Interaction;
+    /**
+     * @deprecated
+     */
     client?: Client;
+    /**
+     * @deprecated
+     */
     framework: ZumitoFramework;
 }

package/dist/definitions/parameters/SelectMenuParameters.d.ts

@@ -3,7 +3,13 @@ import { ZumitoFramework } from '../../ZumitoFramework.js';
 export interface SelectMenuParameters {
     path: string[];
     interaction: SelectMenuInteraction;
+    /**
+     * @deprecated
+     */
     client: Client;
+    /**
+     * @deprecated
+     */
     framework: ZumitoFramework;
     guildSettings?: any;
     trans: (key: string, params?: any) => string;

package/dist/definitions/settings/FrameworkSettings.d.ts

@@ -0,0 +1,24 @@
+import { ModuleParameters } from "../parameters/ModuleParameters";
+import { StatusManagerOptions } from "../StatusManagerOptions";
+export interface FrameworkSettings {
+    database: any;
+    logLevel?: number;
+    debug?: boolean;
+    discordClientOptions: {
+        intents?: number;
+        token: string;
+        clientId: string;
+    };
+    defaultPrefix?: string;
+    statusOptions?: StatusManagerOptions;
+    /**
+     * Read the ./src folder as multiple modules or unique module
+     * This feature is experimental and can disapear anytime
+     * @experimental
+     */
+    srcMode?: 'multiBundle' | 'monoBundle' | undefined;
+    bundles?: {
+        path: string;
+        options?: ModuleParameters;
+    }[];
+}

package/dist/definitions/settings/FrameworkSettings.js

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

package/dist/definitions/settings/InteractionHandlerSettings.d.ts

@@ -0,0 +1,3 @@
+export declare type InteractionHandlerSettings = {
+    disabledHandlers?: ('command' | 'selectMenu' | 'button' | 'modal')[];
+};

package/dist/definitions/settings/InteractionHandlerSettings.js

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

package/dist/index.d.ts

@@ -27,4 +27,7 @@ import { CommandParser } from './services/CommandParser.js';
 import { SlashCommandRefresher } from './services/SlashCommandRefresher.js';
 import { ErrorHandler } from './services/ErrorHandler.js';
 import { Route, RouteMethod } from './definitions/Route.js';
-export { ZumitoFramework, FrameworkSettings, Command, Module, CommandParameters, CommandArguments, FrameworkEvent, Translation, TranslationManager, ApiResponse, SelectMenuParameters, CommandType, CommandArgDefinition, CommandChoiceDefinition, ButtonPressed, ButtonPressedParams, TextFormatter, EmojiFallback, DatabaseConfigLoader, DatabaseModel, PresenceDataRule, RuledPresenceData, StatusManagerOptions, discord, EventParameters, ServiceContainer, GuildDataGetter, SlashCommandRefresher, CommandParser, ErrorHandler, Route, RouteMethod };
+import { InteractionHandler } from './services/InteractionHandler.js';
+import { CommandManager } from './services/CommandManager.js';
+import { ErrorType } from './definitions/ErrorType.js';
+export { ZumitoFramework, FrameworkSettings, Command, Module, CommandParameters, CommandArguments, FrameworkEvent, Translation, TranslationManager, ApiResponse, SelectMenuParameters, CommandType, CommandArgDefinition, CommandChoiceDefinition, ButtonPressed, ButtonPressedParams, TextFormatter, EmojiFallback, DatabaseConfigLoader, DatabaseModel, PresenceDataRule, RuledPresenceData, StatusManagerOptions, discord, EventParameters, ServiceContainer, GuildDataGetter, SlashCommandRefresher, CommandParser, ErrorHandler, ErrorType, Route, RouteMethod, InteractionHandler, CommandManager };

package/dist/index.js

@@ -20,11 +20,15 @@ import { CommandParser } from './services/CommandParser.js';
 import { SlashCommandRefresher } from './services/SlashCommandRefresher.js';
 import { ErrorHandler } from './services/ErrorHandler.js';
 import { Route, RouteMethod } from './definitions/Route.js';
+import { InteractionHandler } from './services/InteractionHandler.js';
+import { CommandManager } from './services/CommandManager.js';
+import { ErrorType } from './definitions/ErrorType.js';
 ServiceContainer.addService(TextFormatter, []);
 ServiceContainer.addService(EmojiFallback, [discord.Client.name, TranslationManager.name]);
 ServiceContainer.addService(GuildDataGetter, [ZumitoFramework.name]);
 ServiceContainer.addService(MemberPermissionChecker, []);
 ServiceContainer.addService(CommandParser, []);
 ServiceContainer.addService(SlashCommandRefresher, [ZumitoFramework.name]);
+ServiceContainer.addService(InteractionHandler, []);
 ServiceContainer.addService(ErrorHandler, ['ZumitoFramework']);
-export { ZumitoFramework, Command, Module, CommandArguments, FrameworkEvent, Translation, TranslationManager, ApiResponse, CommandType, ButtonPressed, TextFormatter, EmojiFallback, DatabaseConfigLoader, DatabaseModel, discord, ServiceContainer, GuildDataGetter, SlashCommandRefresher, CommandParser, ErrorHandler, Route, RouteMethod };
+export { ZumitoFramework, Command, Module, CommandArguments, FrameworkEvent, Translation, TranslationManager, ApiResponse, CommandType, ButtonPressed, TextFormatter, EmojiFallback, DatabaseConfigLoader, DatabaseModel, discord, ServiceContainer, GuildDataGetter, SlashCommandRefresher, CommandParser, ErrorHandler, ErrorType, Route, RouteMethod, InteractionHandler, CommandManager };

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

@@ -1,9 +1,10 @@
-import { Command } from '../../../../../definitions/commands/Command.js';
 import { EventParameters } from '../../../../../definitions/parameters/EventParameters.js';
 import { FrameworkEvent } from '../../../../../definitions/FrameworkEvent.js';
+import { InteractionHandler } from '../../../../../services/InteractionHandler.js';
 export declare class InteractionCreate extends FrameworkEvent {
     once: boolean;
     source: string;
-    execute({ interaction, client, framework, }: EventParameters): Promise<void>;
-    getTransMethod(commandInstance: Command, framework: any, guildSettings: any): (key: string, params?: any) => any;
+    interactionHandler: InteractionHandler;
+    constructor();
+    execute({ interaction, }: EventParameters): Promise<void>;
 }

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

@@ -1,129 +1,15 @@
-import { CommandType } from '../../../../../definitions/commands/CommandType.js';
 import { FrameworkEvent } from '../../../../../definitions/FrameworkEvent.js';
+import { ServiceContainer } from '../../../../../services/ServiceContainer.js';
+import { InteractionHandler } from '../../../../../services/InteractionHandler.js';
 export class InteractionCreate extends FrameworkEvent {
     once = false;
     source = 'discord';
-    async execute({ interaction, client, framework, }) {
-        let guildSettings;
-        if (interaction.guildId) {
-            guildSettings = await framework.getGuildSettings(interaction.guildId);
-        }
-        if (interaction.isCommand()) {
-            if (!framework.commands.getAll().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,
-                });
-            }
-        }
+    interactionHandler;
+    constructor() {
+        super();
+        this.interactionHandler = ServiceContainer.getService(InteractionHandler);
     }
-    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);
-            }
-        };
+    async execute({ interaction, }) {
+        await this.interactionHandler.handleInteraction(interaction);
     }
 }

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

@@ -1,9 +1,16 @@
 import { ActionRowBuilder, EmbedBuilder } from 'discord.js';
 import { EventParameters } from '../../../../../definitions/parameters/EventParameters.js';
 import { FrameworkEvent } from '../../../../../definitions/FrameworkEvent.js';
+import { MemberPermissionChecker } from '../../../../../services/MemberPermissionChecker.js';
+import { ZumitoFramework } from '../../../../../ZumitoFramework.js';
+import { GuildDataGetter } from '../../../../../services/GuildDataGetter.js';
 export declare class MessageCreate extends FrameworkEvent {
     once: boolean;
     source: string;
+    memberPermissionChecker: MemberPermissionChecker;
+    framework: ZumitoFramework;
+    guildDataGetter: GuildDataGetter;
+    constructor();
     execute({ message, framework }: EventParameters): Promise<import("discord.js").Message<boolean>>;
     autocorrect(str: string, words: string[]): any;
     getErrorEmbed(error: any, parse: any): {

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

@@ -1,20 +1,33 @@
 import { ActionRowBuilder, ButtonBuilder, ButtonStyle, ChannelType, EmbedBuilder, PermissionsBitField, } from 'discord.js';
 import ErrorStackParser from 'error-stack-parser';
 import { FrameworkEvent } from '../../../../../definitions/FrameworkEvent.js';
-import { ZumitoFramework } from '../../../../../ZumitoFramework.js';
 import leven from 'leven';
 import path from 'path';
-import { InteractionIdGenerator } from '../../../../../services/InteractionIdGenerator.js';
+import { ServiceContainer } from '../../../../../services/ServiceContainer.js';
+import { CommandParser } from '../../../../../services/CommandParser.js';
+import { MemberPermissionChecker } from '../../../../../services/MemberPermissionChecker.js';
+import { ZumitoFramework } from '../../../../../ZumitoFramework.js';
+import { GuildDataGetter } from '../../../../../services/GuildDataGetter.js';
 export class MessageCreate extends FrameworkEvent {
     once = false;
     source = 'discord';
+    memberPermissionChecker;
+    framework;
+    guildDataGetter;
+    constructor() {
+        super();
+        this.memberPermissionChecker = ServiceContainer.getService(MemberPermissionChecker);
+        this.framework = ServiceContainer.getService(ZumitoFramework);
+        this.guildDataGetter = ServiceContainer.getService(GuildDataGetter);
+    }
     async execute({ message, framework }) {
         const channel = message.channel;
         const prefix = framework.settings.defaultPrefix;
-        const args = ZumitoFramework.splitCommandLine(message.content.slice(prefix.length));
+        const args = CommandParser.splitCommandLine(message.content.slice(prefix.length));
         const command = args.shift().toLowerCase();
         let commandInstance;
         if (message.content.startsWith(prefix)) {
+            debugger;
             if (!framework.commands.getAll().has(command)) {
                 const commandNames = Array.from(framework.commands.getAll().keys());
                 const correctedCommand = this.autocorrect(command, commandNames);
@@ -26,18 +39,24 @@ export class MessageCreate extends FrameworkEvent {
                 }
             }
             else {
-                commandInstance = framework.commands.get(command);
+                const tmpCmd = framework.commands.get(command);
+                if (tmpCmd && !tmpCmd.parent) {
+                    commandInstance = tmpCmd;
+                }
             }
+            commandInstance = Array.from(this.framework.commands.getAll().values()).find((c) => c.name == args.at(0) && c.parent && c.parent == command) || commandInstance;
+            if (!commandInstance)
+                return;
             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) ||
+                if (this.memberPermissionChecker.hasPermissionOnChannel(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)) {
+                            if (!this.memberPermissionChecker.hasPermissionOnChannel(message.member, message.channel, permission)) {
                                 denied = true;
                             }
                         });
@@ -70,37 +89,17 @@ export class MessageCreate extends FrameworkEvent {
                 }
             }
             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 guildSettings = await this.guildDataGetter.getGuildSettings(message.guildId);
+                const parsedArgsResponse = await CommandParser.parseFromSplitedString(args, commandInstance.args, message.guild);
+                if (parsedArgsResponse.errors.length > 0) {
+                    return message.reply({
+                        content: parsedArgsResponse.errors.at(0),
+                        allowedMentions: {
+                            repliedUser: false,
+                        },
+                    });
                 }
-                const interactionIdGenerator = new InteractionIdGenerator(undefined, commandInstance.name);
+                const parsedArgs = parsedArgsResponse.parsedArgs;
                 await commandInstance.execute({
                     message,
                     args: parsedArgs,

package/dist/services/CommandManager.js

@@ -40,6 +40,7 @@ export class CommandManager {
      * @returns {Promise<Command>}
      */
     async loadCommandFile(filePath) {
+        let loaded = false;
         // Validate file has .ts or .js extension
         if (!filePath.endsWith('.js') && !filePath.endsWith('.ts')) {
             throw new Error("File must be a .ts or .js");
@@ -49,9 +50,14 @@ export class CommandManager {
             console.error('[🆕🔴 ] Error loading command ' + chalk.blue(filePath.toString().replace(/^.*[\\\/]/, '').split('.').slice(0, -1).join('.')));
             console.log(e + '\n' + e.name + '\n' + e.stack);
         });
+        if (!command)
+            return;
         command = Object.values(command)[0];
         try {
             command = new command();
+            this.framework.commands.set(command.constructor.name.toLowerCase(), command);
+            console.debug('[🆕🟢 ] Command ' + chalk.blue(filePath.toString().replace(/^.*[\\\/]/, '').split('.').slice(0, -1).join('.')) + ' loaded');
+            loaded = true;
         }
         catch (error) {
             this.errorHandler.handleError(error, {
@@ -59,9 +65,8 @@ export class CommandManager {
                 command: command,
             });
         }
-        this.framework.commands.set(command.constructor.name.toLowerCase(), command);
-        console.debug('[🆕🟢 ] Command ' + chalk.blue(filePath.toString().replace(/^.*[\\\/]/, '').split('.').slice(0, -1).join('.')) + ' loaded');
-        return command;
+        if (loaded)
+            return command;
     }
     /**
      * Load all command files from a folder
@@ -77,12 +82,14 @@ export class CommandManager {
                 continue;
             if (file.endsWith('.js') || file.endsWith('.ts')) {
                 const command = await this.loadCommandFile(path.join(folderPath, file));
-                const commandName = command.constructor.name.toLowerCase();
-                if (options?.blacklist && options.blacklist.includes(commandName))
-                    continue;
-                if (options?.whitelist && !options.whitelist.includes(commandName))
-                    continue;
-                this.commands.set(options?.renames?.[commandName] || commandName, command);
+                if (command) {
+                    const commandName = command.constructor.name.toLowerCase();
+                    if (options?.blacklist && options.blacklist.includes(commandName))
+                        continue;
+                    if (options?.whitelist && !options.whitelist.includes(commandName))
+                        continue;
+                    this.commands.set(options?.renames?.[commandName] || commandName, command);
+                }
             }
         }
         return this.commands;

package/dist/services/CommandParser.d.ts

@@ -1,3 +1,5 @@
+import { Guild } from "discord.js";
+import { CommandArgDefinition } from "../definitions/commands/CommandArgDefinition";
 export declare class CommandParser {
     /**
      * From a command-line string, returns an array of parameters.
@@ -13,4 +15,9 @@ export declare class CommandParser {
      * splitCommandLine('a "b c"');
      */
     static splitCommandLine(commandLine: any): any;
+    static parseFromSplitedString(args: any, argDefinitions: CommandArgDefinition[], guild: Guild): Promise<{
+        validated: boolean;
+        errors: any[];
+        parsedArgs: Map<string, any>;
+    }>;
 }

package/dist/services/CommandParser.js

@@ -36,4 +36,36 @@ export class CommandParser {
         });
         return paramArray;
     }
+    static async parseFromSplitedString(args, argDefinitions, guild) {
+        const parsedArgs = new Map();
+        const errors = [];
+        for (let i = 0; i < args.length; i++) {
+            const arg = args[i];
+            const type = argDefinitions[i]?.type;
+            if (type) {
+                if (type == 'member' || type == 'user') {
+                    const member = await guild.members.cache.get(arg.replace(/[<@!>]/g, ''));
+                    if (member) {
+                        if (type == 'user') {
+                            parsedArgs.set(argDefinitions[i].name, member.user);
+                        }
+                        else {
+                            parsedArgs.set(argDefinitions[i].name, member);
+                        }
+                    }
+                    else {
+                        errors.push('Invalid user.');
+                    }
+                }
+                else if (type == 'string') {
+                    parsedArgs.set(argDefinitions[i]?.name || i.toString(), arg);
+                }
+            }
+        }
+        return {
+            validated: errors.length == 0,
+            errors,
+            parsedArgs,
+        };
+    }
 }

package/dist/services/ErrorHandler.d.ts

@@ -12,8 +12,9 @@ declare type CommandErrorOptions = BaseErrorOptions & {
 export declare class ErrorHandler {
     framework: ZumitoFramework;
     constructor(framework: ZumitoFramework);
-    handleError(error: Error, options: BaseErrorOptions | CommandErrorOptions): void;
+    handleError(error: any, options: BaseErrorOptions | CommandErrorOptions): void;
     handleCommandError(error: Error, options: CommandErrorOptions): void;
+    handleShapeShiftErrors(error: any): void;
     printErrorStack(error: Error): void;
 }
 export {};

package/dist/services/ErrorHandler.js

@@ -1,6 +1,7 @@
 import ErrorStackParser from "error-stack-parser";
 import { ErrorType } from "../definitions/ErrorType";
 import chalk from "chalk";
+import sf from 'source-fragment';
 export class ErrorHandler {
     framework;
     constructor(framework) {
@@ -10,8 +11,20 @@ export class ErrorHandler {
         if (options?.type == ErrorType.CommandInstance || options?.type == ErrorType.CommandLoad || options?.type == ErrorType.CommandRun) {
             this.handleCommandError(error, options);
         }
+        else if (error.constructor.name == 'CombinedError') {
+            this.handleShapeShiftErrors(error);
+        }
+        else if (error.constructor?.name == "ExpectedValidationError") {
+            console.error(`Validation error: Expected ${error.expected}, but received ${error.given}.`);
+            console.line('');
+        }
+        else if (error.constructor.name == "ValidationError") {
+            console.error(`Validation error: ${error.validator} received invalid input: ${error.given}`);
+            console.line('');
+        }
         else {
             console.error(error.toString());
+            console.line('');
         }
         this.printErrorStack(error);
         if (options.exit)
@@ -20,7 +33,7 @@ export class ErrorHandler {
     handleCommandError(error, options) {
         switch (options.type) {
             case ErrorType.CommandInstance:
-                console.group(`[❌] Error instanciating command ${options.command.name}`);
+                console.group(`[❌] Error instanciating command ${options?.command?.name}`);
                 break;
             case ErrorType.CommandLoad:
                 console.group(`[❌] Error loading command ${options.command.name}`);
@@ -29,21 +42,70 @@ export class ErrorHandler {
                 console.group(`[❌] Error running command ${options.command.name}`);
                 break;
         }
-        console.line(error.toString());
-        console.groupEnd();
+        if (error.constructor.name == 'CombinedError') {
+            console.groupEnd();
+            this.handleShapeShiftErrors(error);
+        }
+        else {
+            console.line(chalk.red('Error:'));
+            console.line(error.toString());
+            console.line('');
+            console.groupEnd();
+        }
+    }
+    handleShapeShiftErrors(error) {
+        if (error.constructor.name == 'CombinedError') {
+            error.errors.forEach(err => {
+                this.handleError(err, {
+                    type: ErrorType.Other
+                });
+            });
+        }
     }
     printErrorStack(error) {
         const stackParsedError = ErrorStackParser.parse(error);
         let functionColor = 'blue';
-        for (let stack of stackParsedError) {
-            const filePath = stack.getFileName();
-            let functionName = stack.getFunctionName();
+        const lines = [];
+        let codeFragment;
+        let lastStack;
+        for (const stack of stackParsedError) {
+            const filePath = stack.getFileName().replace(process.cwd(), '.').replace('file://', '');
+            const functionName = stack.getFunctionName();
             if (functionName == 'CommandManager.loadCommandFile') {
                 functionColor = 'yellow';
             }
-            console.line(`    at ${chalk.gray(filePath)}:${stack.getLineNumber()}:${stack.getColumnNumber()} ${chalk[functionColor](functionName)}`);
+            lines.push(`    at ${chalk.gray(filePath)}:${stack.getLineNumber()}:${stack.getColumnNumber()} ${chalk[functionColor](functionName)}`);
             if (functionName == 'CommandManager.loadCommandFile' && !this.framework.settings.debug)
                 break;
+            if (!codeFragment && functionName.includes('.execute')) {
+                let columnEnd = -1;
+                if (lastStack) {
+                    if (lastStack.getFunctionName().contains('.')) {
+                        columnEnd = lastStack.getFunctionName().split('.').at(-1).length;
+                    }
+                    else {
+                        columnEnd = lastStack.getFunctionName().length;
+                    }
+                }
+                codeFragment = {
+                    path: `${filePath}:${stack.getLineNumber()}:${stack.getColumnNumber()}`,
+                    code: sf(`${filePath}:${stack.getLineNumber()}:${stack.getColumnNumber()}:${stack.getLineNumber()}:${stack.getColumnNumber() + columnEnd}`, {
+                        format: 'tty',
+                        linesBefore: 2,
+                        linesAfter: 2,
+                    })
+                };
+            }
+            lastStack = stack;
+        }
+        // Log code fragment
+        if (codeFragment) {
+            console.line(chalk.blue('File: ') + `${codeFragment.path}`);
+            console.line(codeFragment.code);
+            console.line('');
         }
+        // Log stack
+        console.line(chalk.blue('StackTrace:'));
+        lines.forEach(line => console.line(line));
     }
 }

package/dist/services/InteractionHandler.d.ts

@@ -0,0 +1,21 @@
+import { ButtonInteraction, Client, CommandInteraction, Interaction, ModalSubmitInteraction, StringSelectMenuInteraction } from "discord.js";
+import { CommandManager } from "./CommandManager";
+import { GuildDataGetter } from "./GuildDataGetter";
+import { TranslationManager } from "./TranslationManager";
+import { EventManager } from "./EventManager";
+import { InteractionHandlerSettings } from "@definitions/settings/InteractionHandlerSettings";
+import { ErrorHandler } from "./ErrorHandler";
+export declare class InteractionHandler {
+    protected commandManager: CommandManager;
+    protected guildDataGetter: GuildDataGetter;
+    protected client: Client;
+    protected translationManager: TranslationManager;
+    protected eventManager: EventManager;
+    protected errorHandler: ErrorHandler;
+    constructor();
+    handleInteraction(interaction: Interaction, params?: InteractionHandlerSettings): Promise<void>;
+    handleCommandInteraction(interaction: CommandInteraction, guildSettings?: any): Promise<void>;
+    handleButtonInteraction(interaction: ButtonInteraction, guildSettings?: any): Promise<void>;
+    handleSelectMenu(interaction: StringSelectMenuInteraction, guildSettings?: any): Promise<void>;
+    handleModalInteraction(interaction: ModalSubmitInteraction, guildSettings?: any): Promise<void>;
+}

package/dist/services/InteractionHandler.js

@@ -0,0 +1,206 @@
+import { Client } from "discord.js";
+import { CommandManager } from "./CommandManager";
+import { GuildDataGetter } from "./GuildDataGetter";
+import { ServiceContainer } from "./ServiceContainer";
+import { CommandType } from "../definitions/commands/CommandType";
+import { ZumitoFramework } from "../ZumitoFramework";
+import { TranslationManager } from "./TranslationManager";
+import { EventManager } from "./EventManager";
+import { ErrorHandler } from "./ErrorHandler";
+import { ErrorType } from "../definitions/ErrorType";
+export class InteractionHandler {
+    commandManager;
+    guildDataGetter;
+    client;
+    translationManager;
+    eventManager;
+    errorHandler;
+    constructor() {
+        this.commandManager = ServiceContainer.getService(CommandManager);
+        this.guildDataGetter = ServiceContainer.getService(GuildDataGetter);
+        this.client = ServiceContainer.getService(Client);
+        this.translationManager = ServiceContainer.getService(TranslationManager);
+        this.eventManager = ServiceContainer.getService(EventManager);
+        this.errorHandler = ServiceContainer.getService(ErrorHandler);
+    }
+    async handleInteraction(interaction, params) {
+        if (interaction.isCommand()) {
+            if (params?.disabledHandlers?.includes("command"))
+                return;
+            await this.handleCommandInteraction(interaction);
+        }
+        else if (interaction.isButton()) {
+            if (params?.disabledHandlers?.includes("button"))
+                return;
+            await this.handleButtonInteraction(interaction);
+        }
+        else if (interaction.isStringSelectMenu()) {
+            if (params?.disabledHandlers?.includes("selectMenu"))
+                return;
+            await this.handleSelectMenu(interaction);
+        }
+        else if (interaction.isModalSubmit()) {
+            if (params?.disabledHandlers?.includes("modal"))
+                return;
+            await this.handleModalInteraction(interaction);
+        }
+    }
+    async handleCommandInteraction(interaction, guildSettings) {
+        const subcommandName = interaction.options.getSubcommand(false);
+        const commandName = interaction.commandName;
+        let commandInstance;
+        if (subcommandName) {
+            commandInstance = Array.from(this.commandManager.getAll().values()).find(c => c.name == subcommandName && c.parent == commandName);
+        }
+        else {
+            commandInstance = this.commandManager.get(commandName);
+        }
+        if (!commandInstance)
+            return;
+        const framework = ServiceContainer.getService(ZumitoFramework);
+        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;
+        if (!guildSettings && interaction.guildId) {
+            guildSettings = await ServiceContainer.getService(GuildDataGetter).getGuildSettings(interaction.guildId);
+        }
+        const trans = this.translationManager.getShortHandMethod('command.' + commandInstance.name, guildSettings?.lang);
+        if (commandInstance.type === CommandType.separated ||
+            commandInstance.type === CommandType.slash) {
+            await commandInstance.executeSlashCommand({
+                client: this.client,
+                interaction, args, framework, guildSettings, trans,
+            });
+        }
+        else {
+            try {
+                await commandInstance.execute({
+                    client: this.client,
+                    interaction, args, framework, guildSettings, trans,
+                }).catch((error) => {
+                    this.errorHandler.handleError(error, {
+                        command: commandInstance,
+                        type: ErrorType.CommandRun,
+                    });
+                    interaction.reply({
+                        content: "An error ocurred while running this command.",
+                        ephemeral: true
+                    });
+                });
+            }
+            catch (error) {
+                this.errorHandler.handleError(error, {
+                    command: commandInstance,
+                    type: ErrorType.CommandRun,
+                });
+                interaction.reply({
+                    content: "An error ocurred while running this command.",
+                    ephemeral: true,
+                });
+            }
+        }
+    }
+    async handleButtonInteraction(interaction, guildSettings) {
+        const framework = ServiceContainer.getService(ZumitoFramework);
+        const path = interaction.customId.split('.');
+        const commandInstance = this.commandManager.get(path[0]);
+        if (!commandInstance)
+            throw new Error(`Command ${path[0]} not found or button id bad formatted`);
+        if (!guildSettings && interaction.guildId) {
+            guildSettings = await ServiceContainer.getService(GuildDataGetter).getGuildSettings(interaction.guildId);
+        }
+        // If the command has impements ButtonPress class then execute the method
+        if (commandInstance.constructor.prototype.hasOwnProperty('buttonPressed')) {
+            commandInstance.buttonPressed({
+                client: this.client,
+                path,
+                interaction,
+                framework,
+                guildSettings,
+            });
+        }
+    }
+    async handleSelectMenu(interaction, guildSettings) {
+        const path = interaction.customId.split('.');
+        const commandInstance = this.commandManager.get(path[0]);
+        if (!commandInstance)
+            throw new Error(`Command ${path[0]} not found or select menu id bad formatted`);
+        if (!guildSettings && interaction.guildId) {
+            guildSettings = await ServiceContainer.getService(GuildDataGetter).getGuildSettings(interaction.guildId);
+        }
+        const trans = this.translationManager.getShortHandMethod('command.' + commandInstance.name, guildSettings?.lang);
+        const framework = ServiceContainer.getService(ZumitoFramework);
+        if (commandInstance.binds?.selectMenu) {
+            commandInstance.binds?.selectMenu({
+                path,
+                interaction,
+                client: this.client,
+                framework,
+                guildSettings,
+                trans,
+            });
+        }
+        else if ( // Deprecated
+        commandInstance.constructor.prototype.hasOwnProperty('selectMenu')) {
+            commandInstance.selectMenu({
+                path,
+                interaction,
+                client: this.client,
+                framework,
+                guildSettings,
+                trans,
+            });
+        }
+    }
+    async handleModalInteraction(interaction, guildSettings) {
+        const path = interaction.customId.split('.');
+        const commandInstance = this.commandManager.get(path[0]);
+        if (!commandInstance) {
+            throw new Error(`Command ${path[0]} not found or modal id bad formatted`);
+        }
+        const framework = ServiceContainer.getService(ZumitoFramework);
+        if (commandInstance.modalSubmit) {
+            if (!guildSettings && interaction.guildId) {
+                guildSettings = await ServiceContainer.getService(GuildDataGetter).getGuildSettings(interaction.guildId);
+            }
+            commandInstance.modalSubmit({
+                client: this.client,
+                path,
+                interaction,
+                framework,
+                guildSettings,
+            });
+        }
+        else {
+            this.eventManager.emitEvent('modalSubmit', 'framework', {
+                client: this.client,
+                path, interaction, framework, guildSettings,
+            });
+        }
+    }
+}

package/dist/services/ServiceContainer.d.ts

@@ -1 +1,9 @@
-export declare const ServiceContainer: any;
+declare class ServiceContainerManager {
+    private services;
+    addService(serviceClass: any, dependencies: string[], singleton?: boolean, instance?: any): void;
+    getService<T>(serviceClass: new (...args: any[]) => T | string): T;
+    getServiceByName<T>(serviceName: string): T;
+    addInstance(serviceClass: any, instance: any): void;
+}
+export declare const ServiceContainer: ServiceContainerManager;
+export {};

package/dist/services/ServiceContainer.js

@@ -9,13 +9,25 @@ class ServiceContainerManager {
         });
     }
     getService(serviceClass) {
-        const serviceName = typeof serviceClass == 'string' ? serviceClass : serviceClass.name;
+        const serviceName = typeof serviceClass === 'string' ? serviceClass : serviceClass.name;
+        const service = this.services.get(serviceName);
+        if (!service)
+            throw new Error(`Service ${serviceName} not found`);
+        if (service.singleton && service.instance)
+            return service.instance;
+        const dependencies = service.dependencies.map(dependency => this.getServiceByName(dependency));
+        const instance = new service.class(...dependencies);
+        if (service.singleton)
+            service.instance = instance;
+        return instance;
+    }
+    getServiceByName(serviceName) {
         const service = this.services.get(serviceName);
         if (!service)
             throw new Error(`Service ${serviceName} not found`);
         if (service.singleton && service.instance)
             return service.instance;
-        const dependencies = service.dependencies.map(dependency => this.getService(dependency));
+        const dependencies = service.dependencies.map(dependency => this.getServiceByName(dependency));
         const instance = new service.class(...dependencies);
         if (service.singleton)
             service.instance = instance;

package/dist/services/SlashCommandRefresher.d.ts

@@ -1,6 +1,9 @@
 import { ZumitoFramework } from "../ZumitoFramework";
+import { Command } from "../definitions/commands/Command";
+import { SlashCommandSubcommandBuilder } from "discord.js";
 export declare class SlashCommandRefresher {
-    framework: ZumitoFramework;
+    protected framework: ZumitoFramework;
     constructor(framework: ZumitoFramework);
     refreshSlashCommands(): Promise<void>;
+    mapCommand(command: Command, commandBuilder?: SlashCommandSubcommandBuilder): import("discord.js").RESTPostAPIChatInputApplicationCommandsJSONBody | import("discord.js").APIApplicationCommandSubcommandOption;
 }

package/dist/services/SlashCommandRefresher.js

@@ -13,61 +13,78 @@ export class SlashCommandRefresher {
     async refreshSlashCommands() {
         const rest = new REST({ version: '10' }).setToken(this.framework.settings.discordClientOptions.token);
         const commands = Array.from(this.framework.commands.getAll().values())
-            .filter((command) => command.type == CommandType.slash ||
+            .filter((command) => (command.type == CommandType.slash ||
             command.type == CommandType.separated ||
             command.type == CommandType.any)
-            .map((command) => {
-            const slashCommand = new SlashCommandBuilder()
-                .setName(command.name)
-                .setDescription(this.framework.translations.get('command.' + command.name + '.description', 'en'));
-            if (command.args) {
-                command.args.forEach((arg) => {
-                    let method;
-                    switch (arg.type) {
-                        case 'string':
-                            method = 'addStringOption';
-                            break;
-                        case 'user':
-                        case 'member':
-                            method = 'addUserOption';
-                            break;
-                        case 'channel':
-                            method = 'addChannelOption';
-                            break;
-                        case 'role':
-                            method = 'addRoleOption';
-                            break;
-                        default:
-                            throw new Error('Invalid argument type ' + arg.type);
-                    }
-                    slashCommand[method]((option) => {
-                        option.setName(arg.name);
-                        option.setDescription(this.framework.translations.get('command.' +
-                            command.name +
-                            '.args.' +
-                            arg.name +
-                            '.description', 'en'));
-                        option.setRequired(!arg.optional);
-                        if (arg.choices) {
-                            // if arg.choices is function, call it
-                            if (typeof arg.choices == 'function') {
-                                arg.choices =
-                                    arg.choices();
-                            }
-                            arg.choices.forEach((choice) => {
-                                option.addChoices({
-                                    name: choice.name,
-                                    value: choice.value,
-                                });
-                            });
+            && !command.parent)
+            .map(command => this.mapCommand(command));
+        const data = await rest.put(Routes.applicationCommands(this.framework.settings.discordClientOptions.clientId), { body: commands });
+        console.debug(`Successfully reloaded ${data.length} of ${commands.length} application (/) commands.`);
+    }
+    mapCommand(command, commandBuilder) {
+        const slashCommand = commandBuilder || new SlashCommandBuilder();
+        slashCommand
+            .setName(command.name)
+            .setDescription(this.framework.translations.get('command.' + command.name + '.description', 'en'));
+        if (command.args) {
+            command.args.forEach((arg) => {
+                let method;
+                switch (arg.type) {
+                    case 'string':
+                        method = 'addStringOption';
+                        break;
+                    case 'user':
+                    case 'member':
+                        method = 'addUserOption';
+                        break;
+                    case 'channel':
+                        method = 'addChannelOption';
+                        break;
+                    case 'role':
+                        method = 'addRoleOption';
+                        break;
+                    default:
+                        throw new Error('Invalid argument type ' + arg.type);
+                }
+                slashCommand[method]((option) => {
+                    option.setName(arg.name);
+                    option.setDescription(this.framework.translations.get('command.' +
+                        command.name +
+                        '.args.' +
+                        arg.name +
+                        '.description', 'en'));
+                    option.setRequired(!arg.optional);
+                    if (arg.choices) {
+                        // if arg.choices is function, call it
+                        if (typeof arg.choices == 'function') {
+                            arg.choices =
+                                arg.choices();
                         }
-                        return option;
-                    });
+                        arg.choices.forEach((choice) => {
+                            option.addChoices({
+                                name: choice.name,
+                                value: choice.value,
+                            });
+                        });
+                    }
+                    return option;
+                });
+            });
+        }
+        Array.from(this.framework.commands.getAll().values())
+            .filter((subcommand) => (subcommand.type == CommandType.slash ||
+            subcommand.type == CommandType.separated ||
+            subcommand.type == CommandType.any)
+            && subcommand.parent
+            && subcommand.parent == command.name)
+            .forEach(subcommand => {
+            if (!commandBuilder) {
+                slashCommand.addSubcommand((subcommandSlashBuilder) => {
+                    this.mapCommand(subcommand, subcommandSlashBuilder);
+                    return subcommandSlashBuilder;
                 });
             }
-            return slashCommand.toJSON();
         });
-        const data = await rest.put(Routes.applicationCommands(this.framework.settings.discordClientOptions.clientId), { body: commands });
-        console.debug(`Successfully reloaded ${data.length} of ${commands.length} application (/) commands.`);
+        return slashCommand.toJSON();
     }
 }

package/dist/services/TranslationManager.d.ts

@@ -31,4 +31,5 @@ export declare class TranslationManager {
      */
     registerTranslationsFromFolder(folderPath: string, baseKey?: string, watch?: boolean): Promise<void>;
     watchTranslationFolder(folderPath: string, baseKey: string): void;
+    getShortHandMethod(keyPrefix: string, language?: string): (key: string, params?: any, lang?: string) => string;
 }

package/dist/services/TranslationManager.js

@@ -119,4 +119,16 @@ export class TranslationManager {
         // TODO: Handle file removal
         //.on('unlink', function(path) {console.log('File', path, 'has been removed');})
     }
+    getShortHandMethod(keyPrefix, language) {
+        return (key, params, lang) => {
+            if (key.startsWith('$')) {
+                return this.get(key.replace('$', ''), lang || language, params);
+            }
+            else {
+                if (!keyPrefix.endsWith('.'))
+                    keyPrefix += '.';
+                return this.get(keyPrefix + key, lang || language, params);
+            }
+        };
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zumito-framework",
-  "version": "1.2.17",
+  "version": "1.2.18",
   "description": "Discord.js bot framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -33,6 +33,7 @@
     "express": "^4.18.1",
     "leven": "^4.0.0",
     "mongoose": "^6.6.5",
+    "source-fragment": "^1.1.0",
     "tingodb": "^0.6.1",
     "tseep": "^1.2.2",
     "zumito-db": "^1.0.0"
@@ -54,6 +55,10 @@
     ".": "./dist/index.js",
     "./discord": "./dist/discord/index.js"
   },
+  "_moduleAliases": {
+    "@definitions": "definitions",
+    "@services": "services"
+  },
   "typesVersions": {
     "*": {
       ".": [