zumito-framework 1.1.70 → 1.1.72-dev-update-pull-request-ci.0

package/dist/{baseModule/events/discord/messageCreate.d.ts → modules/core/baseModule/events/discord/MessageCreate.d.ts}

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

package/dist/{baseModule/events/discord/messageCreate.js → modules/core/baseModule/events/discord/MessageCreate.js}

@@ -1,23 +1,23 @@
-import * as url from 'url';
 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 { FrameworkEvent } from '../../../../../definitions/FrameworkEvent.js';
+import { ZumitoFramework } from '../../../../../ZumitoFramework.js';
 import leven from 'leven';
 import path from 'path';
+import { InteractionIdGenerator } from '../../../../../services/InteractionIdGenerator.js';
 export class MessageCreate extends FrameworkEvent {
     once = false;
-    async execute({ message, client, framework }) {
+    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());
+            if (!framework.commands.getAll().has(command)) {
+                const commandNames = Array.from(framework.commands.getAll().keys());
                 const correctedCommand = this.autocorrect(command, commandNames);
-                if (framework.commands.has(correctedCommand)) {
+                if (framework.commands.getAll().has(correctedCommand)) {
                     commandInstance = framework.commands.get(correctedCommand);
                 }
                 else {
@@ -71,7 +71,6 @@ export class MessageCreate extends FrameworkEvent {
             try {
                 const guildSettings = await framework.getGuildSettings(message.guildId);
                 const parsedArgs = new Map();
-                const userMentionCount = 0;
                 for (let i = 0; i < args.length; i++) {
                     const arg = args[i];
                     const type = commandInstance.args[i]?.type;
@@ -100,6 +99,7 @@ export class MessageCreate extends FrameworkEvent {
                         }
                     }
                 }
+                const interactionIdGenerator = new InteractionIdGenerator(undefined, commandInstance.name);
                 await commandInstance.execute({
                     message,
                     args: parsedArgs,
@@ -122,7 +122,6 @@ export class MessageCreate extends FrameworkEvent {
                         message.delete().catch(function () {
                             console.error("can't delete user command");
                         });
-                        const metadata = await fetch('https://tulipo.ga/api/last_command/' + command).then((res) => res.json());
                     }
                     catch (err) {
                         console.error(err.name, err.message);
@@ -214,7 +213,6 @@ export class MessageCreate extends FrameworkEvent {
         const 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));
         const path1 = path.resolve('./');
         const path2 = path1.replaceAll('\\', '/');
         stackFrames.forEach((frame) => {

package/dist/{baseModule → modules/core/baseModule}/models/Guild.d.ts

@@ -1,4 +1,4 @@
-import { DatabaseModel } from '../../types/DatabaseModel.js';
+import { DatabaseModel } from '../../../../definitions/DatabaseModel.js';
 export declare class Guild extends DatabaseModel {
     getModel(schema: any): {
         guild_id: {

package/dist/{baseModule → modules/core/baseModule}/models/Guild.js

@@ -1,4 +1,4 @@
-import { DatabaseModel } from '../../types/DatabaseModel.js';
+import { DatabaseModel } from '../../../../definitions/DatabaseModel.js';
 export class Guild extends DatabaseModel {
     getModel(schema) {
         return {

package/dist/services/CommandManager.d.ts

@@ -0,0 +1,40 @@
+import { ZumitoFramework } from "../ZumitoFramework";
+import { Command } from "../definitions/commands/Command.js";
+export declare class CommandManager {
+    protected commands: Map<string, Command>;
+    protected framework: ZumitoFramework;
+    constructor(framework: any);
+    set(name: string, command: Command): void;
+    get(name: string): Command;
+    getAll(): Map<string, Command>;
+    /**
+     * @deprecated
+     */
+    get size(): number;
+    /**
+     * Load command from file
+     * @async
+     * @public
+     * @param filePath - Absolute path to command file
+     * @returns {Promise<Command>}
+     */
+    loadCommandFile(filePath: string): Promise<any>;
+    /**
+     * Load all command files from a folder
+     * @async
+     * @public
+     * @param folderPath - Absolute path to commands folder
+     * @returns {Promise<Map<string, Command>>}
+     */
+    loadCommandsFolder(folderPath: string): Promise<Map<string, any>>;
+    /**
+     * Watch command files on a folder.
+     * It loads command when new file is created, update command when file is modified and deletes command when file is deleted.
+     * @async
+     * @public
+     * @param folderPath - Absolute path to commands folder
+     * @returns {Promise<Map<string, Command>>}
+     */
+    watchCommandsFolder(folderPath: string): void;
+    refreshSlashCommands(): Promise<void>;
+}

package/dist/services/CommandManager.js

@@ -0,0 +1,160 @@
+import chalk from "chalk";
+import * as chokidar from 'chokidar';
+import path from "path";
+import boxen from "boxen";
+import fs from 'fs';
+import { REST, Routes, SlashCommandBuilder } from "discord.js";
+import { CommandType } from "../definitions/commands/CommandType.js";
+export class CommandManager {
+    commands;
+    framework;
+    constructor(framework) {
+        this.commands = new Map;
+        this.framework = framework;
+    }
+    set(name, command) {
+        this.commands.set(name, command);
+    }
+    get(name) {
+        return this.commands.get(name);
+    }
+    getAll() {
+        return this.commands;
+    }
+    /**
+     * @deprecated
+     */
+    get size() {
+        return this.commands.size;
+    }
+    /**
+     * Load command from file
+     * @async
+     * @public
+     * @param filePath - Absolute path to command file
+     * @returns {Promise<Command>}
+     */
+    async loadCommandFile(filePath) {
+        // Validate file has .ts or .js extension
+        if (!filePath.endsWith('.js') && !filePath.endsWith('.ts')) {
+            throw new Error("File must be a .ts or .js");
+        }
+        // import file
+        let command = await import('file://' + filePath + '?update=' + Date.now().toString()).catch(e => {
+            console.error('[🆕🔴 ] Error loading command ' + chalk.blue(filePath.toString().replace(/^.*[\\\/]/, '').split('.').slice(0, -1).join('.')));
+            console.log(e + '\n' + e.name + '\n' + e.stack);
+        });
+        command = Object.values(command)[0];
+        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');
+        return command;
+    }
+    /**
+     * Load all command files from a folder
+     * @async
+     * @public
+     * @param folderPath - Absolute path to commands folder
+     * @returns {Promise<Map<string, Command>>}
+     */
+    async loadCommandsFolder(folderPath) {
+        const files = fs.readdirSync(folderPath);
+        for (const file of files) {
+            if (file.endsWith('d.ts'))
+                continue;
+            if (file.endsWith('.js') || file.endsWith('.ts')) {
+                const command = await this.loadCommandFile(path.join(folderPath, file));
+                this.commands.set(command.constructor.name.toLowerCase(), command);
+            }
+        }
+        return this.commands;
+    }
+    /**
+     * Watch command files on a folder.
+     * It loads command when new file is created, update command when file is modified and deletes command when file is deleted.
+     * @async
+     * @public
+     * @param folderPath - Absolute path to commands folder
+     * @returns {Promise<Map<string, Command>>}
+     */
+    watchCommandsFolder(folderPath) {
+        chokidar
+            .watch(path.resolve(folderPath), {
+            ignored: /^\./,
+            persistent: true,
+            ignoreInitial: true,
+        })
+            .on('add', (filePath) => {
+            this.loadCommandFile(filePath);
+        })
+            .on('change', (filePath) => {
+            this.loadCommandFile(filePath);
+        })
+            .on('error', (error) => {
+            console.error('[🔄🔴 ] Error reloading command');
+            console.log(boxen(error + '\n' + error.stack, { padding: 1 }));
+        });
+        // TODO: Handle file removal
+        //.on('unlink', function(path) {console.log('File', path, 'has been removed');})
+    }
+    async refreshSlashCommands() {
+        const rest = new REST({ version: '10' }).setToken(this.framework.settings.discordClientOptions.token);
+        const commands = Array.from(this.commands.values())
+            .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,
+                                });
+                            });
+                        }
+                        return option;
+                    });
+                });
+            }
+            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.`);
+    }
+}

package/dist/services/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/services/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/services/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/services/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/dist/services/ModuleManager.d.ts

@@ -0,0 +1,17 @@
+import { ZumitoFramework } from "../ZumitoFramework.js";
+import { Module } from "../definitions/Module.js";
+export declare class ModuleManager {
+    protected modules: Map<string, Module>;
+    protected framework: ZumitoFramework;
+    constructor(framework: ZumitoFramework);
+    set(name: string, module: Module): void;
+    get(name: string): Module;
+    getAll(): Map<string, Module>;
+    /**
+     * @deprecated
+     */
+    get size(): number;
+    loadModuleFile(folderPath: string): Promise<unknown>;
+    registerModule(module: InstanceType<typeof Module>): void;
+    instanceModule(module: any, rootPath: string, name?: string): Promise<Module>;
+}

package/dist/services/ModuleManager.js

@@ -0,0 +1,78 @@
+import { Module } from "../definitions/Module.js";
+import fs from 'fs';
+import path from 'path';
+export class ModuleManager {
+    modules;
+    framework;
+    constructor(framework) {
+        this.modules = new Map();
+        this.framework = framework;
+    }
+    set(name, module) {
+        this.modules.set(name, module);
+    }
+    get(name) {
+        return this.modules.get(name);
+    }
+    getAll() {
+        return this.modules;
+    }
+    /**
+     * @deprecated
+     */
+    get size() {
+        return this.modules.size;
+    }
+    async loadModuleFile(folderPath) {
+        let file;
+        if (fs.existsSync(path.join(folderPath, 'index.js'))) {
+            file = path.join(folderPath, 'index.js');
+        }
+        else if (fs.existsSync(path.join(folderPath, 'index.ts'))) {
+            file = path.join(folderPath, 'index.ts');
+        }
+        else {
+            return Module;
+        }
+        const module = await import('file://' + file);
+        return Object.values(module)[0];
+    }
+    registerModule(module) {
+        // Register module commands
+        if (module.getCommands()) {
+            module.getCommands().forEach((command) => {
+                this.framework.commands.set(command.name, command);
+            });
+        }
+        // Register module events
+        this.framework.events = new Map([...this.framework.events, ...module.getEvents()]);
+        // Register models
+        module.getModels().forEach((model) => {
+            this.framework.models.push(model);
+        });
+        /*
+
+        // Register module routes
+        this.routes = new Map([...this.routes, ...moduleInstance.getRoutes()]);
+
+        */
+    }
+    async instanceModule(module, rootPath, name) {
+        let moduleInstance;
+        if (module.constructor) {
+            try {
+                moduleInstance = new module(rootPath, this.framework);
+                await moduleInstance.initialize();
+                this.modules.set(name || moduleInstance.constructor.name, moduleInstance);
+            }
+            catch (err) {
+                console.error(`[📦🔴] Error loading module ${name || moduleInstance?.constructor?.name}: ${err.message}`);
+                console.error(err.stack);
+            }
+        }
+        else {
+            //moduleInstance = new Module();
+        }
+        return moduleInstance;
+    }
+}

package/dist/{managers → services}/StatusManager.d.ts

@@ -1,5 +1,5 @@
 import { PresenceData } from "discord.js";
-import { StatusManagerOptions } from "../types/StatusManagerOptions";
+import { StatusManagerOptions } from "../definitions/StatusManagerOptions";
 import { ZumitoFramework } from "../ZumitoFramework";
 export declare class StatusManager {
     /**

package/dist/services/TranslationManager.d.ts

@@ -0,0 +1,34 @@
+import { Translation } from '../definitions/Translation.js';
+export declare class TranslationManager {
+    private translations;
+    private defaultLanguage;
+    private languages;
+    get(key: string, language?: string, params?: unknown): string;
+    set(key: string, language: string, text: string): void;
+    has(key: string): boolean;
+    getAll(): Map<string, Translation>;
+    setAll(translations: Map<string, Translation>): void;
+    getDefaultLanguage(): string;
+    setDefaultLanguage(language: string): void;
+    getLanguages(): string[];
+    importTranslationsJson(path: string, lang: string, json: object | string): void;
+    /**
+     * Returns content of translation json file
+     * @async
+     * @public
+     * @param filePath - Absolute path to translations file
+     * @returns {Promise<any>}
+     */
+    loadTranslationFile(filePath: string): Promise<object>;
+    /**
+     * load translation files from folder and subfolders
+     * @async
+     * @public
+     * @param folderPath - Absolute path to translations files folder
+     * @param [baseKey=''] - (Optional) the translation key to start from. All translations loaded will be children translations of that key
+     * @param watch - Watch folder for file modifications
+     * @returns {Promise<void>}
+     */
+    registerTranslationsFromFolder(folderPath: string, baseKey?: string, watch?: boolean): Promise<void>;
+    watchTranslationFolder(folderPath: string, baseKey: string): void;
+}

package/dist/services/TranslationManager.js

@@ -0,0 +1,122 @@
+import { Translation } from '../definitions/Translation.js';
+import fs from 'fs';
+import path from 'path';
+import * as chokidar from 'chokidar';
+import boxen from 'boxen';
+import chalk from "chalk";
+export class TranslationManager {
+    translations = new Map();
+    defaultLanguage = 'en';
+    languages = [];
+    get(key, 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)) {
+            this.translations.set(key, new Translation());
+        }
+        this.translations.get(key).set(language, text);
+        if (!this.languages.includes(language))
+            this.languages.push(language);
+    }
+    has(key) {
+        return this.translations.has(key);
+    }
+    getAll() {
+        return this.translations;
+    }
+    setAll(translations) {
+        this.translations = translations;
+    }
+    getDefaultLanguage() {
+        return this.defaultLanguage;
+    }
+    setDefaultLanguage(language) {
+        this.defaultLanguage = language;
+    }
+    getLanguages() {
+        return this.languages;
+    }
+    importTranslationsJson(path, lang, json) {
+        if (typeof json === 'object') {
+            for (const key in json) {
+                this.importTranslationsJson(path + key + '.', lang, json[key]);
+            }
+        }
+        else {
+            this.set(path.slice(0, -1), lang, json);
+        }
+    }
+    /**
+     * Returns content of translation json file
+     * @async
+     * @public
+     * @param filePath - Absolute path to translations file
+     * @returns {Promise<any>}
+     */
+    async loadTranslationFile(filePath) {
+        const json = fs.readFileSync(filePath);
+        return JSON.parse(json);
+    }
+    /**
+     * load translation files from folder and subfolders
+     * @async
+     * @public
+     * @param folderPath - Absolute path to translations files folder
+     * @param [baseKey=''] - (Optional) the translation key to start from. All translations loaded will be children translations of that key
+     * @param watch - Watch folder for file modifications
+     * @returns {Promise<void>}
+     */
+    async registerTranslationsFromFolder(folderPath, baseKey = '', watch = false) {
+        if (!fs.existsSync(path.join(folderPath)))
+            return;
+        const files = fs.readdirSync(folderPath);
+        for (const file of files) {
+            if (file.endsWith('.json')) {
+                const json = await this.loadTranslationFile(path.join(folderPath, file));
+                const lang = file.slice(0, -5);
+                this.importTranslationsJson(baseKey, lang, json);
+            }
+            else if (fs
+                .lstatSync(path.join(folderPath, file))
+                .isDirectory()) {
+                const key = baseKey + path.basename(path.join(folderPath, file)) + '.';
+                await this.registerTranslationsFromFolder(path.join(folderPath, file), key, watch);
+            }
+        }
+        if (watch) {
+            this.watchTranslationFolder(folderPath, baseKey);
+        }
+    }
+    watchTranslationFolder(folderPath, baseKey) {
+        chokidar
+            .watch(path.resolve(folderPath), {
+            ignored: /^\./,
+            persistent: true,
+            ignoreInitial: true,
+        })
+            .on('add', async (filePath) => {
+            const json = await this.loadTranslationFile(filePath);
+            const lang = filePath.replace(/^.*[\\/]/, '').slice(0, -5);
+            this.importTranslationsJson(baseKey, lang, json);
+            console.debug('[🆕🟢 ] Translations file ' + chalk.blue(filePath) + ' loaded');
+        })
+            .on('change', async (filePath) => {
+            const json = await this.loadTranslationFile(filePath);
+            const lang = filePath.replace(/^.*[\\/]/, '').slice(0, -5);
+            this.importTranslationsJson(baseKey, lang, json);
+            console.debug('[🆕🟢 ] Translations file ' + chalk.blue(filePath) + ' loaded');
+        })
+            .on('error', (error) => {
+            console.error('[🔄🔴 ] Error reloading translation file');
+            console.log(boxen(error + '\n' + error.stack, { padding: 1 }));
+        });
+        // TODO: Handle file removal
+        //.on('unlink', function(path) {console.log('File', path, 'has been removed');})
+    }
+}