zumito-framework 1.1.81 → 1.1.83

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/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,123 @@
+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);
+                console.debug('[🆕🟢 ] Translations file ' + chalk.blue(path.join(folderPath, file)) + ' loaded');
+            }
+            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');})
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zumito-framework",
-  "version": "1.1.81",
+  "version": "1.1.83",
   "description": "Discord.js bot framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -29,7 +29,7 @@
     "chokidar": "^3.5.3",
     "cookie-parser": "^1.4.6",
     "cors": "^2.8.5",
-    "discord.js": "^14.14.1",
+    "discord.js": "^14.9.0",
     "error-stack-parser": "^2.1.4",
     "express": "^4.18.1",
     "leven": "^4.0.0",
@@ -46,8 +46,8 @@
     "eslint-plugin-check-file": "^2.2.0",
     "eslint-plugin-prettier": "^4.2.1",
     "prettier": "^2.8.3",
-    "typedoc": "^0.25.4",
-    "typescript": "^5.3.3"
+    "typedoc": "^0.23.14",
+    "typescript": "^4.8.3"
   },
   "type": "module",
   "exports": {

package/dist/TranslationManager.d.ts

@@ -1,15 +0,0 @@
-import { Translation } from './types/Translation.js';
-export declare class TranslationManager {
-    private translations;
-    private defaultLanguage;
-    private languages;
-    constructor();
-    get(key: string, language?: string, params?: any): 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[];
-}

package/dist/TranslationManager.js

@@ -1,41 +0,0 @@
-import { Translation } from './types/Translation.js';
-export class TranslationManager {
-    translations = new Map();
-    defaultLanguage = 'en';
-    languages = [];
-    constructor() { }
-    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;
-    }
-}

package/dist/baseModule/index.d.ts

@@ -1,7 +0,0 @@
-import { Module } from '../types/Module.js';
-import { ZumitoFramework } from '../ZumitoFramework.js';
-export declare class baseModule extends Module {
-    constructor(modulePath: string, framework: ZumitoFramework);
-    registerEvents(): Promise<any>;
-    registerModels(): Promise<void>;
-}

package/dist/baseModule/index.js

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