zumito-framework 1.1.55 → 1.1.57

package/dist/types/Module.js

@@ -1,9 +1,9 @@
 import * as chokidar from 'chokidar';
 import chalk from 'chalk';
-import boxen from "boxen";
+import boxen from 'boxen';
 import * as fs from 'fs';
 import path from 'path';
-import { ButtonInteraction, CommandInteraction, SelectMenuInteraction } from "discord.js";
+import { ButtonInteraction, CommandInteraction, SelectMenuInteraction, } from 'discord.js';
 export class Module {
     path;
     framework;
@@ -24,10 +24,10 @@ export class Module {
     }
     async registerCommands() {
         if (fs.existsSync(path.join(this.path, 'commands'))) {
-            let files = fs.readdirSync(path.join(this.path, 'commands'));
-            for (let file of files) {
+            const files = fs.readdirSync(path.join(this.path, 'commands'));
+            for (const file of files) {
                 if (file.endsWith('.js') || file.endsWith('.ts')) {
-                    let command = await import('file://' + path.join(this.path, 'commands', file)).catch(e => {
+                    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);
                     });
@@ -36,7 +36,6 @@ export class Module {
                     this.commands.set(command.constructor.name.toLowerCase(), command);
                 }
             }
-            ;
             // register watcher
             if (process.env.DEBUG) {
                 /*
@@ -44,7 +43,12 @@ export class Module {
                     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 })
+                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');})
@@ -54,26 +58,48 @@ export class Module {
     }
     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('.')));
+            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');
+            console.debug('[🆕🟢 ] Command ' +
+                chalk.blue(filePath
+                    .replace(/^.*[\\\/]/, '')
+                    .split('.')
+                    .slice(0, -1)
+                    .join('.')) +
+                ' loaded');
         }
     }
     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('.')));
+            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');
+            console.debug('[🔄🟢 ] Command ' +
+                chalk.blue(filePath
+                    .replace(/^.*[\\\/]/, '')
+                    .split('.')
+                    .slice(0, -1)
+                    .join('.')) +
+                ' reloaded');
         }
     }
     onErrorLoadingCommand(error) {
@@ -86,15 +112,19 @@ export class Module {
     async registerEvents() {
         if (!fs.existsSync(path.join(this.path, 'events')))
             return;
-        let files = fs.readdirSync(path.join(this.path, 'events'));
-        for (let file of files) {
+        const files = fs.readdirSync(path.join(this.path, 'events'));
+        for (const file of files) {
             if (file == 'discord') {
-                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)).catch(e => {
+                const moduleFileNames = fs.readdirSync(path.join(this.path, 'events', 'discord'));
+                for (const moduleFileName of moduleFileNames) {
+                    if (moduleFileName.endsWith('.js') ||
+                        moduleFileName.endsWith('.ts')) {
+                        let event = await import('file://' +
+                            path.join(this.path, 'events', 'discord', moduleFileName)).catch((e) => {
                             console.error(`[🔄🔴 ] Error loading ${moduleFileName.slice(0, -3)} event on module ${this.constructor.name}`);
-                            console.log(boxen(e + '\n' + e.name + '\n' + e.stack, { padding: 1 }));
+                            console.log(boxen(e + '\n' + e.name + '\n' + e.stack, {
+                                padding: 1,
+                            }));
                         });
                         event = Object.values(event)[0];
                         event = new event();
@@ -108,7 +138,8 @@ export class Module {
     registerDiscordEvent(frameworkEvent) {
         if (frameworkEvent.disabled)
             return;
-        const eventName = frameworkEvent.constructor.name.charAt(0).toLowerCase() + frameworkEvent.constructor.name.slice(1);
+        const eventName = frameworkEvent.constructor.name.charAt(0).toLowerCase() +
+            frameworkEvent.constructor.name.slice(1);
         const emitter = this.framework.client;
         const once = frameworkEvent.once; // A simple variable which returns if the event should run once
         // Try catch block to throw an error if the code in try{} doesn't work
@@ -121,14 +152,16 @@ export class Module {
         }
     }
     parseEventArgs(args) {
-        let finalArgs = {
+        const finalArgs = {
             framework: this.framework,
             client: this.framework.client,
         };
-        args.forEach(arg => {
+        args.forEach((arg) => {
             finalArgs[arg.constructor.name.toLowerCase()] = arg;
         });
-        let interaction = args.find((arg) => arg instanceof SelectMenuInteraction || arg instanceof CommandInteraction || arg instanceof ButtonInteraction);
+        const interaction = args.find((arg) => arg instanceof SelectMenuInteraction ||
+            arg instanceof CommandInteraction ||
+            arg instanceof ButtonInteraction);
         if (interaction) {
             finalArgs['interaction'] = interaction;
         }
@@ -140,15 +173,19 @@ export class Module {
     async registerTranslations(subpath = '') {
         if (!fs.existsSync(path.join(this.path, 'translations', subpath)))
             return;
-        let files = fs.readdirSync(path.join(this.path, 'translations', subpath));
-        for (let file of files) {
+        const files = fs.readdirSync(path.join(this.path, 'translations', subpath));
+        for (const file of files) {
             if (file.endsWith('.json')) {
-                let json = await this.loadTranslationFile(subpath, file);
-                let lang = file.slice(0, -5);
-                let baseKey = subpath ? subpath.replaceAll('/', '.').replaceAll('\\', '.') + '.' : '';
+                const json = await this.loadTranslationFile(subpath, file);
+                const lang = file.slice(0, -5);
+                const baseKey = subpath
+                    ? subpath.replaceAll('/', '.').replaceAll('\\', '.') + '.'
+                    : '';
                 this.parseTranslation(baseKey, lang, json);
             }
-            else if (fs.lstatSync(path.join(this.path, 'translations', subpath, file)).isDirectory()) {
+            else if (fs
+                .lstatSync(path.join(this.path, 'translations', subpath, file))
+                .isDirectory()) {
                 await this.registerTranslations(path.join(subpath, file));
             }
         }
@@ -156,11 +193,11 @@ export class Module {
     async loadTranslationFile(subpath, file) {
         if (subpath)
             subpath = subpath + '/';
-        let json = await import('file://' + `${this.path}/translations/${subpath}${file}`, {
+        const json = await import('file://' + `${this.path}/translations/${subpath}${file}`, {
             assert: {
-                type: "json",
+                type: 'json',
             },
-        }).catch(e => {
+        }).catch((e) => {
             console.error(`[🔄🔴 ] Error loading ${file.slice(0, -5)} translations on module ${this.constructor.name}`);
             console.error(e + '\n' + e.name + '\n' + e.stack);
         });
@@ -168,7 +205,7 @@ export class Module {
     }
     parseTranslation(path, lang, json) {
         if (typeof json === 'object') {
-            for (let key in json) {
+            for (const key in json) {
                 this.parseTranslation(path + key + '.', lang, json[key]);
             }
         }
@@ -179,15 +216,16 @@ export class Module {
     async registerModels() {
         if (!fs.existsSync(path.join(this.path, 'models')))
             return;
-        let files = fs.readdirSync(path.join(this.path, 'models'));
-        for (let file of files) {
+        const files = fs.readdirSync(path.join(this.path, 'models'));
+        for (const file of files) {
             if (file.endsWith('.json')) {
-                let modelName = file.slice(0, -5).charAt(0).toUpperCase() + file.slice(0, -5).slice(1);
-                let modelDefiniton = await import('file://' + `${this.path}/models/${file}`, {
+                const modelName = file.slice(0, -5).charAt(0).toUpperCase() +
+                    file.slice(0, -5).slice(1);
+                const modelDefiniton = await import('file://' + `${this.path}/models/${file}`, {
                     assert: {
-                        type: "json",
+                        type: 'json',
                     },
-                }).catch(e => {
+                }).catch((e) => {
                     console.error(`[🔄🔴 ] Error loading model ${modelName} on module ${this.constructor.name}`);
                     console.error(e, e.name, e.stack);
                 });

package/dist/types/SelectMenuParameters.d.ts

@@ -1,5 +1,5 @@
-import { Client, SelectMenuInteraction } from "discord.js";
-import { ZumitoFramework } from "../ZumitoFramework.js";
+import { Client, SelectMenuInteraction } from 'discord.js';
+import { ZumitoFramework } from '../ZumitoFramework.js';
 export interface SelectMenuParameters {
     path: string[];
     interaction: SelectMenuInteraction;

package/dist/types/Translation.js

@@ -10,7 +10,7 @@ export class Translation {
             text = this.text.get('en');
         }
         if (params) {
-            Object.keys(params).forEach(key => {
+            Object.keys(params).forEach((key) => {
                 text = text.replace(`{${key}}`, params[key]);
             });
         }

package/dist/utils/EmojiFallback.d.ts

@@ -1,4 +1,4 @@
-import { Client } from "discord.js";
+import { Client } from 'discord.js';
 export declare class EmojiFallback {
     static getEmoji(client: Client, emojiId: string, fallbackEmoji: any): any;
     static getEmojiByName(client: Client, emojiName: string, fallbackEmoji: any): any;

package/dist/utils/EmojiFallback.js

@@ -4,11 +4,11 @@ export class EmojiFallback {
         return emoji?.toString() || fallbackEmoji;
     }
     static getEmojiByName(client, emojiName, fallbackEmoji) {
-        const emoji = client.emojis.cache.find(emoji => emoji.name === emojiName);
+        const emoji = client.emojis.cache.find((emoji) => emoji.name === emojiName);
         return emoji?.toString() || fallbackEmoji;
     }
     static getEmojiByIdentifier(client, emojiId, fallbackEmoji) {
-        const emoji = client.emojis.cache.find(emoji => emoji.id === emojiId);
+        const emoji = client.emojis.cache.find((emoji) => emoji.id === emojiId);
         return emoji?.toString() || fallbackEmoji;
     }
 }

package/package.json

@@ -1,18 +1,13 @@
 {
   "name": "zumito-framework",
-  "version": "1.1.55",
+  "version": "1.1.57",
   "description": "Discord.js bot framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
     "/dist",
-    "/plopfile.js",
-    "/baseModule",
-    "/plop-templates"
+    "/baseModule"
   ],
-  "bin": {
-    "generate": "./templateGenerator.mjs"
-  },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "build": "tsc",
@@ -35,8 +30,7 @@
     "error-stack-parser": "^2.1.4",
     "express": "^4.18.1",
     "leven": "^4.0.0",
-    "mongoose": "^6.6.5",
-    "plop": "^3.1.1"
+    "mongoose": "^6.6.5"
   },
   "devDependencies": {
     "@types/node": "^18.7.16",

package/plop-templates/command.js.hbs

@@ -1,17 +0,0 @@
-import { Command, CommandParameters } from "zumito-framework";
-
-export class {{capitalize command}} extends Command {
-
-    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/plop-templates/translation.json.hbs

@@ -1,8 +0,0 @@
-{
-    "command": {
-
-    },
-    "global": {
-        
-    }
-}

package/plopfile.js

@@ -1,116 +0,0 @@
-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',
-        prompts: [
-            {
-                type: 'input',
-                name: 'module',
-                message: 'Name of the module',
-            },
-            {
-                type: 'input',
-                name: 'command',
-                message: 'Name of the command',
-            },
-        ],
-        actions: [
-            {
-                type: 'add',
-                path: 'src/modules/{{module}}/commands/{{command}}.js',
-                templateFile: 'plop-templates/command.js.hbs',
-            },
-        ],
-    });
-    plop.setGenerator('translation', {
-        description: 'This generate translation file for a module',
-        prompts: [
-            {
-                type: 'input',
-                name: 'module',
-                message: 'Name of the module',
-            },
-            {
-                type: 'choice',
-                name: 'language',
-                message: 'Language of the translations',
-                choices: [
-                    {
-                        name: 'English',
-                        value: 'en',
-                    },
-                    {
-                        name: 'Spanish',
-                        value: 'es',
-                    },
-                    {
-                        name: 'French',
-                        value: 'fr',
-                    },
-                    {
-                        name: 'German',
-                        value: 'de',
-                    },
-                    {
-                        name: 'Italian',
-                        value: 'it',
-                    },
-                    {
-                        name: 'Portuguese',
-                        value: 'pt',
-                    },
-                    {
-                        name: 'Russian',
-                        value: 'ru',
-                    },
-                    {
-                        name: 'Turkish',
-                        value: 'tr',
-                    },
-                    {
-                        name: 'Chinese',
-                        value: 'zh',
-                    },
-                    {
-                        name: 'Japanese',
-                        value: 'ja',
-                    },
-                    {
-                        name: 'Korean',
-                        value: 'ko',
-                    },
-                    {
-                        name: 'Polish',
-                        value: 'pl',
-                    },
-                    {
-                        name: 'Romanian',
-                        value: 'ro',
-                    },
-                    {
-                        name: 'Russian',
-                        value: 'ru',
-                    },
-                    {
-                        name: 'Ukrainian',
-                        value: 'uk',
-                    },
-                    {
-                        name: 'Vietnamese',
-                        value: 'vi',
-                    },
-                ],
-            },
-        ],
-        actions: [
-            {
-                type: 'add',
-                path: 'src/modules/{{module}}/translations/{{language}}.json',
-                templateFile: 'plop-templates/translation.json.hbs',
-            },
-        ],
-    });
-};

package/templateGenerator.mjs

@@ -1,26 +0,0 @@
-#!/usr/bin/env node --experimental-modules --no-warnings
-import path from "node:path";
-import minimist from "minimist";
-import { Plop, run } from "plop";
-
-const args = process.argv.slice(2);
-const argv = minimist(args);
-
-import { dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-Plop.prepare({
-  cwd: process.cwd(),
-  configPath: path.join(__dirname, 'plopfile.js'),
-  preload: argv.preload || [],
-  completion: argv.completion,
-  dest: process.cwd()
-}, env => Plop.execute(env, (env) => {
-  const options = {
-      ...env,
-      dest: process.cwd() // this will make the destination path to be based on the cwd when calling the wrapper
-  }
-  return run(options, undefined, true)
-}));