djs-builder 0.5.41 → 0.6.0

package/lib/discord/functions/anticrash.ts

@@ -1,60 +0,0 @@
-import { WebhookClient, EmbedBuilder } from 'discord.js';
-import { StarterOptions } from '../types/starter';
-
-let uncaughtExceptionThrown = false;
-let unhandledRejectionThrown = false;
-
-export async function AntiCrash(djs: any, options: StarterOptions) {
-    try {
-        if (!options.anticrash?.webhookURL) {
-            throw new Error('Please provide a valid webhook URL.');
-        }
-        const webhookClient = new WebhookClient({ url: options.anticrash.webhookURL });
-
-        process.on('uncaughtException', async (error: any) => {
-            if (!uncaughtExceptionThrown) {
-                uncaughtExceptionThrown = true;
-                console.error('Uncaught Exception:');
-                console.error('⚠️ Error:', error.message);
-                if (error.stack) {
-                    console.error('⚠️ Stack Trace:', error.stack);
-                    const filenameMatch = error.stack.match(/\((.*?):\d+:\d+\)/);
-                    const filename = filenameMatch ? filenameMatch[1] : 'Unknown File';
-
-                    const embed = new EmbedBuilder()
-                        .setTitle('🚨 Uncaught Exception')
-                        .setDescription(`> 📂 **File:** \`${filename}\`\n> 💥 **Error:** \`${error.message}\`\n> 🔍 **Stack Trace:**\n\`\`\`${await error.stack}\`\`\``)
-                        .setColor('#FF0000')
-                        .setTimestamp();
-
-                    webhookClient.send({ content: options.anticrash?.mention || '', embeds: [embed] });
-                }
-            }
-        });
-
-        process.on('unhandledRejection', async (reason: any, promise: any) => {
-            if (!unhandledRejectionThrown) {
-                unhandledRejectionThrown = true;
-                console.error('Unhandled Rejection:');
-                console.error('⚠️ Reason:', reason);
-                if (promise) {
-                    console.error('⚠️ Promise:', await promise);
-                }
-                
-                const stackTrace = reason?.stack || '';
-                const filenameMatch = stackTrace.match(/at\s+(.+):(\d+):(\d+)/);
-                const filename = filenameMatch ? filenameMatch[1] : 'Unknown File';
-                
-                const embed = new EmbedBuilder()
-                    .setTitle('🚨 Unhandled Rejection')
-                    .setDescription(`> 📂 **File:** \`${filename}\`\n> 💡 **Reason:** \`${reason}\`\n> 🔍 **Promise:**\n\`${await promise}\``)
-                    .setColor('#FF0000')
-                    .setTimestamp();
-                
-                webhookClient.send({ content: options.anticrash?.mention || '', embeds: [embed] });
-            }
-        });
-    } catch (error: any) {
-        console.error('An error occurred in AntiCrash function:', error.message);
-    }
-}

package/lib/discord/functions/devLogs.ts

@@ -1,128 +0,0 @@
-import { WebhookClient, EmbedBuilder } from 'discord.js';
-import * as fs from 'fs';
-import * as path from 'path';
-
-export async function devLogger(devLogger: any): Promise<void> {
-  const webhook = new WebhookClient({ url: devLogger.webhookURL });
-
-  const watchedExtensions = ['.js', '.json', '.txt', '.md', '.ts', '.tsx', '.jsx', '.html', '.css', '.py', '.verse'];
-
-  const MAX_DESCRIPTION_LENGTH = 2048;
-
-  const watchDirectory = (directory: string) => {
-    fs.readdir(directory, (err, files) => {
-      if (err) {
-        console.error('Error reading directory:', err);
-        return;
-      }
-
-      for (const file of files) {
-        const filePath = path.join(directory, file);
-        fs.stat(filePath, (err, stats) => {
-          if (err) {
-            console.error('Error getting file stats:', err);
-            return;
-          }
-
-          if (stats.isDirectory()) {
-            watchDirectory(filePath);
-          } else {
-            if (watchedExtensions.some(ext => file.endsWith(ext))) {
-              watchFile(filePath);
-            }
-          }
-        });
-      }
-    });
-  };
-
-  const watchFile = (filePath: string) => {
-    fs.watchFile(filePath, { interval: 500 }, (curr, prev) => {
-      if (curr.mtime !== prev.mtime) {
-        readFile(filePath);
-      }
-    });
-  };
-
-  const readFile = (filePath: string) => {
-    fs.readFile(filePath, 'utf-8', (err, data) => {
-      if (err) {
-        console.error('Error reading file:', err);
-        return;
-      }
-
-      const embeds = createEmbeds(filePath, data);
-      sendWebhooks(embeds);
-    });
-  };
-
-  const createEmbeds = (filePath: string, data: string) => {
-    const fileType = getFileType(filePath);
-    const formattedData = '```' + fileType + '\n' + data + '\n```';
-
-    const chunks = chunkString(formattedData, MAX_DESCRIPTION_LENGTH);
-    const embeds: EmbedBuilder[] = [];
-
-    for (const chunk of chunks) {
-      const chunkLines = chunk.split('\n');
-      const fileTypeLine = chunkLines[0];
-      const codeLines = chunkLines.slice(1, chunkLines.length - 1); // Exclude first and last lines (```javascript and ```)
-      const code = codeLines.join('\n');
-
-      const embed = new EmbedBuilder()
-        .setColor('#3498db')
-        .setTitle('File Changed')
-        .setDescription(`File: \`${filePath}\`\n\`\`\`${fileTypeLine.split('```')[1]}\n${code}\n\`\`\``)
-        .setTimestamp();
-
-      embeds.push(embed);
-    }
-
-    return embeds;
-  };
-
-  const sendWebhooks = (embeds: EmbedBuilder[]) => {
-    for (const embed of embeds) {
-      webhook.send({ content: devLogger.mention || '', embeds: [embed] })
-        .then()
-        .catch((error) => console.error('Error Dev Logger Message', error));
-    }
-  };
-
-  const getFileType = (filePath: string): string => {
-    const extension = path.extname(filePath);
-    switch (extension) {
-      case '.js':
-      case '.jsx':
-        return 'js';
-      case 'ts':
-      case 'tsx':
-        return 'ts';
-      case '.json':
-        return 'json';
-      case '.txt':
-      case '.md':
-        return 'plaintext';
-      case '.html':
-        return 'html';
-      case '.css':
-        return 'css';
-      case '.py':
-        return 'python';
-      case '.verse':
-        return 'verse';
-      default:
-        return 'unknown';
-    }
-  };
-
-  const chunkString = (str: string, length: number) => {
-    const chunks = [];
-    for (let i = 0; i < str.length; i += length) {
-      chunks.push(str.substring(i, i + length));
-    }
-    return chunks;
-  };
-
-  watchDirectory(devLogger.pathToWatch);
-}

package/lib/discord/functions/logger.ts

@@ -1,58 +0,0 @@
-const successEmoji = '✅';
-const errorEmoji = '❌';
-const infoEmoji = 'ℹ️';
-const warningEmoji = '⚠️';
-
-const green = '\x1b[32m'; 
-const red = '\x1b[31m';
-const cyan = '\x1b[36m';
-const reset = '\x1b[0m';
-const yellow = '\x1b[33m';
-
-function getTimestamp(): string {
-    const now = new Date();
-    const year = now.getFullYear();
-    const month = String(now.getMonth() + 1).padStart(2, '0');
-    const day = String(now.getDate()).padStart(2, '0');
-    const hours = String(now.getHours()).padStart(2, '0');
-    const minutes = String(now.getMinutes()).padStart(2, '0');
-    const seconds = String(now.getSeconds()).padStart(2, '0');
-    return `[${year}-${month}-${day} ${hours}:${minutes}:${seconds}]`;
-}
-
-function extractErrorLocation(stack: string): string {
-    const lines = stack.split('\n');
-    const locationLine = lines[1] || lines[0];
-    
-    const match = locationLine.match(/\((.*):(\d+):(\d+)\)/);
-    if (match) {
-        const file = match[1];
-        const line = match[2];
-        return `File: ${file}, Line: ${line}`;
-    }
-    return 'Unknown location';
-}
-
-export function logSuccess(message: string) {
-    console.log(`${getTimestamp()} ${green}${successEmoji}${reset} ${green}${message}${reset}`);
-}
-
-export function logError(message: string, error?: Error) {
-    const timestamp = getTimestamp();
-    const baseMessage = `${timestamp} ${red}${errorEmoji}${reset} ${red}${message}${reset}`;
-
-    if (error && error.stack) {
-        const location = extractErrorLocation(error.stack);
-        console.error(`${baseMessage}\n${location}\n${error.stack}`);
-    } else {
-        console.error(baseMessage);
-    }
-}
-
-export function logInfo(message: string) {
-    console.log(`${getTimestamp()} ${cyan}${infoEmoji}${reset} ${cyan}${message}${reset}`);
-}
-
-export function logWarning(message: string) {
-    console.warn(`${getTimestamp()} ${yellow}${warningEmoji}${reset} ${yellow}${message}${reset}`);
-}

package/lib/discord/functions/mongoDb.ts

@@ -1,38 +0,0 @@
-import { MongoClient, Db } from 'mongodb';
-
-let db: Db | null = null;
-let isInitialized = false;
-let connectionPromise: Promise<MongoClient> | null = null;
-
-async function initialize(uri: string, dbName: string): Promise<void> {
-    if (isInitialized || connectionPromise) {
-        return;
-    }
-
-    try {
-        const client = new MongoClient(uri);
-        connectionPromise = client.connect();
-        const connectedClient = await connectionPromise;
-        db = connectedClient.db(dbName || 'djsBuilder');
-        isInitialized = true;
-    } catch (error) {
-        console.error('Error initializing MongoDB:', error);
-    } finally {
-        connectionPromise = null;
-    }
-}
-
-export async function mongoConnect(uri: string, dbName: string): Promise<void> {
-    await initialize(uri, dbName);
-}
-
-export async function getDb(): Promise<Db> {
-    if (!isInitialized) {
-        throw new Error('MongoDB connection not initialized');
-    }
-    if (!db) {
-        throw new Error('MongoDB connection not established');
-    }
-    
-    return db;
-}

package/lib/discord/functions/similarity.ts

@@ -1,70 +0,0 @@
-import { Command } from '../types/starter';
-
-export function getSimilarCommands(commandName: string, commands: Command[]): string[] {
-    const similarityThreshold = 0.6;
-    const partialMatches: string[] = [];
-    const similarCommands: { name: string; similarity: number }[] = [];
-
-    for (const command of commands) {
-        const cmdName = command.name;
-
-        if (cmdName.includes(commandName) || commandName.includes(cmdName)) {
-            partialMatches.push(cmdName);
-        }
-
-        const similarity = calculateSimilarity(commandName, cmdName);
-        if (similarity >= similarityThreshold) {
-            similarCommands.push({ name: cmdName, similarity });
-        }
-
-        if (command.aliases && command.aliases.length > 0) {
-            for (const alias of command.aliases) {
-                if (alias.includes(commandName) || commandName.includes(alias)) {
-                    partialMatches.push(alias);
-                }
-
-                const aliasSimilarity = calculateSimilarity(commandName, alias);
-                if (aliasSimilarity >= similarityThreshold) {
-                    similarCommands.push({ name: alias, similarity: aliasSimilarity });
-                }
-            }
-        }
-    }
-
-    const combinedCommands = new Set([...partialMatches, ...similarCommands.map(cmd => cmd.name)]);
-    const uniqueCommands = Array.from(combinedCommands);
-
-    similarCommands.sort((a, b) => b.similarity - a.similarity);
-
-    return uniqueCommands.sort((a, b) => {
-        const aIndex = similarCommands.findIndex(cmd => cmd.name === a);
-        const bIndex = similarCommands.findIndex(cmd => cmd.name === b);
-        return bIndex - aIndex;
-    });
-}
-
-function calculateSimilarity(str1: string, str2: string): number {
-    const len1 = str1.length;
-    const len2 = str2.length;
-    const matrix = [];
-
-    for (let i = 0; i <= len1; i++) {
-        matrix[i] = [i];
-    }
-    for (let j = 0; j <= len2; j++) {
-        matrix[0][j] = j;
-    }
-
-    for (let i = 1; i <= len1; i++) {
-        for (let j = 1; j <= len2; j++) {
-            const cost = str1[i - 1] === str2[j - 1] ? 0 : 1;
-            matrix[i][j] = Math.min(
-                matrix[i - 1][j] + 1,
-                matrix[i][j - 1] + 1,
-                matrix[i - 1][j - 1] + cost
-            );
-        }
-    }
-
-    return 1 - matrix[len1][len2] / Math.max(len1, len2);
-}

package/lib/discord/functions/terminal.ts

@@ -1,162 +0,0 @@
-import { blue, cyanBright, greenBright, red, yellowBright, redBright, green, magentaBright, cyan, yellow, blueBright, gray } from 'colorette';
-import Table from 'cli-table';
-import fs from 'fs';
-import path from 'path';
-import figlet from 'figlet';
-
-
-
-async function showLoadingBar(duration: number) {
-    const steps = [15, 30, 70, 85, 95, 100];
-    const interval = duration / steps.length;
-
-    for (const step of steps) {
-        process.stdout.write(`\r${cyanBright('Loading... ')}${'█'.repeat(step / 10)}${'░'.repeat(10 - step / 10)} ${step}%`);
-        await new Promise(resolve => setTimeout(resolve, interval));
-    }
-
-    process.stdout.write('\r'.padEnd(50) + '\r');
-}
-
-export async function terminalLogs(client: any, bot: any): Promise<void> {
-    const { user, prefixSize = 0, slashSize = 0, eventSize = 0 } = client;
-
-    const totalCommands = slashSize + prefixSize;
-    const totalGuilds = client.guilds.cache.size;
-    const totalMembers = client.guilds.cache.reduce((acc: any, guild: any) => acc + guild.memberCount, 0);
-
-    function getProjectSize(dir: string): number {
-        let size = 0;
-        const files = fs.readdirSync(dir, { withFileTypes: true });
-
-        files.forEach(file => {
-            const filePath = path.join(dir, file.name);
-            if (file.isDirectory() && file.name !== 'node_modules') {
-                size += getProjectSize(filePath);
-            } else if (file.isFile()) {
-                size += fs.statSync(filePath).size;
-            }
-        });
-
-        return size;
-    }
-
-    function findProjectRoot(): string {
-        let currentDir = __dirname;
-        while (!fs.existsSync(path.join(currentDir, 'package.json'))) {
-            currentDir = path.dirname(currentDir);
-        }
-        return currentDir;
-    }
-
-    const projectPath = findProjectRoot();
-    const projectSize = getProjectSize(projectPath);
-
-    await showLoadingBar(3000);
-
-
-
-    const colors: string[] = [
-        '\x1b[34m', // Navy Blue
-        '\x1b[36m', // Light Blue
-        '\x1b[90m', // Dark Gray
-        '\x1b[35m'  // Magenta
-    ];
-    
-    const reset: string = '\x1b[0m'; // Reset color code
-    
-    function printFigletText(
-        text: string,
-        font: string,
-        colorArray: string[],
-        width: number,
-        padding: number = 0,
-        verticalPadding: number = 0
-    ): void {
-        // @ts-ignore
-        figlet.text(text, { font, width }, (err, data) => {
-            if (err) {
-                console.log('Something went wrong...');
-                console.dir(err);
-                return;
-            }
-    
-            const lines: string[] | undefined = data?.split('\n');
-    
-            const coloredLines: string[] | undefined = lines?.map((line, index) => {
-                const color: string = colorArray[index % colorArray.length];
-                const paddedLine: string = ' '.repeat(padding) + line;
-                return `${color}${paddedLine}${reset}`;
-            });
-    
-            const validVerticalPadding: number = Math.max(verticalPadding, 0);
-            const outputLines: string = Array(validVerticalPadding).fill('').concat(coloredLines).join('\n');
-            
-            console.log(outputLines);
-        });
-    }
-    
-    
-    const secondText: string = 'djs-builder';
-    const secondFont: string = 'Small Slant';
-    const secondColor: string = colors[2];
-    const horizontalPadding: number = 50; 
-    const verticalPadding: number = 2000;
-    if (bot.logs.waterMark) {
-        printFigletText(secondText, secondFont, [secondColor], 50, horizontalPadding, -verticalPadding);
-        printFigletText(user.username, '3D-ASCII', colors, 100);    
-    }
-
-    await new Promise(resolve => setTimeout(resolve, 2000));
-    
-    const botStatesTable = new Table({
-        head: [blue('# Bot States')],
-        colWidths: [30, 40],
-        style: { 'padding-left': 1, 'padding-right': 1 }
-    });
-    botStatesTable.push(
-        [yellowBright('Bot Name'), user.username],
-        [greenBright('Prefix Count'), prefixSize],
-        [red('Slash Command Count'), slashSize],
-        [cyanBright('Total Commands'), totalCommands],
-        [magentaBright('Event Count'), eventSize]
-    );
-
-    const botInfoTable = new Table({
-        head: [blue('# Bot Info')],
-        colWidths: [30, 50],
-        style: { 'padding-left': 1, 'padding-right': 1 }
-    });
-    if (client.presence?.status) {
-        botInfoTable.push([yellowBright('Status'), client.presence.status]);
-    }
-    if (bot.Status?.activities && bot.Status.activities.length > 0) {
-        botInfoTable.push([cyanBright('Activity'), bot.Status.activities[0]]);
-    }
-    if (bot.BotInfo?.botInvite) {
-        botInfoTable.push([cyanBright('Bot Invite'), bot.BotInfo.botInvite]);
-    }
-    botInfoTable.push(
-        [red('Guilds Count'), totalGuilds],
-        [redBright('Members Count'), totalMembers]
-    );
-    if (bot.Database?.verse) {
-        botInfoTable.push([gray('Bot Database'), 'VerseDb']);
-    } else if (bot.Database?.mongo) {
-        botInfoTable.push([greenBright('Bot Database'), 'MongoDb']);
-    }
-    botInfoTable.push([redBright('Bot Size'), `${(projectSize / (1024 * 1024)).toFixed(2)} MB`]);
-    if (client.user?.displayAvatarURL()) {
-        botInfoTable.push([blueBright('AvatarURL'), client.user.displayAvatarURL()]);
-    }
-    if (bot.BotInfo?.ownerId) {
-        botInfoTable.push([cyan('Owner'), bot.BotInfo.ownerId]);
-    }
-    if (client.readyTimestamp) {
-        const loggedInAt = new Date(client.readyTimestamp).toLocaleString();
-        botInfoTable.push([yellowBright('Logged In At'), loggedInAt]);
-    }
-
-    console.log(`\n${blueBright('Bot States')}\n${botStatesTable.toString()}\n`);
-    console.log(`${blueBright('Bot Info')}\n${botInfoTable.toString()}\n`);
-}

package/lib/discord/functions/utils.ts

@@ -1,4 +0,0 @@
-import { getSimilarCommands } from './similarity';
-import { mongoConnect, getDb } from './mongoDb';
-import { verseConnect } from './versedb'
-export { getSimilarCommands, mongoConnect, getDb, verseConnect }

package/lib/discord/functions/versedb.ts

@@ -1,17 +0,0 @@
-import versedb from "verse.db";
-import { LocalDb } from "../types/starter";
-
-export async function verseConnect(options: LocalDb) {
-    const connection = {
-        adapter: options.adapterType,
-        dataPath: options.path,
-        secure: { enable: options.secure?.enable, secret: options.secure?.secret || 'djs-builder' },
-        devLogs: {
-            enable: options.dev.enable,
-            path: options.dev.logsPath || ''
-        }
-    };
-
-    const db = new versedb.connect(connection)
-    return db;
-}

package/lib/discord/types/starter.ts

@@ -1,158 +0,0 @@
-import { Client } from 'discord.js'
-
-export interface BotOptions {
-    token?: string;
-    logs?: {
-        devLogs?: {
-            enable: boolean;
-            pathToWatch: any;
-            webhookURL: string;
-            mention?: string;
-        };
-        terminal?: boolean;
-        waterMark?: boolean; 
-    };
-    name?: string;
-    avatar?: string;
-    banner?: string;
-    BotInfo?: {
-        perms?: string[];
-        serverId?: string;
-        botInvite?: string;
-        serverInvite?: string;
-        ownerId?: string;
-        partners?: string[];
-        developers?: string[];
-    };
-    Status?: {
-        state: 'online' | 'dnd' | 'idle' | 'invisible' | 'Streaming' | any;
-        activities?: string[] | undefined;
-        type?: number;
-        delay?: number;
-    };
-    Database?: {
-        mongo?: MongoDbOptions;
-        verse?: LocalDb;
-    }
-}
-
-export interface SlashOptions {
-    path: string;
-    global?: boolean;
-    serverId?: string;
-    logsId?: string;
-    autoLoader?: {
-      enable?: boolean;
-      DEBOUNCE_DELAY?: number;
-    }
-}
-
-export interface PrefixOptions {
-    path: string;
-    prefix: string;
-    global?: boolean;
-    serverIds?: string[];
-    customPrefix?: {
-        serverId: string;
-        prefix: string;
-    }[];
-    similarity?: boolean;
-    logsId?: string;
-    autoLoader?: {
-        enable?: boolean;
-        DEBOUNCE_DELAY?: number;
-    }
-}
-
-export interface MongoDbOptions{
-    mongoURI: string;
-    dbName?: string;
-}
-
-export interface LocalDb {
-    adapterType: string | 'json' | 'sql' | 'yaml';
-    path: string;
-    dev: {
-        enable: boolean;
-        logsPath?: string;
-    };
-    secure: {
-        enable: boolean;
-        secret: string;
-    };
-}
-
-
-export interface AntiCrash{
-    enable: boolean;
-    webhookURL: string;
-    mention?: string;
-}
-
-export interface EventsOptions {
-    path: string;
-    logsId?: string;
-    recursive?: boolean;
-    eventBlacklist?: string[];
-    autoLoader?: {
-        enable?: boolean;
-        DEBOUNCE_DELAY?: number;
-    }
-}
-
-export interface Event {
-    name: string;
-    once: boolean;
-    execute(...args: any[]): Promise<void>;
-    initializer?: number;
-    interval?: number;
-    intervalId?: NodeJS.Timeout; 
-    maxExecution?: number;
-    retryAttempts?: number;
-}
-
-export interface Command {
-    name: string;
-    description?: string;
-    execute?: (...args: any[]) => void;
-    run?: (...args: any[]) => void;
-    aliases?: string[];
-    cooldown?: number;
-    usage?: string;
-    developer?: boolean;
-    category?: string;
-    fastUse?: boolean;
-    botPerms?: string[];
-    userPerms?: string[];
-    owner?: boolean;
-    accessLevel?: string;
-    method?: (...args: any[]) => void;
-}
-
-export type ShardingManagerMode = 'process' | 'worker';
-
-export interface ShardingManagerOptions {
-  enable?: boolean;
-  totalShards?: number | 'auto';
-  shardList?: readonly number[] | 'auto';
-  mode?: ShardingManagerMode;
-  respawn?: boolean;
-  silent?: boolean;
-  shardArgs?: readonly string[];
-  token?: string;
-  execArgv?: readonly string[];
-}
-
-export interface StarterOptions {
-    bot: BotOptions;
-    sharding?: ShardingManagerOptions;
-    slash?: SlashOptions;
-    prefix?: PrefixOptions;
-    events?: EventsOptions;
-    anticrash?: AntiCrash; 
-}
-
-export interface StarterInterface {
-    start(djs: Client, options: StarterOptions): Promise<any>;
-}
-