djskage/dist/index.js

A Discord.js extension for utility commands

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Timestamp = exports.Systeminfo = exports.Logger = exports.DjskageError = void 0;
const discord_js_1 = require("discord.js");
const fs = __importStar(require("fs"));
const path = __importStar(require("path"));
const readline = __importStar(require("readline"));
const logger_1 = __importDefault(require("./utils/logger"));
function createExternalLogger() {
    logger_1.default.setDebugOptions({
        enabled: true,
        level: ["verbose", "error", "warn", "log", "fatal"],
    });
    return logger_1.default;
}
const ExternalLogger = createExternalLogger();
exports.Logger = ExternalLogger;
class DjskageError extends Error {
    constructor(error, code, message) {
        super(message);
        this.error = error;
        this.code = code;
        this.message = message;
    }
}
exports.DjskageError = DjskageError;
const rl = readline.createInterface({
    //@ts-ignore
    input: process.stdin,
    output: process.stdout,
});
class Djskage {
    constructor() {
        this.client = null;
        this.commands = new Map();
        this.tCh = undefined;
        this.client = null;
        this.options = {
            prefix: ">",
            aliases: ["djskage", "djk"],
            customisation: {
                embedColor: "#2b2d31",
            },
            debug: {
                enabled: false,
            },
            disabled: [],
            permissions: [],
            track: {
                enabled: false,
            },
        };
        this.defInt = null;
        if (fs.existsSync("djskage.json")) {
            const fileData = fs.readFileSync("djskage.json", "utf-8");
            const loadedOptions = JSON.parse(fileData);
            this.options = {
                ...this.options,
                ...loadedOptions,
            };
        }
        logger_1.default.setDebugOptions(this.options.debug || { enabled: false });
        logger_1.default.ready("Djskage Options found, loading...", "Djskage Startup");
    }
    async initialize(client) {
        if (!(client instanceof discord_js_1.Client)) {
            logger_1.default.fatal(`Provided client is not an instance of "discord.js".Client\nUsing this client might result in errors or broken commands.`, "Djskage Startup");
        }
        this.client = client;
        const tch = this.options.track?.enabled
            ? await client.channels.fetch(this.options.track?.channel || "")
            : undefined;
        if (tch && tch.isTextBased() && tch.isSendable()) {
            this.tCh = tch;
            logger_1.default.log(`Tracking channel set to #${"name" in tch ? tch.name : tch.id}`, "Djskage Startup");
        }
        logger_1.default.log("Loading commands...", "Djskage Startup");
        const commandsDir = path.join(__dirname, "commands");
        const commandFiles = fs.readdirSync(commandsDir);
        for (const file of commandFiles) {
            if (!file.endsWith(".js"))
                continue;
            const commandPath = path.join(commandsDir, file);
            const command = require(commandPath);
            if (command) {
                if (command?.name && typeof command.execute === "function") {
                    if (this.options.disabled?.includes(command.name))
                        continue;
                    this.commands.set(command.name, command);
                    if (command.aliases && Array.isArray(command.aliases)) {
                        command.aliases.forEach((alias) => {
                            this.commands.set(alias, command);
                        });
                    }
                }
                logger_1.default.verbose(`Loaded command: ${command.name}`, "Djskage Startup");
            }
        }
        await client.application?.fetch();
        const ownerId = client.application?.owner?.id;
        logger_1.default.log("Initiating client events...", "Djskage Startup");
        this.client.on(discord_js_1.Events.MessageCreate, (message) => {
            if (message.author.bot)
                return;
            if (!(this.options.permissions?.includes(message.author.id) ||
                message.author.id === ownerId))
                return;
            let matchedPrefix = null;
            for (const alias of this.options.aliases || []) {
                const fullPrefix = `${this.options.prefix}${alias}`;
                if (message.content.startsWith(fullPrefix)) {
                    matchedPrefix = fullPrefix;
                    break;
                }
            }
            if (!matchedPrefix)
                return;
            this.handleCommand(matchedPrefix, message);
        });
    }
    async handleCommand(matchedPrefix, message) {
        message = await (await this.client?.channels.fetch(message.channel.id))?.messages.fetch(message.id); // Re-fetching the message to ensure acurate data
        const ownerId = this.client?.application?.owner?.id;
        if (!(this.options.permissions?.includes(message.author.id) ||
            message.author.id === ownerId))
            return;
        if (!message)
            return;
        if (typeof matchedPrefix !== "string")
            return;
        const args = message.content
            .slice((matchedPrefix ?? "").length)
            .trim()
            .split(/ +/);
        if (!args)
            return;
        if (args.length === 0)
            return;
        const commandName = args.shift()?.toLowerCase();
        if (!commandName)
            return;
        if (this.options.disabled?.includes(commandName))
            return;
        const command = this.commands.get(commandName);
        if (!command)
            return;
        if (this.client) {
            if (this.tCh && this.tCh?.isTextBased() && this.tCh?.isSendable()) {
                this.tCh.send({
                    content: `${message.author} \`${message.author.id}\` used command: ${command.name}\n\`${message.content.length > 1500
                        ? message.content.slice(0, 1500) + "..."
                        : message.content}\``,
                    allowedMentions: { users: [] },
                });
            }
            try {
                await command.execute(this, this.client, message, args);
            }
            catch (err) {
                logger_1.default.error(`Error in command "${command.name}": ${err}`, err, "Djskage Command Execution");
                message.reply("❌ Something went wrong in that command.");
            }
        }
        else
            return;
    }
    getCommands() {
        return Array.from(new Set(this.commands.values()));
    }
    getPrefix() {
        return this.options.prefix || ">";
    }
    getOptions() {
        return this.options;
    }
    static async hook(client, options) {
        const djskage = new Djskage();
        if (options) {
            djskage.options = Djskage.deepMergeOptions(djskage.options, options);
            logger_1.default.setDebugOptions(djskage.options.debug || { enabled: false });
        }
        logger_1.default.log("Loading DjsKage...", "Djskage Startup");
        await djskage.initialize(client);
        logger_1.default.ready("DjsKage successfully loaded", "Djskage Startup");
        const hiddenProps = ["getCommands", "getPrefix", "getOptions"];
        return new Proxy(djskage, {
            get(target, prop) {
                if (hiddenProps.includes(prop)) {
                    return undefined;
                }
                return target[prop];
            },
        });
    }
    static deepMergeOptions(defaults, provided) {
        if (!provided)
            return defaults;
        return {
            prefix: provided.prefix || defaults.prefix,
            aliases: provided.aliases || defaults.aliases,
            customisation: {
                embedColor: provided.customisation?.embedColor ||
                    defaults.customisation?.embedColor ||
                    "#2b2d31",
            },
            debug: provided.debug || defaults.debug,
            disabled: provided.disabled || defaults.disabled,
            permissions: provided.permissions || defaults.permissions,
            track: provided.track
                ? {
                    enabled: provided.track.enabled,
                    channel: provided.track.channel || defaults.track?.channel,
                }
                : defaults.track,
        };
    }
}
const system_1 = require("./utils/system");
Object.defineProperty(exports, "Systeminfo", { enumerable: true, get: function () { return system_1.Systeminfo; } });
const time_1 = require("./utils/time");
Object.defineProperty(exports, "Timestamp", { enumerable: true, get: function () { return time_1.Timestamp; } });
exports.default = Djskage;
if (typeof module !== "undefined") {
    module.exports = Djskage;
    module.exports.default = Djskage;
    module.exports.Logger = ExternalLogger;
    module.exports.Systeminfo = system_1.Systeminfo;
    module.exports.Timestamp = time_1.Timestamp;
}