djs-builder 0.5.41 → 0.6.0

package/lib/discord/builder/system/Pagination.ts

@@ -1,323 +0,0 @@
-import {
-    ButtonBuilder,
-    ActionRowBuilder,
-    EmbedBuilder,
-    Message,
-    MessageComponentInteraction,
-    MessageActionRowComponentBuilder,
-    ButtonStyle,
-    StringSelectMenuBuilder,
-  } from "discord.js";
-  
-  interface PagerOptions {
-    firstLast?: boolean;
-    deleteOption?: boolean;
-    otherComponents?: ActionRowBuilder<MessageActionRowComponentBuilder>[];
-    home?: {
-      home_Option?: boolean;
-      home_page?: number;
-    };
-    timeOption?: {
-      timeOut?: number;
-      disable?: boolean;
-      deletes?: boolean;
-      custom?: (() => void);
-    };
-    user_only?: {
-      user_status?: boolean;
-      reply?: string;
-    };
-    style?: {
-      nextAndBack?: ButtonStyle;
-      firstAndLast?: ButtonStyle;
-      homeStyle?: ButtonStyle;
-      deleteStyle?: ButtonStyle;
-    };
-    label?: {
-      labelNext?: string | null;
-      labelBack?: string | null;
-      labelFirst?: string | null;
-      labelLast?: string | null;
-      labelHome?: string | null;
-      labelDelete?: string | null;
-    };
-    emoji?: {
-      emojiNext?: string;
-      emojiBack?: string;
-      emojiFirst?: string;
-      emojiLast?: string;
-      emojiHome?: string;
-      emojiDelete?: string;
-    };
-    pages?: {
-      embeds?: EmbedBuilder[];
-      attachment?: (string | Buffer)[];
-      content?: string[];
-    };
-    navigationMenu?: {
-      enabled?: boolean;
-      placeHolder?: string;
-      selects?: string[];
-    };
-  }
-    
-  const CUSTOM_IDS = {
-    NEXT: "next-discobase",
-    BACK: "back-discobase",
-    FIRST: "first-discobase",
-    LAST: "last-discobase",
-    DELETE: "delete-discobase",
-    HOME: "home-discobase",
-    SELECT: "select-discobase"
-  };
-  
-  const VALID_BUTTON_STYLES = [
-    ButtonStyle.Primary,
-    ButtonStyle.Secondary,
-    ButtonStyle.Success,
-    ButtonStyle.Danger
-  ];
-  
-  const isValidEmoji = (emoji: string | undefined): boolean => {
-    if (!emoji) return false;
-    const unicodeEmojiPattern = /^[\u{1F600}-\u{1F64F}\u{1F300}-\u{1F5FF}\u{1F680}-\u{1F6FF}\u{1F700}-\u{1F77F}\u{1F780}-\u{1F7FF}\u{1F800}-\u{1F8FF}\u{1F900}-\u{1F9FF}\u{1FA00}-\u{1FA6F}\u{1FA70}-\u{1FAFF}\u{2600}-\u{26FF}\u{2700}-\u{27BF}\u{2300}-\u{23FF}\u{2B50}\u{2934}\u{2935}\u{3030}]+$/u;
-    return unicodeEmojiPattern.test(emoji) || /^\d+$/.test(emoji);
-  };
-  
-  export class Pagination {
-    private message: Message;
-    private options: Required<PagerOptions>;
-    private buttons: ButtonBuilder[];
-    private components: ActionRowBuilder<MessageActionRowComponentBuilder>[];
-    private naw_page: number = 0;
-  
-    constructor(message: Message, options: PagerOptions) {
-      this.message = message;
-      this.options = {
-        firstLast: false,
-        deleteOption: false,
-        otherComponents: [],
-        home: { home_Option: false, home_page: 0 },
-        timeOption: { timeOut: 86400000, disable: false, deletes: false, custom: undefined },
-        user_only: { user_status: false, reply: "You are not the command owner" },
-        style: { nextAndBack: ButtonStyle.Primary, firstAndLast: ButtonStyle.Secondary, homeStyle: ButtonStyle.Success, deleteStyle: ButtonStyle.Danger },
-        label: {},
-        emoji: { emojiNext: "➡", emojiBack: "⬅", emojiFirst: "⏪", emojiLast: "⏩", emojiHome: "🏠", emojiDelete: "🗑" },
-        pages: { embeds: [], attachment: [], content: [] },
-        navigationMenu: { enabled: false, placeHolder: "Choose a page", selects: [] },
-        ...options,
-      };
-  
-      this.validateOptions();
-      this.buttons = this.createButtons();
-      this.components = this.createComponents();
-    }  
-    private validateOptions() {
-      const { emoji } = this.options;
-      if (!Object.values(emoji).every(isValidEmoji)) {
-        throw new Error("Invalid emoji format. Must be either Unicode emojis or valid emoji IDs.");
-      }
-  
-      const { style } = this.options;
-      if (!Object.values(style).every(style => VALID_BUTTON_STYLES.includes(style))) {
-        throw new Error("Invalid button style. Must be one of the predefined ButtonStyle values.");
-      }
-  
-      if (this.options.deleteOption && this.options.home?.home_Option) {
-        throw new Error("You can't use 'home' and 'delete' together.");
-      }
-  
-      if (this.options.timeOption?.disable && this.options.timeOption?.deletes) {
-        throw new Error("You can't use 'disable' and 'deletes' together.");
-      }
-    }
-  
-    private createButtons(): ButtonBuilder[] {
-      const {
-        nextAndBack,
-        firstAndLast,
-        homeStyle,
-        deleteStyle,
-      } = this.options.style;
-  
-      const {
-        emojiNext,
-        emojiBack,
-        emojiFirst,
-        emojiLast,
-        emojiHome,
-        emojiDelete,
-      } = this.options.emoji;
-  
-      const next = new ButtonBuilder().setCustomId(CUSTOM_IDS.NEXT).setEmoji(emojiNext!).setStyle(nextAndBack!);
-      const back = new ButtonBuilder().setCustomId(CUSTOM_IDS.BACK).setEmoji(emojiBack!).setStyle(nextAndBack!);
-      const first = new ButtonBuilder().setCustomId(CUSTOM_IDS.FIRST).setEmoji(emojiFirst!).setStyle(firstAndLast!);
-      const last = new ButtonBuilder().setCustomId(CUSTOM_IDS.LAST).setEmoji(emojiLast!).setStyle(firstAndLast!);
-      const home = new ButtonBuilder().setCustomId(CUSTOM_IDS.HOME).setEmoji(emojiHome!).setStyle(homeStyle!);
-      const deleteBtn = new ButtonBuilder().setCustomId(CUSTOM_IDS.DELETE).setEmoji(emojiDelete!).setStyle(deleteStyle!);
-  
-      const {
-        labelNext,
-        labelBack,
-        labelFirst,
-        labelLast,
-        labelHome,
-        labelDelete,
-      } = this.options.label;
-  
-      if (labelNext) next.setLabel(labelNext);
-      if (labelBack) back.setLabel(labelBack);
-      if (labelFirst) first.setLabel(labelFirst);
-      if (labelLast) last.setLabel(labelLast);
-      if (labelHome) home.setLabel(labelHome);
-      if (labelDelete) deleteBtn.setLabel(labelDelete);
-  
-      const buttons: ButtonBuilder[] = [];
-  
-      if (this.options.firstLast) buttons.push(first);
-      buttons.push(back);
-      if (this.options.home?.home_Option) buttons.push(home);
-      else if (this.options.deleteOption) buttons.push(deleteBtn);
-      buttons.push(next);
-      if (this.options.firstLast) buttons.push(last);
-  
-      return buttons;
-    }
-  
-    private createComponents(): ActionRowBuilder<MessageActionRowComponentBuilder>[] {
-        const buttonRow = new ActionRowBuilder<MessageActionRowComponentBuilder>().addComponents(this.buttons);
-    
-        const otherRows = this.options.otherComponents || [];
-        const selectMenus = this.options.navigationMenu?.enabled ? this.createSelectMenus() : [];
-    
-        return [buttonRow, ...selectMenus, ...otherRows];
-      }
-    
-      private createSelectMenus(): ActionRowBuilder<StringSelectMenuBuilder>[] {
-        const { embeds = [], content = [], attachment = [] } = this.options.pages || {};
-        const longest_length = Math.max(embeds.length, content.length, attachment.length);
-        const selectMenus: ActionRowBuilder<StringSelectMenuBuilder>[] = [];
-        const select_status = this.options.navigationMenu?.enabled;
-        const select_placeholder = this.options.navigationMenu?.placeHolder;
-        const selects = this.options.navigationMenu?.selects || [];
-    
-        if (select_status) {
-            for (let i = 0; i < longest_length; i += 25) {
-                const menuOptions = Array.from({ length: Math.min(25, longest_length - i) }, (_, j) => ({
-                    label: selects[i + j] ? selects[i + j] : `Page ${i + j + 1}`,
-                    value: `${i + j}` 
-                }));
-    
-                const selectMenu = new StringSelectMenuBuilder()
-                    .setCustomId(`discobase_select_${i / 25}`) 
-                    .setPlaceholder(`${select_placeholder || "Choose a page"} (${i + 1}-${Math.min(i + 25, longest_length)})`)
-                    .addOptions(menuOptions);
-    
-                selectMenus.push(new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(selectMenu));
-            }
-        }
-    
-        return selectMenus;
-    }
-              
-      public async send() {
-        const { embeds = [], content = [], attachment = [] } = this.options.pages || {};
-    
-        if (embeds.length === 0) {
-          throw new Error("No embeds provided.");
-        }
-    
-        try {
-          const msg = await this.message.reply({
-            embeds: [embeds[0]],
-            content: content[0] || "",
-            files: attachment[0] ? [attachment[0]] : [],
-            components: this.components,
-          });
-    
-          const collector = this.createCollector(msg);
-          collector.on("collect", async (i: MessageComponentInteraction) => this.handleCollect(i));
-          collector.on("end", async () => this.handleEnd(msg));
-        } catch (error) {
-          console.error("Error sending message:", error);
-        }
-      }
-    
-      private createCollector(msg: Message) {
-        const filter = this.options.user_only?.user_status
-          ? async (i: MessageComponentInteraction) => {
-              if (i.user.id !== this.message.author.id) {
-                await i.reply({ content: this.options.user_only.reply!, ephemeral: true });
-                return false;
-              }
-              return true;
-            }
-          : undefined;
-    
-        return msg.createMessageComponentCollector({
-          filter,
-          time: this.options.timeOption?.timeOut || 86400000,
-        });
-      }
-      
-      
-      private async handleCollect(i: MessageComponentInteraction) {
-        const { embeds = [], content = [], attachment = [] } = this.options.pages || {};
-        const num = embeds.length;
-      
-        try {
-          if (i.isButton()) {
-            switch (i.customId) {
-              case CUSTOM_IDS.NEXT:
-                this.naw_page = (this.naw_page + 1) % num;
-                break;
-              case CUSTOM_IDS.BACK:
-                this.naw_page = (this.naw_page - 1 + num) % num;
-                break;
-              case CUSTOM_IDS.FIRST:
-                this.naw_page = 0;
-                break;
-              case CUSTOM_IDS.LAST:
-                this.naw_page = num - 1;
-                break;
-              case CUSTOM_IDS.DELETE:
-                await i.message.delete();
-                return;
-              case CUSTOM_IDS.HOME:
-                this.naw_page = this.options.home?.home_page || 0;
-                break;
-            }
-          } else if (i.isStringSelectMenu()) {
-            if (i.customId.startsWith("discobase_select_")) {
-              this.naw_page = parseInt(i.values[0], 10);
-            }
-          }
-          await i.update({
-            embeds: [embeds[this.naw_page]],
-            content: content[this.naw_page] || "",
-            files: attachment[this.naw_page] ? [attachment[this.naw_page]] : [],
-            components: this.createComponents(),
-          });
-        } catch (error) {
-          console.error("Error handling interaction:", error);
-        }
-      }
-            
-      private async handleEnd(msg: Message) {
-        try {
-          if (this.options.timeOption?.disable) {
-            this.components[0].components.forEach((button) => button.setDisabled(true));
-            await msg.edit({ components: this.components });
-          }
-          if (this.options.timeOption?.deletes) {
-            await msg.edit({ components: [] });
-          }
-          if (typeof this.options.timeOption?.custom === "function") {
-            this.options.timeOption.custom();
-          }
-        } catch (error) {
-          console.error("Error handling end of collector:", error);
-        }
-      }
-    }
-    

package/lib/discord/builder/system/collectors.ts

@@ -1,197 +0,0 @@
-import {
-    Message,
-    Interaction,
-    MessageCollector,
-    InteractionCollector,
-    CollectorFilter,
-    Snowflake,
-    ReadonlyCollection,
-    CommandInteraction,
-    ButtonInteraction,
-    MessageReaction,
-    ModalSubmitInteraction,
-    StringSelectMenuInteraction,
-    UserSelectMenuInteraction,
-    RoleSelectMenuInteraction,
-    ContextMenuCommandInteraction,
-    Collector,
-} from 'discord.js';
-
-type EventSource = Message | CommandInteraction | ButtonInteraction | MessageReaction | Interaction;
-
-const collectorCache: Map<string, any> = new Map();
-
-/**
- * @param sources - The event source(s) (message, interaction, reaction, etc.) to collect from.
- * @param options - Custom options for collection (time, filter, max, idle).
- * @param events - Custom event handlers for `onCollect`, `onEnd`, `onError`, etc.
- */
-function Djs_Collectors<T extends EventSource>(
-    sources: T | T[],
-    options: {
-        time?: number; 
-        filter?: CollectorFilter<[T]>; 
-        max?: number; 
-        idle?: number; 
-        log?: boolean; 
-        throttle?: number; 
-        uniqueId?: string; 
-    },
-    events: {
-        onCollect: (collectedItem: T, meta?: Record<string, any>) => void; 
-        onEnd?: (collected: ReadonlyCollection<Snowflake, T>, reason: string) => void; 
-        onError?: (error: Error) => void; 
-        onDispose?: (disposedItem: T) => void; 
-        onTimeout?: () => void; 
-        onStart?: () => void; 
-    },
-    metadata?: Record<string, any> 
-): { stop: (reason?: string) => void } { 
-    const eventSources = Array.isArray(sources) ? sources : [sources];
-    const filter: CollectorFilter<[T]> = options.filter || (() => true);
-    const time: number = options.time || 60000; 
-
-    if (events.onStart) events.onStart();
-
-    if (options.uniqueId && collectorCache.has(options.uniqueId)) {
-        console.warn(`Collector with unique ID "${options.uniqueId}" is already active. Skipping creation.`);
-        return { stop: () => {} };
-    }
-
-    if (options.uniqueId) {
-        collectorCache.set(options.uniqueId, { sources: eventSources, time, max: options.max, idle: options.idle });
-    }
-
-    const collectors: any[] = []; 
-
-    for (const source of eventSources) {
-        if (source instanceof Message) {
-            const messageCollector = new MessageCollector(source.channel, {
-                filter: filter as CollectorFilter<[Message]>,
-                time,
-                max: options.max,
-                idle: options.idle,
-            });
-
-            collectors.push(messageCollector); // Store reference
-            handleCollector(messageCollector, events, options, metadata);
-
-        } else if (
-            source instanceof CommandInteraction ||
-            source instanceof ButtonInteraction ||
-            source instanceof StringSelectMenuInteraction ||
-            source instanceof UserSelectMenuInteraction ||
-            source instanceof RoleSelectMenuInteraction ||
-            source instanceof ContextMenuCommandInteraction ||
-            source instanceof ModalSubmitInteraction
-        ) {
-            if (!source.client.isReady()) {
-                throw new Error('Client is not ready. Please ensure the client is logged in and ready before creating a collector.');
-            }
-
-            const interactionCollector = new InteractionCollector(source.client, {
-                filter: filter as CollectorFilter<[Interaction]>,
-                time,
-                max: options.max,
-                idle: options.idle,
-            });
-
-            collectors.push(interactionCollector); // Store reference
-            handleCollector(interactionCollector, events, options, metadata);
-
-        } else if (source instanceof MessageReaction) {
-            const reactionCollector = source.message.createReactionCollector({
-                filter: filter as CollectorFilter<[MessageReaction]>,
-                time,
-                max: options.max,
-                idle: options.idle,
-            });
-
-            collectors.push(reactionCollector); // Store reference
-            handleCollector(reactionCollector, events, options, metadata);
-
-        } else {
-            throw new Error("Source must be either a Message, Interaction, or Reaction.");
-        }
-    }
-
-    return {
-        stop: (reason: string = 'manual') => {
-            if (options.uniqueId) {
-                const cached = collectorCache.get(options.uniqueId);
-                if (cached) {
-                    collectors.forEach((collector) => collector.stop(reason));
-                    collectorCache.delete(options.uniqueId);
-                    console.log(`Collector with unique ID "${options.uniqueId}" has been ended. Reason: ${reason}`);
-                } else {
-                    console.warn(`No collector found with unique ID "${options.uniqueId}".`);
-                }
-            } else {
-                collectors.forEach((collector) => collector.stop(reason)); 
-                console.log(`Collectors have been ended. Reason: ${reason}`);
-            }
-        },
-    };
-}
-
-/**
- * Generic function to handle a collector's events and lifecycle.
- * @param collector - The specific collector (MessageCollector, InteractionCollector, etc.).
- * @param events - The event handlers for collection lifecycle.
- * @param options - Additional collection options.
- * @param metadata - Optional metadata attached to each collected item.
- */
-function handleCollector<T>(
-    collector: any,
-    events: {
-        onCollect: (collectedItem: T, meta?: Record<string, any>) => void;
-        onEnd?: (collected: ReadonlyCollection<Snowflake, T>, reason: string) => void;
-        onError?: (error: Error) => void;
-        onDispose?: (disposedItem: T) => void;
-        onTimeout?: () => void;
-    },
-    options: { log?: boolean; throttle?: number; uniqueId?: string }, 
-    metadata?: Record<string, any>
-) {
-    let lastCollectedTime = 0; 
-
-    collector.on('collect', (collectedItem: T) => {
-        const now = Date.now();
-        if (options.throttle && now - lastCollectedTime < options.throttle) {
-            if (options.log) console.warn(`Throttled collect for ${collectedItem}`);
-            return; 
-        }
-        lastCollectedTime = now;
-
-        if (options.log) console.log('Collected item:', collectedItem);
-        events.onCollect(collectedItem, metadata);
-    });
-
-    collector.on('end', (collected: ReadonlyCollection<Snowflake, T>, reason: string) => {
-        if (options.log) console.log(`Collector ended. Reason: ${reason}`);
-        if (events.onEnd) events.onEnd(collected, reason);
-        if (reason === 'time' && events.onTimeout) {
-            events.onTimeout();
-        }
-
-        if (options.uniqueId) {
-            collectorCache.delete(options.uniqueId);
-        }
-    });
-
-    if (events.onError) {
-        collector.on('error', (error: Error) => {
-            if (options.log) console.error('Collector error:', error);
-            (events.onError as (error: Error) => void)(error);
-        });
-    }
-
-    if (events.onDispose) {
-        collector.on('dispose', (disposedItem: T) => {
-            if (options.log) console.log('Disposed item:', disposedItem);
-            (events.onDispose as (disposedItem: T) => void)(disposedItem);
-        });
-    }
-}
-
-export { Djs_Collectors };

package/lib/discord/builder/utils.ts

@@ -1,9 +0,0 @@
-import { ButtonManager } from './components/Buttons';
-import { MenuManager } from './components/Menus';
-import { PermissionChecker } from './permissions/perms';
-
-export {
-  ButtonManager,
-  MenuManager,
-  PermissionChecker
-};

package/lib/discord/events-handler/eventLoader.ts

@@ -1,166 +0,0 @@
-import { Client, Collection } from 'discord.js';
-import { readdir } from 'fs/promises';
-import { resolve, extname } from 'path';
-import { Event } from '../types/utils';
-import { logError, logInfo } from '../functions/logger';
-import { botData } from './login';
-import { watch } from 'fs';
-
-const validExtensions = ['.js', '.ts'];
-
-interface Events {
-    eventBlacklist?: string[];
-    recursive?: boolean;
-}
-
-export async function eventLoader(client: any, eventsOptions: Events = {}): Promise<{ events: Collection<string, Event>; success: boolean }> {
-    try {
-        const eventsPath = botData.get('eventsPath') as string;
-        const eventPath = resolve(process.cwd(), eventsPath);
-
-        const getAllFiles = async (dirPath: string): Promise<string[]> => {
-            let files: string[] = [];
-            const dirents = await readdir(dirPath, { withFileTypes: true });
-
-            for (const dirent of dirents) {
-                const res = resolve(dirPath, dirent.name);
-                if (dirent.isDirectory()) {
-                    if (eventsOptions.recursive) {
-                        files = files.concat(await getAllFiles(res));
-                    }
-                } else if (validExtensions.includes(extname(dirent.name))) {
-                    files.push(res);
-                }
-            }
-            return files;
-        };
-
-        const files = await getAllFiles(eventPath);
-        if (files.length === 0) {
-            logInfo(`No event files found in directory \`${eventPath}\`.`);
-            return { events: new Collection<string, Event>(), success: false };
-        }
-
-        client.removeAllListeners();
-
-        for (const file of files) {
-            delete require.cache[require.resolve(file)];
-            logInfo(`Unlinked cached module: ${file}`);
-        }
-
-        const newEvents = new Collection<string, Event>();
-        for (const file of files) {
-            try {
-                const event: Event = await import(file);
-                if (eventsOptions.eventBlacklist?.includes(file)) {
-                    continue;
-                }
-
-                let eventHandler: (...args: any[]) => Promise<void> = async (...args: any[]) => {
-                    if (event.initializer) {
-                        await new Promise(resolve => setTimeout(resolve, event.initializer));
-                    }
-                    await event.execute(...args, client);
-
-                    if (event.interval) {
-                        if (event.intervalId) clearInterval(event.intervalId);
-                        event.intervalId = setInterval(async () => {
-                            await event.execute(...args, client);
-                        }, event.interval);
-                    }
-                };
-
-                if (event.once) {
-                    client.once(event.name, eventHandler);
-                } else {
-                    client.on(event.name, eventHandler);
-                }
-
-                if (event.maxExecution !== undefined) {
-                    eventHandler = await limitConcurrency(eventHandler, event.maxExecution);
-                }
-
-                if (event.retryAttempts !== undefined) {
-                    eventHandler = await withRetry(eventHandler, event.retryAttempts);
-                }
-
-                newEvents.set(event.name, event);
-            } catch (error: any) {
-                logError(`Error re-importing file: ${file}`);
-                logError(error.message, error);
-            }
-        }
-
-        client.eventSize = newEvents.size;
-
-        return { events: newEvents, success: true };
-    } catch (error: any) {
-        logError('Error reloading events:');
-        logError(error.message, error);
-        return { events: new Collection<string, Event>(), success: false };
-    }
-}
-
-async function limitConcurrency(handler: (...args: any[]) => void, maxConcurrentExecutions: number): Promise<(...args: any[]) => Promise<void>> {
-    let executing = 0;
-    const queue: any[] = [];
-
-    return async function(...args: any[]) {
-        if (executing < maxConcurrentExecutions) {
-            executing++;
-            handler(...args);
-            executing--;
-
-            if (queue.length > 0) {
-                const next = queue.shift();
-                next();
-            }
-        } else {
-            queue.push(() => handler(...args));
-        }
-    };
-}
-
-async function withRetry(handler: (...args: any[]) => Promise<void>, retryAttempts: number): Promise<(...args: any[]) => Promise<void>> {
-    return async function(...args: any[]) {
-        let attempts = 0;
-        while (attempts < retryAttempts) {
-            try {
-                await handler(...args);
-                return;
-            } catch (error: any) {
-                logError('Error executing event:');
-                logError(error.message, error);
-                attempts++;
-            }
-        }
-        logError('Reached maximum retry attempts.');
-    };
-}
-
-export function autoEventLoader(client: Client, DEBOUNCE_DELAY: number = 10000, eventsOptions: Events = {}) {
-
-    const slashPath = botData.get('slashCommandPath') as string;
-    const commandPath = resolve(process.cwd(), slashPath);
-
-    let debounceTimer: NodeJS.Timeout | null = null;
-
-    const handleReload = async () => {
-        if (debounceTimer) {
-            clearTimeout(debounceTimer);
-        }
-        debounceTimer = setTimeout(async () => {
-            await eventLoader(client, eventsOptions);
-            logInfo('Slash commands successfully reloaded after debounce.');
-        }, DEBOUNCE_DELAY);
-    };
-
-    watch(commandPath, { recursive: false }, (eventType: any, filename: any) => {
-        if (filename && validExtensions.includes(extname(filename))) {
-            logInfo(`Detected ${eventType} in ${filename}, waiting for debouncing...`);
-            handleReload();
-        }
-    });
-
-    logInfo('Started watching for changes in slash commands...');
-}