qaut.js 1.0.6 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qaut.js",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "Official QauT bot framework for building bots and integrations.",
   "main": "src/index.js",
   "types": "src/index.d.ts",

package/src/handlers/CommandHandler.js

@@ -0,0 +1,56 @@
+'use strict';
+
+class CommandHandler {
+  constructor(client, options = {}) {
+    this.client = client;
+    this.prefix = options.prefix || '!';
+    this.commands = new Map();
+    this.cooldowns = new Map();
+  }
+
+  register(name, execute, options = {}) {
+    if (!name || typeof execute !== 'function') throw new TypeError('Command name and execute function are required');
+    this.commands.set(String(name).toLowerCase(), {
+      name: String(name).toLowerCase(),
+      aliases: (options.aliases || []).map(alias => String(alias).toLowerCase()),
+      description: options.description || '',
+      cooldown: Number(options.cooldown || 0),
+      execute
+    });
+    return this;
+  }
+
+  unregister(name) {
+    return this.commands.delete(String(name).toLowerCase());
+  }
+
+  find(name) {
+    const key = String(name || '').toLowerCase();
+    return this.commands.get(key) || [...this.commands.values()].find(command => command.aliases.includes(key));
+  }
+
+  async handleMessage(message) {
+    const content = String(message?.content || '');
+    if (!content.startsWith(this.prefix)) return false;
+    const [rawName, ...args] = content.slice(this.prefix.length).trim().split(/\s+/);
+    const command = this.find(rawName);
+    if (!command) return false;
+    if (command.cooldown && this.isCoolingDown(message.author?.id || message.authorId, command)) return true;
+    if (command.cooldown) this.setCooldown(message.author?.id || message.authorId, command);
+    await command.execute(message, args, this.client);
+    return true;
+  }
+
+  isCoolingDown(userId, command) {
+    const key = `${userId}:${command.name}`;
+    return (this.cooldowns.get(key) || 0) > Date.now();
+  }
+
+  setCooldown(userId, command) {
+    const key = `${userId}:${command.name}`;
+    this.cooldowns.set(key, Date.now() + command.cooldown);
+    setTimeout(() => this.cooldowns.delete(key), command.cooldown).unref?.();
+  }
+}
+
+module.exports = { CommandHandler };

package/src/handlers/EventHandler.js

@@ -0,0 +1,34 @@
+'use strict';
+
+class EventHandler {
+  constructor(client) {
+    this.client = client;
+    this.listeners = new Map();
+  }
+
+  register(eventName, listener, options = {}) {
+    if (!eventName || typeof listener !== 'function') throw new TypeError('Event name and listener function are required');
+    const method = options.once ? 'once' : 'on';
+    this.client[method](eventName, listener);
+    if (!this.listeners.has(eventName)) this.listeners.set(eventName, new Set());
+    this.listeners.get(eventName).add(listener);
+    return this;
+  }
+
+  unregister(eventName, listener) {
+    this.client.off(eventName, listener);
+    this.listeners.get(eventName)?.delete(listener);
+    return this;
+  }
+
+  clear(eventName) {
+    const names = eventName ? [eventName] : [...this.listeners.keys()];
+    names.forEach(name => {
+      for (const listener of this.listeners.get(name) || []) this.client.off(name, listener);
+      this.listeners.delete(name);
+    });
+    return this;
+  }
+}
+
+module.exports = { EventHandler };

package/src/handlers/GatewayHandler.js

@@ -0,0 +1,25 @@
+'use strict';
+
+class GatewayHandler {
+  constructor(client, options = {}) {
+    this.client = client;
+    this.intervalMs = Number(options.intervalMs || client.pollIntervalMs || 1500);
+    this.timer = null;
+  }
+
+  start() {
+    this.client.pollIntervalMs = this.intervalMs;
+    this.client.startPolling();
+    this.timer = this.client.pollInterval;
+    return this;
+  }
+
+  stop() {
+    if (this.client.pollInterval) clearInterval(this.client.pollInterval);
+    this.client.pollInterval = null;
+    this.timer = null;
+    return this;
+  }
+}
+
+module.exports = { GatewayHandler };

package/src/handlers/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const { CommandHandler } = require('./CommandHandler');
+const { EventHandler } = require('./EventHandler');
+const { GatewayHandler } = require('./GatewayHandler');
+
+module.exports = {
+  CommandHandler,
+  EventHandler,
+  GatewayHandler
+};

package/src/index.d.ts

@@ -114,9 +114,28 @@ export declare class Sticker extends Entity { [key: string]: any; }
 export declare class Emoji extends Entity { [key: string]: any; }
 export declare class ScheduledEvent extends Entity { [key: string]: any; }
 export declare class Collector extends EventEmitter { collected: Collection; next: Promise<any>; stop(reason?: string): void; resetTimer(): this; }
+export declare class CommandHandler {
+  constructor(client: Client, options?: { prefix?: string });
+  register(name: string, execute: Function, options?: { aliases?: string[]; description?: string; cooldown?: number }): this;
+  unregister(name: string): boolean;
+  find(name: string): any;
+  handleMessage(message: any): Promise<boolean>;
+}
+export declare class EventHandler {
+  constructor(client: Client);
+  register(eventName: string, listener: Function, options?: { once?: boolean }): this;
+  unregister(eventName: string, listener: Function): this;
+  clear(eventName?: string): this;
+}
+export declare class GatewayHandler {
+  constructor(client: Client, options?: { intervalMs?: number });
+  start(): this;
+  stop(): this;
+}
 
 export declare class Client extends EventEmitter {
   token: string; rest: REST; user: any; guilds: Collection; channels: Collection; users: Collection;
+  commands: CommandHandler; events: EventHandler; gateway: GatewayHandler;
   constructor(options?: { token?: string; intents?: any; restBaseUrl?: string; keepAlive?: boolean; polling?: boolean; pollIntervalMs?: number; registerProcessShutdown?: boolean });
   login(token?: string): Promise<string>; destroy(options?: { setOffline?: boolean }): Promise<this>; isReady(): boolean;
   generateInvite(options?: any): string; fetchInvite(code: string): Promise<any>; fetchWebhook(id: string): Promise<any>; fetchGuildPreview(id: string): Promise<any>;

package/src/index.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { EventEmitter } = require('events');
+const { CommandHandler, EventHandler, GatewayHandler } = require('./handlers');
 
 const DefaultRestBase = 'https://qaut.gg/api';
 
@@ -471,6 +472,10 @@ class Client extends EventEmitter {
     this.destroyed = false;
     this.registerProcessShutdown = options.registerProcessShutdown !== false;
     this.boundShutdown = null;
+    this.commands = new CommandHandler(this, options.commands || {});
+    this.events = new EventHandler(this);
+    this.gateway = new GatewayHandler(this, options.gateway || {});
+    this.on(Events.MessageCreate, message => this.commands.handleMessage(message).catch(err => this.emit(Events.Error, err)));
   }
   isReady() { return Boolean(this.user && !this.destroyed); }
   async login(token = this.token) { if (!token) throw new QauTError('Bot token is required'); this.token = token; this.rest.setToken(token); this.user = await this.rest.get('/bot/me'); if (this.keepAlive) this.startKeepAlive(); if (this.polling) this.startPolling(); if (this.registerProcessShutdown) this.attachProcessShutdown(); this.emit(Events.ClientReady, this.user); return token; }
@@ -551,6 +556,7 @@ Object.defineProperty(User.prototype, 'displayName', {
 module.exports = {
   ActionRowBuilder, ActivityType, AttachmentBuilder, BitField, ButtonBuilder, Channel, ChannelSelectMenuBuilder,
   Client, Collection, ContextMenuCommandBuilder, CreateEmbed, DefaultRestBase, EmbedBuilder, Emoji, Events,
+  CommandHandler, EventHandler, GatewayHandler,
   GatewayIntentBits, Guild, GuildMember, IntentBitField, Interaction, Invite, Message, ModalBuilder,
   PermissionBitField, PermissionsBitField, PermissionFlagsBits, Partials, QauTError, REST, Reaction, Role,
   RoleSelectMenuBuilder, ScheduledEvent, SelectMenuBuilder, SlashCommandBuilder, Status, Sticker,