seyfert 1.4.0 → 2.0.0

package/lib/client/index.d.ts

@@ -2,3 +2,4 @@ export type { RuntimeConfig, RuntimeConfigHTTP } from './base';
 export * from './client';
 export * from './httpclient';
 export * from './workerclient';
+export * from './transformers';

package/lib/client/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./client"), exports);
 __exportStar(require("./httpclient"), exports);
 __exportStar(require("./workerclient"), exports);
+__exportStar(require("./transformers"), exports);

package/lib/client/transformers.d.ts

@@ -0,0 +1,68 @@
+import type { ChannelType } from '../types';
+import { type CustomStructures, OptionResolver } from '../commands';
+import { AnonymousGuild, AutoModerationRule, BaseChannel, BaseGuildChannel, CategoryChannel, ClientUser, DMChannel, DirectoryChannel, ForumChannel, Guild, GuildEmoji, GuildMember, GuildRole, GuildTemplate, InteractionGuildMember, MediaChannel, Message, NewsChannel, Poll, StageChannel, Sticker, TextGuildChannel, ThreadChannel, User, VoiceChannel, VoiceState, Webhook, WebhookMessage } from '../structures';
+import type { StructStates } from '../common/';
+import { GuildBan } from '../structures/GuildBan';
+export type PollStructure = InferCustomStructure<Poll, 'Poll'>;
+export type ClientUserStructure = InferCustomStructure<ClientUser, 'ClientUser'>;
+export type AnonymousGuildStructure = InferCustomStructure<AnonymousGuild, 'AnonymousGuild'>;
+export type AutoModerationRuleStructure = InferCustomStructure<AutoModerationRule, 'AutoModerationRule'>;
+export type BaseChannelStructure = InferCustomStructure<BaseChannel<ChannelType>, 'BaseChannel'>;
+export type BaseGuildChannelStructure = InferCustomStructure<BaseGuildChannel, 'BaseGuildChannel'>;
+export type TextGuildChannelStructure = InferCustomStructure<TextGuildChannel, 'TextGuildChannel'>;
+export type DMChannelStructure = InferCustomStructure<DMChannel, 'DMChannel'>;
+export type VoiceChannelStructure = InferCustomStructure<VoiceChannel, 'VoiceChannel'>;
+export type StageChannelStructure = InferCustomStructure<StageChannel, 'StageChannel'>;
+export type MediaChannelStructure = InferCustomStructure<MediaChannel, 'MediaChannel'>;
+export type ForumChannelStructure = InferCustomStructure<ForumChannel, 'ForumChannel'>;
+export type ThreadChannelStructure = InferCustomStructure<ThreadChannel, 'ThreadChannel'>;
+export type CategoryChannelStructure = InferCustomStructure<CategoryChannel, 'CategoryChannel'>;
+export type NewsChannelStructure = InferCustomStructure<NewsChannel, 'NewsChannel'>;
+export type DirectoryChannelStructure = InferCustomStructure<DirectoryChannel, 'DirectoryChannel'>;
+export type GuildStructure<State extends StructStates = 'api'> = InferCustomStructure<Guild<State>, 'Guild'>;
+export type GuildBanStructure = InferCustomStructure<GuildBan, 'GuildBan'>;
+export type GuildEmojiStructure = InferCustomStructure<GuildEmoji, 'GuildEmoji'>;
+export type GuildMemberStructure = InferCustomStructure<GuildMember, 'GuildMember'>;
+export type InteractionGuildMemberStructure = InferCustomStructure<InteractionGuildMember, 'InteractionGuildMember'>;
+export type GuildRoleStructure = InferCustomStructure<GuildRole, 'GuildRole'>;
+export type GuildTemplateStructure = InferCustomStructure<GuildTemplate, 'GuildTemplate'>;
+export type MessageStructure = InferCustomStructure<Message, 'Message'>;
+export type WebhookMessageStructure = InferCustomStructure<WebhookMessage, 'WebhookMessage'>;
+export type StickerStructure = InferCustomStructure<Sticker, 'Sticker'>;
+export type UserStructure = InferCustomStructure<User, 'User'>;
+export type VoiceStateStructure = InferCustomStructure<VoiceState, 'VoiceState'>;
+export type WebhookStructure = InferCustomStructure<Webhook, 'Webhook'>;
+export type OptionResolverStructure = InferCustomStructure<OptionResolver, 'OptionResolver'>;
+export declare class Transformers {
+    static AnonymousGuild(...args: ConstructorParameters<typeof AnonymousGuild>): AnonymousGuildStructure;
+    static AutoModerationRule(...args: ConstructorParameters<typeof AutoModerationRule>): AutoModerationRuleStructure;
+    static BaseChannel(...args: ConstructorParameters<typeof BaseChannel>): BaseChannelStructure;
+    static BaseGuildChannel(...args: ConstructorParameters<typeof BaseGuildChannel>): BaseGuildChannelStructure;
+    static TextGuildChannel(...args: ConstructorParameters<typeof TextGuildChannel>): TextGuildChannelStructure;
+    static DMChannel(...args: ConstructorParameters<typeof DMChannel>): DMChannelStructure;
+    static VoiceChannel(...args: ConstructorParameters<typeof VoiceChannel>): VoiceChannelStructure;
+    static StageChannel(...args: ConstructorParameters<typeof StageChannel>): StageChannelStructure;
+    static MediaChannel(...args: ConstructorParameters<typeof MediaChannel>): MediaChannelStructure;
+    static ForumChannel(...args: ConstructorParameters<typeof ForumChannel>): ForumChannelStructure;
+    static ThreadChannel(...args: ConstructorParameters<typeof ThreadChannel>): ThreadChannelStructure;
+    static CategoryChannel(...args: ConstructorParameters<typeof CategoryChannel>): CategoryChannelStructure;
+    static NewsChannel(...args: ConstructorParameters<typeof NewsChannel>): NewsChannelStructure;
+    static DirectoryChannel(...args: ConstructorParameters<typeof DirectoryChannel>): DirectoryChannelStructure;
+    static ClientUser(...args: ConstructorParameters<typeof ClientUser>): ClientUserStructure;
+    static Guild<State extends StructStates = 'api'>(...args: ConstructorParameters<typeof Guild>): GuildStructure<State>;
+    static GuildBan(...args: ConstructorParameters<typeof GuildBan>): GuildBanStructure;
+    static GuildEmoji(...args: ConstructorParameters<typeof GuildEmoji>): GuildEmojiStructure;
+    static GuildMember(...args: ConstructorParameters<typeof GuildMember>): GuildMemberStructure;
+    static InteractionGuildMember(...args: ConstructorParameters<typeof InteractionGuildMember>): InteractionGuildMemberStructure;
+    static GuildRole(...args: ConstructorParameters<typeof GuildRole>): GuildRoleStructure;
+    static GuildTemplate(...args: ConstructorParameters<typeof GuildTemplate>): GuildTemplateStructure;
+    static Message(...args: ConstructorParameters<typeof Message>): MessageStructure;
+    static WebhookMessage(...args: ConstructorParameters<typeof WebhookMessage>): WebhookMessageStructure;
+    static Poll(...args: ConstructorParameters<typeof Poll>): PollStructure;
+    static Sticker(...args: ConstructorParameters<typeof Sticker>): StickerStructure;
+    static User(...args: ConstructorParameters<typeof User>): UserStructure;
+    static VoiceState(...args: ConstructorParameters<typeof VoiceState>): VoiceStateStructure;
+    static Webhook(...args: ConstructorParameters<typeof Webhook>): WebhookStructure;
+    static OptionResolver(...args: ConstructorParameters<typeof OptionResolver>): OptionResolverStructure;
+}
+export type InferCustomStructure<T, N extends string> = CustomStructures extends Record<N, infer P> ? P : T;

package/lib/client/transformers.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transformers = void 0;
+const commands_1 = require("../commands");
+const structures_1 = require("../structures");
+const GuildBan_1 = require("../structures/GuildBan");
+class Transformers {
+    static AnonymousGuild(...args) {
+        return new structures_1.AnonymousGuild(...args);
+    }
+    static AutoModerationRule(...args) {
+        return new structures_1.AutoModerationRule(...args);
+    }
+    static BaseChannel(...args) {
+        return new structures_1.BaseChannel(...args);
+    }
+    static BaseGuildChannel(...args) {
+        return new structures_1.BaseGuildChannel(...args);
+    }
+    static TextGuildChannel(...args) {
+        return new structures_1.TextGuildChannel(...args);
+    }
+    static DMChannel(...args) {
+        return new structures_1.DMChannel(...args);
+    }
+    static VoiceChannel(...args) {
+        return new structures_1.VoiceChannel(...args);
+    }
+    static StageChannel(...args) {
+        return new structures_1.StageChannel(...args);
+    }
+    static MediaChannel(...args) {
+        return new structures_1.MediaChannel(...args);
+    }
+    static ForumChannel(...args) {
+        return new structures_1.ForumChannel(...args);
+    }
+    static ThreadChannel(...args) {
+        return new structures_1.ThreadChannel(...args);
+    }
+    static CategoryChannel(...args) {
+        return new structures_1.CategoryChannel(...args);
+    }
+    static NewsChannel(...args) {
+        return new structures_1.NewsChannel(...args);
+    }
+    static DirectoryChannel(...args) {
+        return new structures_1.DirectoryChannel(...args);
+    }
+    static ClientUser(...args) {
+        return new structures_1.ClientUser(...args);
+    }
+    static Guild(...args) {
+        return new structures_1.Guild(...args);
+    }
+    static GuildBan(...args) {
+        return new GuildBan_1.GuildBan(...args);
+    }
+    static GuildEmoji(...args) {
+        return new structures_1.GuildEmoji(...args);
+    }
+    static GuildMember(...args) {
+        return new structures_1.GuildMember(...args);
+    }
+    static InteractionGuildMember(...args) {
+        return new structures_1.InteractionGuildMember(...args);
+    }
+    static GuildRole(...args) {
+        return new structures_1.GuildRole(...args);
+    }
+    static GuildTemplate(...args) {
+        return new structures_1.GuildTemplate(...args);
+    }
+    static Message(...args) {
+        return new structures_1.Message(...args);
+    }
+    static WebhookMessage(...args) {
+        return new structures_1.WebhookMessage(...args);
+    }
+    static Poll(...args) {
+        return new structures_1.Poll(...args);
+    }
+    static Sticker(...args) {
+        return new structures_1.Sticker(...args);
+    }
+    static User(...args) {
+        return new structures_1.User(...args);
+    }
+    static VoiceState(...args) {
+        return new structures_1.VoiceState(...args);
+    }
+    static Webhook(...args) {
+        return new structures_1.Webhook(...args);
+    }
+    static OptionResolver(...args) {
+        return new commands_1.OptionResolver(...args);
+    }
+}
+exports.Transformers = Transformers;

package/lib/client/types.d.ts

@@ -0,0 +1,5 @@
+import type { HttpClient } from './httpclient';
+export interface HttpServerAdapter {
+    client: HttpClient;
+    start?(path: `/${string}`): any;
+}

package/lib/client/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/client/workerclient.d.ts

@@ -1,30 +1,30 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import { type GatewayDispatchPayload } from 'discord-api-types/v10';
-import { Logger } from '..';
+import { type GatewayDispatchPayload } from '../types';
 import type { Cache } from '../cache';
 import { type DeepPartial, type When } from '../common';
 import { EventHandler } from '../events';
-import { ClientUser } from '../structures';
-import { Shard, type ShardManagerOptions } from '../websocket';
+import { Shard, type ShardManagerOptions, type WorkerData } from '../websocket';
 import type { WorkerShardInfo } from '../websocket/discord/worker';
 import type { ManagerMessages } from '../websocket/discord/workermanager';
 import type { BaseClientOptions, ServicesOptions, StartOptions } from './base';
 import { BaseClient } from './base';
-import type { Client } from './client';
+import type { Client, ClientOptions } from './client';
+import { Collectors } from './collectors';
+import { type ClientUserStructure } from './transformers';
+import { MemberUpdateHandler } from '../websocket/discord/events/memberUpdate';
+import { PresenceUpdateHandler } from '../websocket/discord/events/presenceUpdate';
 export declare class WorkerClient<Ready extends boolean = boolean> extends BaseClient {
     private __handleGuilds?;
-    logger: Logger;
+    memberUpdateHandler: MemberUpdateHandler;
+    presenceUpdateHandler: PresenceUpdateHandler;
+    collectors: Collectors;
     events?: EventHandler | undefined;
-    me: When<Ready, ClientUser>;
+    me: When<Ready, ClientUserStructure>;
     promises: Map<string, {
         resolve: (value: any) => void;
         timeout: NodeJS.Timeout;
     }>;
     shards: Map<number, Shard>;
+    private __setServicesCache?;
     options: WorkerClientOptions;
     constructor(options?: WorkerClientOptions);
     get workerId(): number;
@@ -34,10 +34,11 @@ export declare class WorkerClient<Ready extends boolean = boolean> extends BaseC
             events?: EventHandler['callback'];
         };
     }): void;
+    setWorkerData(data: WorkerData): void;
     start(options?: Omit<DeepPartial<StartOptions>, 'httpConnection' | 'token' | 'connection'>): Promise<void>;
     loadEvents(dir?: string): Promise<void>;
-    postMessage(body: any): boolean | void;
-    protected handleManagerMessages(data: ManagerMessages): Promise<any>;
+    postMessage(body: unknown): unknown;
+    handleManagerMessages(data: ManagerMessages): Promise<any>;
     private generateNonce;
     private generateSendPromise;
     tellWorker(workerId: number, func: (_: this) => {}): Promise<unknown>;
@@ -45,8 +46,10 @@ export declare class WorkerClient<Ready extends boolean = boolean> extends BaseC
 }
 export declare function generateShardInfo(shard: Shard): WorkerShardInfo;
 interface WorkerClientOptions extends BaseClientOptions {
-    disabledCache: Cache['disabledCache'];
+    disabledCache?: Cache['disabledCache'];
     commands?: NonNullable<Client['options']>['commands'];
     handlePayload?: ShardManagerOptions['handlePayload'];
+    gateway?: ClientOptions['gateway'];
+    postMessage?: (body: unknown) => unknown;
 }
 export {};

package/lib/client/workerclient.js

@@ -1,17 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateShardInfo = exports.WorkerClient = void 0;
-const v10_1 = require("discord-api-types/v10");
+exports.WorkerClient = void 0;
+exports.generateShardInfo = generateShardInfo;
+const types_1 = require("../types");
 const node_crypto_1 = require("node:crypto");
 const __1 = require("..");
 const cache_1 = require("../cache");
 const common_1 = require("../common");
 const events_1 = require("../events");
-const structures_1 = require("../structures");
 const websocket_1 = require("../websocket");
 const base_1 = require("./base");
-const oninteractioncreate_1 = require("./oninteractioncreate");
-const onmessagecreate_1 = require("./onmessagecreate");
+const collectors_1 = require("./collectors");
+const transformers_1 = require("./transformers");
+const memberUpdate_1 = require("../websocket/discord/events/memberUpdate");
+const presenceUpdate_1 = require("../websocket/discord/events/presenceUpdate");
 let workerData;
 let manager;
 try {
@@ -23,52 +25,25 @@ try {
         token: process.env.SEYFERT_WORKER_TOKEN,
         workerId: Number.parseInt(process.env.SEYFERT_WORKER_WORKERID),
         workerProxy: process.env.SEYFERT_WORKER_WORKERPROXY === 'true',
+        totalShards: Number(process.env.SEYFERT_WORKER_TOTALSHARDS),
+        mode: process.env.SEYFERT_WORKER_MODE,
     };
 }
 catch { }
 class WorkerClient extends base_1.BaseClient {
     __handleGuilds = new Set();
-    logger = new __1.Logger({
-        name: `[Worker #${workerData.workerId}]`,
-    });
-    events = new events_1.EventHandler(this.logger);
+    memberUpdateHandler = new memberUpdate_1.MemberUpdateHandler();
+    presenceUpdateHandler = new presenceUpdate_1.PresenceUpdateHandler();
+    collectors = new collectors_1.Collectors();
+    events = new events_1.EventHandler(this);
     me;
     promises = new Map();
     shards = new Map();
+    __setServicesCache;
     constructor(options) {
         super(options);
-        if (!process.env.SEYFERT_SPAWNING) {
-            throw new Error('WorkerClient cannot spawn without manager');
-        }
-        this.postMessage({
-            type: 'WORKER_START',
-            workerId: workerData.workerId,
-        });
-        const worker_threads = (0, common_1.lazyLoadPackage)('node:worker_threads');
-        if (worker_threads?.parentPort) {
-            manager = worker_threads?.parentPort;
-        }
-        (manager ?? process).on('message', (data) => this.handleManagerMessages(data));
-        this.setServices({
-            cache: {
-                adapter: new cache_1.WorkerAdapter(workerData),
-                disabledCache: options?.disabledCache,
-            },
-        });
-        if (workerData.debug) {
-            this.debugger = new __1.Logger({
-                name: `[Worker #${workerData.workerId}]`,
-                logLevel: common_1.LogLevels.Debug,
-            });
-        }
-        if (workerData.workerProxy) {
-            this.setServices({
-                rest: new __1.ApiHandler({
-                    token: workerData.token,
-                    workerProxy: true,
-                    debug: workerData.debug,
-                }),
-            });
+        if (options?.postMessage) {
+            this.postMessage = options.postMessage;
         }
     }
     get workerId() {
@@ -81,22 +56,73 @@ class WorkerClient extends base_1.BaseClient {
     }
     setServices({ ...rest }) {
         super.setServices(rest);
+        if (rest.cache) {
+            this.__setServicesCache = true;
+        }
         if (rest.handlers && 'events' in rest.handlers) {
             if (!rest.handlers.events) {
                 this.events = undefined;
             }
             else if (typeof rest.handlers.events === 'function') {
-                this.events = new events_1.EventHandler(this.logger);
-                this.events.setHandlers({
-                    callback: rest.handlers.events,
-                });
+                this.events = new events_1.EventHandler(this);
             }
             else {
                 this.events = rest.handlers.events;
             }
         }
     }
+    setWorkerData(data) {
+        workerData = data;
+    }
     async start(options = {}) {
+        const worker_threads = (0, common_1.lazyLoadPackage)('node:worker_threads');
+        if (worker_threads?.parentPort) {
+            manager = worker_threads?.parentPort;
+        }
+        if (workerData.mode !== 'custom')
+            (manager ?? process).on('message', (data) => this.handleManagerMessages(data));
+        this.logger = new __1.Logger({
+            name: `[Worker #${workerData.workerId}]`,
+        });
+        if (this.__setServicesCache) {
+            this.setServices({
+                cache: {
+                    disabledCache: this.options.disabledCache,
+                },
+            });
+        }
+        else {
+            const adapter = new cache_1.WorkerAdapter(workerData);
+            if (this.options.postMessage) {
+                adapter.postMessage = this.options.postMessage;
+            }
+            this.setServices({
+                cache: {
+                    adapter,
+                    disabledCache: this.options.disabledCache,
+                },
+            });
+        }
+        delete this.__setServicesCache;
+        if (workerData.debug) {
+            this.debugger = new __1.Logger({
+                name: `[Worker #${workerData.workerId}]`,
+                logLevel: common_1.LogLevels.Debug,
+            });
+        }
+        if (workerData.workerProxy) {
+            this.setServices({
+                rest: new __1.ApiHandler({
+                    token: workerData.token,
+                    workerProxy: true,
+                    debug: workerData.debug,
+                }),
+            });
+        }
+        this.postMessage({
+            type: 'WORKER_START',
+            workerId: workerData.workerId,
+        });
         await super.start(options);
         await this.loadEvents(options.eventsDir);
         this.cache.intents = workerData.intents;
@@ -165,9 +191,12 @@ class WorkerClient extends base_1.BaseClient {
                                 info: data.info,
                                 compress: data.compress,
                                 debugger: this.debugger,
+                                properties: {
+                                    ...websocket_1.properties,
+                                    ...this.options.gateway?.properties,
+                                },
                                 async handlePayload(shardId, payload) {
                                     await handlePayload?.(shardId, payload);
-                                    await self.cache.onPacket(payload);
                                     await onPacket?.(payload, shardId);
                                     self.postMessage({
                                         workerId: workerData.workerId,
@@ -230,9 +259,8 @@ class WorkerClient extends base_1.BaseClient {
                 {
                     let result;
                     try {
-                        // biome-ignore lint/security/noGlobalEval: yes
-                        result = await eval(`
-					(${data.func})(this)
+                        result = await eval(`
+					(${data.func})(this)
 					`);
                     }
                     catch (e) {
@@ -286,76 +314,87 @@ class WorkerClient extends base_1.BaseClient {
         return this.generateSendPromise(nonce);
     }
     async onPacket(packet, shardId) {
-        await this.events?.execute('RAW', packet, this, shardId);
+        Promise.allSettled([
+            this.events?.runEvent('RAW', this, packet, shardId, false),
+            this.collectors.run('RAW', packet, this),
+        ]); //ignore promise
         switch (packet.t) {
+            //// Cases where we must obtain the old data before updating
             case 'GUILD_MEMBER_UPDATE':
+                {
+                    if (!this.memberUpdateHandler.check(packet.d)) {
+                        return;
+                    }
+                    await this.events?.execute(packet.t, packet, this, shardId);
+                }
+                break;
             case 'PRESENCE_UPDATE':
-            case 'MESSAGE_UPDATE':
-            case 'MESSAGE_DELETE_BULK':
-            case 'MESSAGE_DELETE':
+                {
+                    if (!this.presenceUpdateHandler.check(packet.d)) {
+                        return;
+                    }
+                    await this.events?.execute(packet.t, packet, this, shardId);
+                }
+                break;
             case 'GUILD_DELETE':
-            case 'CHANNEL_UPDATE':
-            case 'GUILD_EMOJIS_UPDATE':
-            case 'GUILD_UPDATE':
-            case 'GUILD_ROLE_UPDATE':
-            case 'GUILD_ROLE_DELETE':
-            case 'THREAD_UPDATE':
-            case 'USER_UPDATE':
-            case 'VOICE_STATE_UPDATE':
-            case 'STAGE_INSTANCE_UPDATE':
-            case 'GUILD_STICKERS_UPDATE':
+            case 'GUILD_CREATE': {
+                if (this.__handleGuilds?.has(packet.d.id)) {
+                    this.__handleGuilds?.delete(packet.d.id);
+                    if (!this.__handleGuilds?.size && [...this.shards.values()].every(shard => shard.data.session_id)) {
+                        delete this.__handleGuilds;
+                        await this.cache.onPacket?.(packet);
+                        this.postMessage({
+                            type: 'WORKER_READY',
+                            workerId: this.workerId,
+                        });
+                        return this.events?.runEvent('WORKER_READY', this, this.me, -1);
+                    }
+                    if (!this.__handleGuilds?.size)
+                        delete this.__handleGuilds;
+                    return this.cache.onPacket?.(packet);
+                }
                 await this.events?.execute(packet.t, packet, this, shardId);
-                await this.cache.onPacket(packet);
                 break;
-            //rest of the events
-            default:
-                {
-                    switch (packet.t) {
-                        case 'READY':
-                            for (const g of packet.d.guilds) {
-                                this.__handleGuilds?.add(g.id);
-                            }
-                            this.botId = packet.d.user.id;
-                            this.applicationId = packet.d.application.id;
-                            this.me = new structures_1.ClientUser(this, packet.d.user, packet.d.application);
-                            if (!this.__handleGuilds?.size ||
-                                !((workerData.intents & v10_1.GatewayIntentBits.Guilds) === v10_1.GatewayIntentBits.Guilds)) {
-                                if ([...this.shards.values()].every(shard => shard.data.session_id)) {
-                                    this.postMessage({
-                                        type: 'WORKER_READY',
-                                        workerId: this.workerId,
-                                    });
-                                    await this.events?.runEvent('WORKER_READY', this, this.me, -1);
-                                }
-                                delete this.__handleGuilds;
-                            }
-                            this.debugger?.debug(`#${shardId} [${packet.d.user.username}](${this.botId}) is online...`);
-                            break;
-                        case 'INTERACTION_CREATE':
-                            await (0, oninteractioncreate_1.onInteractionCreate)(this, packet.d, shardId);
-                            break;
-                        case 'MESSAGE_CREATE':
-                            await (0, onmessagecreate_1.onMessageCreate)(this, packet.d, shardId);
-                            break;
-                        case 'GUILD_CREATE': {
-                            if (this.__handleGuilds?.has(packet.d.id)) {
-                                this.__handleGuilds.delete(packet.d.id);
-                                if (!this.__handleGuilds.size && [...this.shards.values()].every(shard => shard.data.session_id)) {
-                                    this.postMessage({
-                                        type: 'WORKER_READY',
-                                        workerId: this.workerId,
-                                    });
-                                    await this.events?.runEvent('WORKER_READY', this, this.me, -1);
-                                }
-                                if (!this.__handleGuilds.size)
-                                    delete this.__handleGuilds;
-                                return;
+            }
+            default: {
+                switch (packet.t) {
+                    case 'INTERACTION_CREATE':
+                        await this.events?.execute(packet.t, packet, this, shardId);
+                        await this.handleCommand.interaction(packet.d, shardId);
+                        break;
+                    case 'MESSAGE_CREATE':
+                        await this.events?.execute(packet.t, packet, this, shardId);
+                        await this.handleCommand.message(packet.d, shardId);
+                        break;
+                    case 'READY':
+                        if (!this.__handleGuilds)
+                            this.__handleGuilds = new Set();
+                        for (const g of packet.d.guilds) {
+                            this.__handleGuilds?.add(g.id);
+                        }
+                        this.botId = packet.d.user.id;
+                        this.applicationId = packet.d.application.id;
+                        this.me = transformers_1.Transformers.ClientUser(this, packet.d.user, packet.d.application);
+                        await this.events?.execute(packet.t, packet, this, shardId);
+                        if (!(this.__handleGuilds?.size &&
+                            (workerData.intents & types_1.GatewayIntentBits.Guilds) === types_1.GatewayIntentBits.Guilds)) {
+                            if ([...this.shards.values()].every(shard => shard.data.session_id)) {
+                                this.postMessage({
+                                    type: 'WORKER_READY',
+                                    workerId: this.workerId,
+                                });
+                                await this.events?.runEvent('WORKER_READY', this, this.me, -1);
                             }
+                            delete this.__handleGuilds;
                         }
-                    }
-                    await this.events?.execute(packet.t, packet, this, shardId);
+                        this.debugger?.debug(`#${shardId}[${packet.d.user.username}](${this.botId}) is online...`);
+                        break;
+                    default:
+                        await this.events?.execute(packet.t, packet, this, shardId);
+                        break;
                 }
                 break;
+            }
         }
     }
 }
@@ -368,4 +407,3 @@ function generateShardInfo(shard) {
         resumable: shard.resumable,
     };
 }
-exports.generateShardInfo = generateShardInfo;

package/lib/collection.d.ts

@@ -229,8 +229,8 @@ export declare class LimitedCollection<K, V> {
     private resetTimeout;
     private stopTimeout;
     private startTimeout;
-    keys(): () => IterableIterator<K>;
-    values(): () => IterableIterator<LimitedCollectionData<V>>;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<LimitedCollectionData<V>>;
     entries(): IterableIterator<[K, LimitedCollectionData<V>]>;
     clear(): void;
     private clearExpired;

package/lib/collection.js

@@ -365,10 +365,10 @@ class LimitedCollection {
         }, expireOn - Date.now());
     }
     keys() {
-        return this.data.keys;
+        return this.data.keys();
     }
     values() {
-        return this.data.values;
+        return this.data.values();
     }
     entries() {
         return this.data.entries();