@jubbio/core 1.0.0

package/dist/Client.js

@@ -0,0 +1,471 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewayIntentBits = exports.Client = void 0;
+const events_1 = require("events");
+const ws_1 = __importDefault(require("ws"));
+const enums_1 = require("./enums");
+Object.defineProperty(exports, "GatewayIntentBits", { enumerable: true, get: function () { return enums_1.GatewayIntentBits; } });
+const Collection_1 = require("./structures/Collection");
+const User_1 = require("./structures/User");
+const Guild_1 = require("./structures/Guild");
+const Message_1 = require("./structures/Message");
+const Interaction_1 = require("./structures/Interaction");
+const REST_1 = require("./rest/REST");
+/**
+ * Main client class
+ */
+class Client extends events_1.EventEmitter {
+    /** Client options */
+    options;
+    /** REST API client */
+    rest;
+    /** The bot user */
+    user = null;
+    /** Application ID */
+    applicationId = null;
+    /** Cached guilds */
+    guilds = new Collection_1.Collection();
+    /** Cached channels */
+    channels = new Collection_1.Collection();
+    /** Cached users */
+    users = new Collection_1.Collection();
+    /** Voice adapter management */
+    voice;
+    /** WebSocket connection */
+    ws = null;
+    /** Bot token */
+    token = '';
+    /** Session ID */
+    sessionId = null;
+    /** Sequence number */
+    sequence = null;
+    /** Heartbeat interval */
+    heartbeatInterval = null;
+    /** Gateway URL */
+    gatewayUrl;
+    /** Voice state update handlers (for voice adapters) */
+    voiceStateHandlers = new Map();
+    voiceServerHandlers = new Map();
+    constructor(options) {
+        super();
+        this.options = options;
+        this.gatewayUrl = options.gatewayUrl || 'ws://localhost:5003/ws/bot';
+        this.rest = new REST_1.REST(options.apiUrl);
+        // Initialize voice adapter system
+        this.voice = {
+            adapters: new Map()
+        };
+    }
+    /**
+     * Calculate intents value
+     */
+    getIntentsValue() {
+        if (typeof this.options.intents === 'number') {
+            return this.options.intents;
+        }
+        return this.options.intents.reduce((acc, intent) => acc | intent, 0);
+    }
+    /**
+     * Login to the gateway
+     */
+    async login(token) {
+        this.token = token.replace(/^Bot\s+/i, '');
+        this.rest.setToken(this.token);
+        return new Promise((resolve, reject) => {
+            this.connect();
+            // Wait for ready event
+            const timeout = setTimeout(() => {
+                reject(new Error('Login timeout'));
+            }, 30000);
+            this.once('ready', () => {
+                clearTimeout(timeout);
+                resolve(this.token);
+            });
+            this.once('error', (error) => {
+                clearTimeout(timeout);
+                reject(error);
+            });
+        });
+    }
+    /**
+     * Connect to the gateway
+     */
+    connect() {
+        this.ws = new ws_1.default(this.gatewayUrl);
+        this.ws.on('open', () => {
+            this.emit('debug', 'WebSocket connection opened');
+        });
+        this.ws.on('message', (data) => {
+            this.handleMessage(data.toString());
+        });
+        this.ws.on('close', (code, reason) => {
+            this.emit('debug', `WebSocket closed: ${code} - ${reason}`);
+            this.cleanup();
+            // Reconnect on certain close codes
+            if (code !== 1000 && code !== 4004) {
+                setTimeout(() => this.connect(), 5000);
+            }
+        });
+        this.ws.on('error', (error) => {
+            this.emit('error', error);
+        });
+    }
+    /**
+     * Handle incoming gateway message
+     */
+    handleMessage(data) {
+        // Handle multiple messages in one frame
+        const messages = data.split('\n').filter(m => m.trim());
+        for (const msg of messages) {
+            try {
+                const payload = JSON.parse(msg);
+                this.handlePayload(payload);
+            }
+            catch (e) {
+                this.emit('debug', `Failed to parse message: ${msg}`);
+            }
+        }
+    }
+    /**
+     * Handle gateway payload
+     */
+    handlePayload(payload) {
+        if (payload.s) {
+            this.sequence = payload.s;
+        }
+        switch (payload.op) {
+            case enums_1.GatewayOpcodes.Hello:
+                this.handleHello(payload.d);
+                break;
+            case enums_1.GatewayOpcodes.Dispatch:
+                this.handleDispatch(payload.t, payload.d);
+                break;
+            case enums_1.GatewayOpcodes.HeartbeatAck:
+                this.emit('debug', 'Heartbeat acknowledged');
+                break;
+            case enums_1.GatewayOpcodes.InvalidSession:
+                this.emit('debug', 'Invalid session, re-identifying...');
+                setTimeout(() => this.identify(), 5000);
+                break;
+            case enums_1.GatewayOpcodes.Reconnect:
+                this.emit('debug', 'Reconnect requested');
+                this.ws?.close();
+                setTimeout(() => this.connect(), 1000);
+                break;
+        }
+    }
+    /**
+     * Handle Hello payload
+     */
+    handleHello(data) {
+        this.emit('debug', `Received Hello, heartbeat interval: ${data.heartbeat_interval}ms`);
+        this.startHeartbeat(data.heartbeat_interval);
+        this.identify();
+    }
+    /**
+     * Handle Dispatch events
+     */
+    handleDispatch(eventType, data) {
+        this.emit('debug', `Dispatch: ${eventType}`);
+        switch (eventType) {
+            case 'READY':
+                this.handleReady(data);
+                break;
+            case 'GUILD_CREATE':
+                this.handleGuildCreate(data);
+                break;
+            case 'GUILD_UPDATE':
+                this.handleGuildUpdate(data);
+                break;
+            case 'GUILD_DELETE':
+                this.handleGuildDelete(data);
+                break;
+            case 'MESSAGE_CREATE':
+                this.handleMessageCreate(data);
+                break;
+            case 'MESSAGE_UPDATE':
+                this.emit('messageUpdate', data);
+                break;
+            case 'MESSAGE_DELETE':
+                this.emit('messageDelete', data);
+                break;
+            case 'MESSAGE_DELETE_BULK':
+                this.emit('messageDeleteBulk', data);
+                break;
+            case 'CHANNEL_CREATE':
+                this.emit('channelCreate', data);
+                break;
+            case 'CHANNEL_UPDATE':
+                this.emit('channelUpdate', data);
+                break;
+            case 'CHANNEL_DELETE':
+                this.emit('channelDelete', data);
+                break;
+            case 'GUILD_MEMBER_ADD':
+                this.emit('guildMemberAdd', data);
+                break;
+            case 'GUILD_MEMBER_UPDATE':
+                this.emit('guildMemberUpdate', data);
+                break;
+            case 'GUILD_MEMBER_REMOVE':
+                this.emit('guildMemberRemove', data);
+                break;
+            case 'GUILD_ROLE_CREATE':
+                this.emit('roleCreate', data);
+                break;
+            case 'GUILD_ROLE_UPDATE':
+                this.emit('roleUpdate', data);
+                break;
+            case 'GUILD_ROLE_DELETE':
+                this.emit('roleDelete', data);
+                break;
+            case 'GUILD_BAN_ADD':
+                this.emit('guildBanAdd', data);
+                break;
+            case 'GUILD_BAN_REMOVE':
+                this.emit('guildBanRemove', data);
+                break;
+            case 'INVITE_CREATE':
+                this.emit('inviteCreate', data);
+                break;
+            case 'INVITE_DELETE':
+                this.emit('inviteDelete', data);
+                break;
+            case 'THREAD_CREATE':
+                this.emit('threadCreate', data);
+                break;
+            case 'THREAD_UPDATE':
+                this.emit('threadUpdate', data);
+                break;
+            case 'THREAD_DELETE':
+                this.emit('threadDelete', data);
+                break;
+            case 'TYPING_START':
+                this.emit('typingStart', data);
+                break;
+            case 'PRESENCE_UPDATE':
+                this.emit('presenceUpdate', data);
+                break;
+            case 'INTERACTION_CREATE':
+                this.handleInteractionCreate(data);
+                break;
+            case 'VOICE_STATE_UPDATE':
+                this.handleVoiceStateUpdate(data);
+                break;
+            case 'VOICE_SERVER_UPDATE':
+                this.handleVoiceServerUpdate(data);
+                break;
+            default:
+                // Emit raw event for unhandled types
+                this.emit('raw', { t: eventType, d: data });
+        }
+    }
+    /**
+     * Handle Ready event
+     */
+    handleReady(data) {
+        this.sessionId = data.session_id;
+        this.user = new User_1.User(data.user);
+        // Handle both string and number application IDs
+        this.applicationId = data.application?.id ? String(data.application.id) : null;
+        if (this.applicationId) {
+            this.rest.setApplicationId(this.applicationId);
+        }
+        // Cache guilds (as unavailable initially)
+        if (data.guilds) {
+            for (const guild of data.guilds) {
+                this.guilds.set(String(guild.id), new Guild_1.Guild(this, guild));
+            }
+        }
+        // Setup voice adapters for each guild
+        this.setupVoiceAdapters();
+        console.log(`✅ Bot hazır! User: ${this.user.username} (${this.user.id}), App: ${this.applicationId}`);
+        this.emit('ready', this);
+    }
+    /**
+     * Setup voice adapters for all guilds
+     */
+    setupVoiceAdapters() {
+        for (const [guildId] of this.guilds) {
+            this.createVoiceAdapter(guildId);
+        }
+    }
+    /**
+     * Create a voice adapter for a guild
+     */
+    createVoiceAdapter(guildId) {
+        const adapter = (methods) => {
+            // Store handlers for this guild
+            this.voiceStateHandlers.set(guildId, methods.onVoiceStateUpdate);
+            this.voiceServerHandlers.set(guildId, methods.onVoiceServerUpdate);
+            return {
+                sendPayload: (payload) => {
+                    if (this.ws?.readyState === ws_1.default.OPEN) {
+                        this.ws.send(JSON.stringify(payload));
+                        return true;
+                    }
+                    return false;
+                },
+                destroy: () => {
+                    this.voiceStateHandlers.delete(guildId);
+                    this.voiceServerHandlers.delete(guildId);
+                }
+            };
+        };
+        this.voice.adapters.set(guildId, adapter);
+    }
+    /**
+     * Handle Guild Create event
+     */
+    handleGuildCreate(data) {
+        let guild = this.guilds.get(data.id);
+        if (guild) {
+            guild._patch(data);
+        }
+        else {
+            guild = new Guild_1.Guild(this, data);
+            this.guilds.set(data.id, guild);
+            this.createVoiceAdapter(data.id);
+        }
+        this.emit('guildCreate', guild);
+    }
+    /**
+     * Handle Guild Update event
+     */
+    handleGuildUpdate(data) {
+        const guild = this.guilds.get(data.id);
+        if (guild) {
+            guild._patch(data);
+            this.emit('guildUpdate', guild);
+        }
+    }
+    /**
+     * Handle Guild Delete event
+     */
+    handleGuildDelete(data) {
+        const guild = this.guilds.get(data.id);
+        if (guild) {
+            this.guilds.delete(data.id);
+            this.voice.adapters.delete(data.id);
+            this.emit('guildDelete', guild);
+        }
+    }
+    /**
+     * Handle Message Create event
+     */
+    handleMessageCreate(data) {
+        // Backend sends user_id separately, map it to author.id for compatibility
+        if (data.user_id && data.author && !data.author.id) {
+            data.author.id = data.user_id;
+        }
+        // Cache the author
+        if (data.author) {
+            const user = new User_1.User(data.author);
+            this.users.set(user.id, user);
+            // Also cache in REST for mention resolution
+            this.rest.cacheUser(data.author);
+        }
+        const message = new Message_1.Message(this, data);
+        this.emit('messageCreate', message);
+    }
+    /**
+     * Handle Interaction Create event
+     */
+    handleInteractionCreate(data) {
+        console.log('[DEBUG] handleInteractionCreate called with:', JSON.stringify(data, null, 2));
+        // Cache the user
+        const userData = data.member?.user || data.user;
+        if (userData) {
+            const user = new User_1.User(userData);
+            this.users.set(user.id, user);
+            this.rest.cacheUser(userData);
+        }
+        const interaction = (0, Interaction_1.createInteraction)(this, data);
+        console.log('[DEBUG] Created interaction type:', interaction.constructor.name, 'customId:', interaction.customId);
+        this.emit('interactionCreate', interaction);
+    }
+    /**
+     * Handle Voice State Update event
+     */
+    handleVoiceStateUpdate(data) {
+        const guildId = data.guild_id;
+        // Forward to voice adapter if exists
+        const handler = this.voiceStateHandlers.get(guildId);
+        if (handler) {
+            handler(data);
+        }
+        this.emit('voiceStateUpdate', data);
+    }
+    /**
+     * Handle Voice Server Update event
+     */
+    handleVoiceServerUpdate(data) {
+        const guildId = data.guild_id;
+        // Forward to voice adapter if exists
+        const handler = this.voiceServerHandlers.get(guildId);
+        if (handler) {
+            handler({
+                token: data.token,
+                endpoint: data.endpoint,
+                room: data.room
+            });
+        }
+        this.emit('voiceServerUpdate', data);
+    }
+    /**
+     * Send Identify payload
+     */
+    identify() {
+        const payload = {
+            op: enums_1.GatewayOpcodes.Identify,
+            d: {
+                token: `Bot ${this.token}`,
+                intents: this.getIntentsValue(),
+                shard: this.options.shards || [0, 1]
+            }
+        };
+        this.send(payload);
+    }
+    /**
+     * Start heartbeat
+     */
+    startHeartbeat(interval) {
+        this.heartbeatInterval = setInterval(() => {
+            this.send({
+                op: enums_1.GatewayOpcodes.Heartbeat,
+                d: this.sequence
+            });
+        }, interval);
+    }
+    /**
+     * Send payload to gateway
+     */
+    send(payload) {
+        if (this.ws?.readyState === ws_1.default.OPEN) {
+            this.ws.send(JSON.stringify(payload));
+        }
+    }
+    /**
+     * Cleanup on disconnect
+     */
+    cleanup() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+    }
+    /**
+     * Destroy the client
+     */
+    destroy() {
+        this.cleanup();
+        this.ws?.close(1000);
+        this.ws = null;
+        this.removeAllListeners();
+    }
+}
+exports.Client = Client;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Client.js","sourceRoot":"","sources":["../src/Client.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitter } from 'events';\r\nimport WebSocket from 'ws';\r\nimport { \r\n  ClientOptions, \r\n  GatewayPayload, \r\n  ReadyEventData,\r\n  APIGuild,\r\n  APIInteraction,\r\n  APIMessage,\r\n  APIVoiceServerUpdate,\r\n  APIChannel,\r\n  APIUser\r\n} from './types';\r\nimport { GatewayOpcodes, GatewayIntentBits } from './enums';\r\nimport { Collection } from './structures/Collection';\r\nimport { User } from './structures/User';\r\nimport { Guild } from './structures/Guild';\r\nimport { Message } from './structures/Message';\r\nimport { createInteraction, Interaction } from './structures/Interaction';\r\nimport { BaseChannel, createChannel } from './structures/Channel';\r\nimport { REST } from './rest/REST';\r\n\r\n/**\r\n * Voice adapter creator type for @jubbio/voice compatibility\r\n */\r\ntype VoiceAdapterCreator = (methods: {\r\n  onVoiceServerUpdate(data: any): void;\r\n  onVoiceStateUpdate(data: any): void;\r\n  destroy(): void;\r\n}) => {\r\n  sendPayload(payload: any): boolean;\r\n  destroy(): void;\r\n};\r\n\r\n/**\r\n * Main client class\r\n */\r\nexport class Client extends EventEmitter {\r\n  /** Client options */\r\n  public readonly options: ClientOptions;\r\n  \r\n  /** REST API client */\r\n  public readonly rest: REST;\r\n  \r\n  /** The bot user */\r\n  public user: User | null = null;\r\n  \r\n  /** Application ID */\r\n  public applicationId: string | null = null;\r\n  \r\n  /** Cached guilds */\r\n  public guilds: Collection<string, Guild> = new Collection();\r\n  \r\n  /** Cached channels */\r\n  public channels: Collection<string, BaseChannel> = new Collection();\r\n  \r\n  /** Cached users */\r\n  public users: Collection<string, User> = new Collection();\r\n  \r\n  /** Voice adapter management */\r\n  public voice: {\r\n    adapters: Map<string, VoiceAdapterCreator>;\r\n  };\r\n  \r\n  /** WebSocket connection */\r\n  private ws: WebSocket | null = null;\r\n  \r\n  /** Bot token */\r\n  private token: string = '';\r\n  \r\n  /** Session ID */\r\n  private sessionId: string | null = null;\r\n  \r\n  /** Sequence number */\r\n  private sequence: number | null = null;\r\n  \r\n  /** Heartbeat interval */\r\n  private heartbeatInterval: NodeJS.Timeout | null = null;\r\n  \r\n  /** Gateway URL */\r\n  private gatewayUrl: string;\r\n  \r\n  /** Voice state update handlers (for voice adapters) */\r\n  private voiceStateHandlers: Map<string, (data: any) => void> = new Map();\r\n  private voiceServerHandlers: Map<string, (data: any) => void> = new Map();\r\n\r\n  constructor(options: ClientOptions) {\r\n    super();\r\n    this.options = options;\r\n    this.gatewayUrl = options.gatewayUrl || 'ws://localhost:5003/ws/bot';\r\n    this.rest = new REST(options.apiUrl);\r\n    \r\n    // Initialize voice adapter system\r\n    this.voice = {\r\n      adapters: new Map()\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Calculate intents value\r\n   */\r\n  private getIntentsValue(): number {\r\n    if (typeof this.options.intents === 'number') {\r\n      return this.options.intents;\r\n    }\r\n    return this.options.intents.reduce((acc, intent) => acc | intent, 0);\r\n  }\r\n\r\n  /**\r\n   * Login to the gateway\r\n   */\r\n  async login(token: string): Promise<string> {\r\n    this.token = token.replace(/^Bot\\s+/i, '');\r\n    this.rest.setToken(this.token);\r\n    \r\n    return new Promise((resolve, reject) => {\r\n      this.connect();\r\n      \r\n      // Wait for ready event\r\n      const timeout = setTimeout(() => {\r\n        reject(new Error('Login timeout'));\r\n      }, 30000);\r\n      \r\n      this.once('ready', () => {\r\n        clearTimeout(timeout);\r\n        resolve(this.token);\r\n      });\r\n      \r\n      this.once('error', (error) => {\r\n        clearTimeout(timeout);\r\n        reject(error);\r\n      });\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Connect to the gateway\r\n   */\r\n  private connect(): void {\r\n    this.ws = new WebSocket(this.gatewayUrl);\r\n    \r\n    this.ws.on('open', () => {\r\n      this.emit('debug', 'WebSocket connection opened');\r\n    });\r\n    \r\n    this.ws.on('message', (data) => {\r\n      this.handleMessage(data.toString());\r\n    });\r\n    \r\n    this.ws.on('close', (code, reason) => {\r\n      this.emit('debug', `WebSocket closed: ${code} - ${reason}`);\r\n      this.cleanup();\r\n      \r\n      // Reconnect on certain close codes\r\n      if (code !== 1000 && code !== 4004) {\r\n        setTimeout(() => this.connect(), 5000);\r\n      }\r\n    });\r\n    \r\n    this.ws.on('error', (error) => {\r\n      this.emit('error', error);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Handle incoming gateway message\r\n   */\r\n  private handleMessage(data: string): void {\r\n    // Handle multiple messages in one frame\r\n    const messages = data.split('\\n').filter(m => m.trim());\r\n    \r\n    for (const msg of messages) {\r\n      try {\r\n        const payload: GatewayPayload = JSON.parse(msg);\r\n        this.handlePayload(payload);\r\n      } catch (e) {\r\n        this.emit('debug', `Failed to parse message: ${msg}`);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Handle gateway payload\r\n   */\r\n  private handlePayload(payload: GatewayPayload): void {\r\n    if (payload.s) {\r\n      this.sequence = payload.s;\r\n    }\r\n\r\n    switch (payload.op) {\r\n      case GatewayOpcodes.Hello:\r\n        this.handleHello(payload.d);\r\n        break;\r\n        \r\n      case GatewayOpcodes.Dispatch:\r\n        this.handleDispatch(payload.t!, payload.d);\r\n        break;\r\n        \r\n      case GatewayOpcodes.HeartbeatAck:\r\n        this.emit('debug', 'Heartbeat acknowledged');\r\n        break;\r\n        \r\n      case GatewayOpcodes.InvalidSession:\r\n        this.emit('debug', 'Invalid session, re-identifying...');\r\n        setTimeout(() => this.identify(), 5000);\r\n        break;\r\n        \r\n      case GatewayOpcodes.Reconnect:\r\n        this.emit('debug', 'Reconnect requested');\r\n        this.ws?.close();\r\n        setTimeout(() => this.connect(), 1000);\r\n        break;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Handle Hello payload\r\n   */\r\n  private handleHello(data: { heartbeat_interval: number }): void {\r\n    this.emit('debug', `Received Hello, heartbeat interval: ${data.heartbeat_interval}ms`);\r\n    this.startHeartbeat(data.heartbeat_interval);\r\n    this.identify();\r\n  }\r\n\r\n  /**\r\n   * Handle Dispatch events\r\n   */\r\n  private handleDispatch(eventType: string, data: any): void {\r\n    this.emit('debug', `Dispatch: ${eventType}`);\r\n    \r\n    switch (eventType) {\r\n      case 'READY':\r\n        this.handleReady(data);\r\n        break;\r\n        \r\n      case 'GUILD_CREATE':\r\n        this.handleGuildCreate(data);\r\n        break;\r\n        \r\n      case 'GUILD_UPDATE':\r\n        this.handleGuildUpdate(data);\r\n        break;\r\n        \r\n      case 'GUILD_DELETE':\r\n        this.handleGuildDelete(data);\r\n        break;\r\n        \r\n      case 'MESSAGE_CREATE':\r\n        this.handleMessageCreate(data);\r\n        break;\r\n        \r\n      case 'MESSAGE_UPDATE':\r\n        this.emit('messageUpdate', data);\r\n        break;\r\n        \r\n      case 'MESSAGE_DELETE':\r\n        this.emit('messageDelete', data);\r\n        break;\r\n        \r\n      case 'MESSAGE_DELETE_BULK':\r\n        this.emit('messageDeleteBulk', data);\r\n        break;\r\n        \r\n      case 'CHANNEL_CREATE':\r\n        this.emit('channelCreate', data);\r\n        break;\r\n        \r\n      case 'CHANNEL_UPDATE':\r\n        this.emit('channelUpdate', data);\r\n        break;\r\n        \r\n      case 'CHANNEL_DELETE':\r\n        this.emit('channelDelete', data);\r\n        break;\r\n        \r\n      case 'GUILD_MEMBER_ADD':\r\n        this.emit('guildMemberAdd', data);\r\n        break;\r\n        \r\n      case 'GUILD_MEMBER_UPDATE':\r\n        this.emit('guildMemberUpdate', data);\r\n        break;\r\n        \r\n      case 'GUILD_MEMBER_REMOVE':\r\n        this.emit('guildMemberRemove', data);\r\n        break;\r\n        \r\n      case 'GUILD_ROLE_CREATE':\r\n        this.emit('roleCreate', data);\r\n        break;\r\n        \r\n      case 'GUILD_ROLE_UPDATE':\r\n        this.emit('roleUpdate', data);\r\n        break;\r\n        \r\n      case 'GUILD_ROLE_DELETE':\r\n        this.emit('roleDelete', data);\r\n        break;\r\n        \r\n      case 'GUILD_BAN_ADD':\r\n        this.emit('guildBanAdd', data);\r\n        break;\r\n        \r\n      case 'GUILD_BAN_REMOVE':\r\n        this.emit('guildBanRemove', data);\r\n        break;\r\n        \r\n      case 'INVITE_CREATE':\r\n        this.emit('inviteCreate', data);\r\n        break;\r\n        \r\n      case 'INVITE_DELETE':\r\n        this.emit('inviteDelete', data);\r\n        break;\r\n        \r\n      case 'THREAD_CREATE':\r\n        this.emit('threadCreate', data);\r\n        break;\r\n        \r\n      case 'THREAD_UPDATE':\r\n        this.emit('threadUpdate', data);\r\n        break;\r\n        \r\n      case 'THREAD_DELETE':\r\n        this.emit('threadDelete', data);\r\n        break;\r\n        \r\n      case 'TYPING_START':\r\n        this.emit('typingStart', data);\r\n        break;\r\n        \r\n      case 'PRESENCE_UPDATE':\r\n        this.emit('presenceUpdate', data);\r\n        break;\r\n        \r\n      case 'INTERACTION_CREATE':\r\n        this.handleInteractionCreate(data);\r\n        break;\r\n        \r\n      case 'VOICE_STATE_UPDATE':\r\n        this.handleVoiceStateUpdate(data);\r\n        break;\r\n        \r\n      case 'VOICE_SERVER_UPDATE':\r\n        this.handleVoiceServerUpdate(data);\r\n        break;\r\n        \r\n      default:\r\n        // Emit raw event for unhandled types\r\n        this.emit('raw', { t: eventType, d: data });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Handle Ready event\r\n   */\r\n  private handleReady(data: ReadyEventData): void {\r\n    this.sessionId = data.session_id;\r\n    this.user = new User(data.user);\r\n    // Handle both string and number application IDs\r\n    this.applicationId = data.application?.id ? String(data.application.id) : null;\r\n    if (this.applicationId) {\r\n      this.rest.setApplicationId(this.applicationId);\r\n    }\r\n    \r\n    // Cache guilds (as unavailable initially)\r\n    if (data.guilds) {\r\n      for (const guild of data.guilds) {\r\n        this.guilds.set(String(guild.id), new Guild(this, guild));\r\n      }\r\n    }\r\n    \r\n    // Setup voice adapters for each guild\r\n    this.setupVoiceAdapters();\r\n    \r\n    console.log(`✅ Bot hazır! User: ${this.user.username} (${this.user.id}), App: ${this.applicationId}`);\r\n    this.emit('ready', this);\r\n  }\r\n\r\n  /**\r\n   * Setup voice adapters for all guilds\r\n   */\r\n  private setupVoiceAdapters(): void {\r\n    for (const [guildId] of this.guilds) {\r\n      this.createVoiceAdapter(guildId);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Create a voice adapter for a guild\r\n   */\r\n  private createVoiceAdapter(guildId: string): void {\r\n    const adapter: VoiceAdapterCreator = (methods) => {\r\n      // Store handlers for this guild\r\n      this.voiceStateHandlers.set(guildId, methods.onVoiceStateUpdate);\r\n      this.voiceServerHandlers.set(guildId, methods.onVoiceServerUpdate);\r\n      \r\n      return {\r\n        sendPayload: (payload) => {\r\n          if (this.ws?.readyState === WebSocket.OPEN) {\r\n            this.ws.send(JSON.stringify(payload));\r\n            return true;\r\n          }\r\n          return false;\r\n        },\r\n        destroy: () => {\r\n          this.voiceStateHandlers.delete(guildId);\r\n          this.voiceServerHandlers.delete(guildId);\r\n        }\r\n      };\r\n    };\r\n    \r\n    this.voice.adapters.set(guildId, adapter);\r\n  }\r\n\r\n  /**\r\n   * Handle Guild Create event\r\n   */\r\n  private handleGuildCreate(data: APIGuild): void {\r\n    let guild = this.guilds.get(data.id);\r\n    \r\n    if (guild) {\r\n      guild._patch(data);\r\n    } else {\r\n      guild = new Guild(this, data);\r\n      this.guilds.set(data.id, guild);\r\n      this.createVoiceAdapter(data.id);\r\n    }\r\n    \r\n    this.emit('guildCreate', guild);\r\n  }\r\n\r\n  /**\r\n   * Handle Guild Update event\r\n   */\r\n  private handleGuildUpdate(data: APIGuild): void {\r\n    const guild = this.guilds.get(data.id);\r\n    if (guild) {\r\n      guild._patch(data);\r\n      this.emit('guildUpdate', guild);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Handle Guild Delete event\r\n   */\r\n  private handleGuildDelete(data: { id: string }): void {\r\n    const guild = this.guilds.get(data.id);\r\n    if (guild) {\r\n      this.guilds.delete(data.id);\r\n      this.voice.adapters.delete(data.id);\r\n      this.emit('guildDelete', guild);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Handle Message Create event\r\n   */\r\n  private handleMessageCreate(data: APIMessage): void {\r\n    // Backend sends user_id separately, map it to author.id for compatibility\r\n    if (data.user_id && data.author && !data.author.id) {\r\n      (data.author as any).id = data.user_id;\r\n    }\r\n    \r\n    // Cache the author\r\n    if (data.author) {\r\n      const user = new User(data.author);\r\n      this.users.set(user.id, user);\r\n      // Also cache in REST for mention resolution\r\n      this.rest.cacheUser(data.author);\r\n    }\r\n    \r\n    const message = new Message(this, data);\r\n    this.emit('messageCreate', message);\r\n  }\r\n\r\n  /**\r\n   * Handle Interaction Create event\r\n   */\r\n  private handleInteractionCreate(data: APIInteraction): void {\r\n    console.log('[DEBUG] handleInteractionCreate called with:', JSON.stringify(data, null, 2));\r\n    \r\n    // Cache the user\r\n    const userData = data.member?.user || data.user;\r\n    if (userData) {\r\n      const user = new User(userData);\r\n      this.users.set(user.id, user);\r\n      this.rest.cacheUser(userData);\r\n    }\r\n    \r\n    const interaction = createInteraction(this, data);\r\n    console.log('[DEBUG] Created interaction type:', interaction.constructor.name, 'customId:', (interaction as any).customId);\r\n    this.emit('interactionCreate', interaction);\r\n  }\r\n\r\n  /**\r\n   * Handle Voice State Update event\r\n   */\r\n  private handleVoiceStateUpdate(data: any): void {\r\n    const guildId = data.guild_id;\r\n    \r\n    // Forward to voice adapter if exists\r\n    const handler = this.voiceStateHandlers.get(guildId);\r\n    if (handler) {\r\n      handler(data);\r\n    }\r\n    \r\n    this.emit('voiceStateUpdate', data);\r\n  }\r\n\r\n  /**\r\n   * Handle Voice Server Update event\r\n   */\r\n  private handleVoiceServerUpdate(data: APIVoiceServerUpdate): void {\r\n    const guildId = data.guild_id;\r\n    \r\n    // Forward to voice adapter if exists\r\n    const handler = this.voiceServerHandlers.get(guildId);\r\n    if (handler) {\r\n      handler({\r\n        token: data.token,\r\n        endpoint: data.endpoint,\r\n        room: data.room\r\n      });\r\n    }\r\n    \r\n    this.emit('voiceServerUpdate', data);\r\n  }\r\n\r\n  /**\r\n   * Send Identify payload\r\n   */\r\n  private identify(): void {\r\n    const payload: GatewayPayload = {\r\n      op: GatewayOpcodes.Identify,\r\n      d: {\r\n        token: `Bot ${this.token}`,\r\n        intents: this.getIntentsValue(),\r\n        shard: this.options.shards || [0, 1]\r\n      }\r\n    };\r\n    \r\n    this.send(payload);\r\n  }\r\n\r\n  /**\r\n   * Start heartbeat\r\n   */\r\n  private startHeartbeat(interval: number): void {\r\n    this.heartbeatInterval = setInterval(() => {\r\n      this.send({\r\n        op: GatewayOpcodes.Heartbeat,\r\n        d: this.sequence\r\n      });\r\n    }, interval);\r\n  }\r\n\r\n  /**\r\n   * Send payload to gateway\r\n   */\r\n  private send(payload: GatewayPayload): void {\r\n    if (this.ws?.readyState === WebSocket.OPEN) {\r\n      this.ws.send(JSON.stringify(payload));\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Cleanup on disconnect\r\n   */\r\n  private cleanup(): void {\r\n    if (this.heartbeatInterval) {\r\n      clearInterval(this.heartbeatInterval);\r\n      this.heartbeatInterval = null;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Destroy the client\r\n   */\r\n  destroy(): void {\r\n    this.cleanup();\r\n    this.ws?.close(1000);\r\n    this.ws = null;\r\n    this.removeAllListeners();\r\n  }\r\n}\r\n\r\n// Re-export for convenience\r\nexport { GatewayIntentBits };\r\n"]}

package/dist/builders/ActionRowBuilder.d.ts

@@ -0,0 +1,53 @@
+/**
+ * ActionRowBuilder for creating component rows
+ */
+import { APIButtonComponent } from './ButtonBuilder';
+import { APISelectMenuComponent } from './SelectMenuBuilder';
+export type APIActionRowComponent = APIButtonComponent | APISelectMenuComponent;
+export interface APIActionRow {
+    type: 1;
+    components: APIActionRowComponent[];
+}
+/**
+ * A builder for creating action rows
+ */
+export declare class ActionRowBuilder<T extends APIActionRowComponent = APIActionRowComponent> {
+    readonly data: {
+        type: 1;
+        components: T[];
+    };
+    constructor(data?: Partial<APIActionRow>);
+    /**
+     * Adds components to this action row
+     * @param components The components to add
+     */
+    addComponents(...components: (T | {
+        toJSON(): T;
+    })[]): this;
+    /**
+     * Sets the components of this action row
+     * @param components The components to set
+     */
+    setComponents(...components: (T | {
+        toJSON(): T;
+    })[]): this;
+    /**
+     * Removes, replaces, or inserts components
+     * @param index The index to start at
+     * @param deleteCount The number of components to remove
+     * @param components The components to insert
+     */
+    spliceComponents(index: number, deleteCount: number, ...components: (T | {
+        toJSON(): T;
+    })[]): this;
+    /**
+     * Returns the JSON representation of this action row
+     */
+    toJSON(): APIActionRow;
+    /**
+     * Creates a new action row builder from existing data
+     * @param other The action row data to copy
+     */
+    static from<T extends APIActionRowComponent>(other: Partial<APIActionRow> | ActionRowBuilder<T>): ActionRowBuilder<T>;
+}
+export default ActionRowBuilder;