seyfert 2.0.0 → 2.1.1-dev-11310514874.0

package/lib/client/workerclient.d.ts

@@ -1,19 +1,19 @@
-import { type GatewayDispatchPayload } from '../types';
-import type { Cache } from '../cache';
 import { type DeepPartial, type When } from '../common';
 import { EventHandler } from '../events';
+import { type GatewayDispatchPayload } from '../types';
 import { Shard, type ShardManagerOptions, type WorkerData } from '../websocket';
-import type { WorkerShardInfo } from '../websocket/discord/worker';
+import type { WorkerMessage, 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, 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';
+import { Collectors } from './collectors';
+import { type ClientUserStructure } from './transformers';
 export declare class WorkerClient<Ready extends boolean = boolean> extends BaseClient {
     private __handleGuilds?;
+    private __handleGuildsResharding?;
     memberUpdateHandler: MemberUpdateHandler;
     presenceUpdateHandler: PresenceUpdateHandler;
     collectors: Collectors;
@@ -24,32 +24,32 @@ export declare class WorkerClient<Ready extends boolean = boolean> extends BaseC
         timeout: NodeJS.Timeout;
     }>;
     shards: Map<number, Shard>;
+    resharding: Map<number, Shard>;
+    private _ready?;
     private __setServicesCache?;
     options: WorkerClientOptions;
     constructor(options?: WorkerClientOptions);
     get workerId(): number;
     get latency(): number;
-    setServices({ ...rest }: ServicesOptions & {
-        handlers?: ServicesOptions['handlers'] & {
-            events?: EventHandler['callback'];
-        };
-    }): void;
+    setServices(rest: ServicesOptions): void;
     setWorkerData(data: WorkerData): void;
+    get workerData(): WorkerData;
     start(options?: Omit<DeepPartial<StartOptions>, 'httpConnection' | 'token' | 'connection'>): Promise<void>;
     loadEvents(dir?: string): Promise<void>;
-    postMessage(body: unknown): unknown;
+    postMessage(body: WorkerMessage): unknown;
     handleManagerMessages(data: ManagerMessages): Promise<any>;
     private generateNonce;
     private generateSendPromise;
-    tellWorker(workerId: number, func: (_: this) => {}): Promise<unknown>;
+    tellWorker(workerId: number, func: (_: this) => any): Promise<unknown>;
     protected onPacket(packet: GatewayDispatchPayload, shardId: number): Promise<void>;
 }
 export declare function generateShardInfo(shard: Shard): WorkerShardInfo;
 interface WorkerClientOptions extends BaseClientOptions {
-    disabledCache?: Cache['disabledCache'];
     commands?: NonNullable<Client['options']>['commands'];
     handlePayload?: ShardManagerOptions['handlePayload'];
     gateway?: ClientOptions['gateway'];
     postMessage?: (body: unknown) => unknown;
+    /** can have perfomance issues in big bots if the client sends every event, specially in startup (false by default) */
+    sendPayloadToParent?: boolean;
 }
 export {};

package/lib/client/workerclient.js

@@ -2,18 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 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 types_1 = require("../types");
 const websocket_1 = require("../websocket");
 const base_1 = require("./base");
-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");
+const collectors_1 = require("./collectors");
+const transformers_1 = require("./transformers");
 let workerData;
 let manager;
 try {
@@ -27,11 +27,15 @@ try {
         workerProxy: process.env.SEYFERT_WORKER_WORKERPROXY === 'true',
         totalShards: Number(process.env.SEYFERT_WORKER_TOTALSHARDS),
         mode: process.env.SEYFERT_WORKER_MODE,
+        resharding: process.env.SEYFERT_WORKER_RESHARDING === 'true',
     };
 }
-catch { }
+catch {
+    //
+}
 class WorkerClient extends base_1.BaseClient {
     __handleGuilds = new Set();
+    __handleGuildsResharding;
     memberUpdateHandler = new memberUpdate_1.MemberUpdateHandler();
     presenceUpdateHandler = new presenceUpdate_1.PresenceUpdateHandler();
     collectors = new collectors_1.Collectors();
@@ -39,6 +43,8 @@ class WorkerClient extends base_1.BaseClient {
     me;
     promises = new Map();
     shards = new Map();
+    resharding = new Map();
+    _ready;
     __setServicesCache;
     constructor(options) {
         super(options);
@@ -54,26 +60,18 @@ class WorkerClient extends base_1.BaseClient {
         this.shards.forEach(s => (acc += s.latency));
         return acc / this.shards.size;
     }
-    setServices({ ...rest }) {
+    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);
-            }
-            else {
-                this.events = rest.handlers.events;
-            }
-        }
     }
     setWorkerData(data) {
         workerData = data;
     }
+    get workerData() {
+        return workerData;
+    }
     async start(options = {}) {
         const worker_threads = (0, common_1.lazyLoadPackage)('node:worker_threads');
         if (worker_threads?.parentPort) {
@@ -87,7 +85,7 @@ class WorkerClient extends base_1.BaseClient {
         if (this.__setServicesCache) {
             this.setServices({
                 cache: {
-                    disabledCache: this.options.disabledCache,
+                    disabledCache: this.cache.disabledCache,
                 },
             });
         }
@@ -99,7 +97,7 @@ class WorkerClient extends base_1.BaseClient {
             this.setServices({
                 cache: {
                     adapter,
-                    disabledCache: this.options.disabledCache,
+                    disabledCache: this.cache.disabledCache,
                 },
             });
         }
@@ -120,9 +118,12 @@ class WorkerClient extends base_1.BaseClient {
             });
         }
         this.postMessage({
-            type: 'WORKER_START',
+            type: workerData.resharding ? 'WORKER_START_RESHARDING' : 'WORKER_START',
             workerId: workerData.workerId,
         });
+        if (workerData.resharding) {
+            this.__handleGuildsResharding = new Set();
+        }
         await super.start(options);
         await this.loadEvents(options.eventsDir);
         this.cache.intents = workerData.intents;
@@ -166,6 +167,17 @@ class WorkerClient extends base_1.BaseClient {
                     });
                 }
                 break;
+            case 'ALLOW_CONNECT_RESHARDING':
+                {
+                    const shard = this.resharding.get(data.shardId);
+                    if (!shard) {
+                        this.logger.fatal('Worker trying reshard non-existent shard');
+                        return;
+                    }
+                    shard.options.presence = data.presence;
+                    await shard.connect();
+                }
+                break;
             case 'ALLOW_CONNECT':
                 {
                     const shard = this.shards.get(data.shardId);
@@ -177,37 +189,96 @@ class WorkerClient extends base_1.BaseClient {
                     await shard.connect();
                 }
                 break;
+            case 'SPAWN_SHARDS_RESHARDING':
+                {
+                    let shardsConnected = 0;
+                    const self = this;
+                    for (const id of workerData.shards) {
+                        const existsShard = this.resharding.has(id);
+                        if (existsShard) {
+                            this.logger.warn(`Trying to re-spawn existing shard #${id}`);
+                            continue;
+                        }
+                        const shard = new websocket_1.Shard(id, {
+                            token: workerData.token,
+                            intents: workerData.intents,
+                            info: data.info,
+                            compress: data.compress,
+                            debugger: this.debugger,
+                            properties: {
+                                ...websocket_1.properties,
+                                ...this.options.gateway?.properties,
+                            },
+                            handlePayload(_, payload) {
+                                if (payload.t === 'GUILD_CREATE' || payload.t === 'GUILD_DELETE') {
+                                    self.__handleGuildsResharding.delete(payload.d.id);
+                                    if (!self.__handleGuildsResharding?.size && shardsConnected === workerData.shards.length) {
+                                        delete self.__handleGuildsResharding;
+                                        self.postMessage({
+                                            type: 'WORKER_READY_RESHARDING',
+                                            workerId: workerData.workerId,
+                                        });
+                                    }
+                                }
+                                if (payload.t !== 'READY')
+                                    return;
+                                shardsConnected++;
+                                for (const guild of payload.d.guilds) {
+                                    self.__handleGuildsResharding.add(guild.id);
+                                }
+                                if (shardsConnected === workerData.shards.length &&
+                                    !(0, common_1.hasIntent)(workerData.intents, types_1.GatewayIntentBits.Guilds)) {
+                                    delete self.__handleGuildsResharding;
+                                    self.postMessage({
+                                        type: 'WORKER_READY_RESHARDING',
+                                        workerId: workerData.workerId,
+                                    });
+                                }
+                            },
+                        });
+                        this.resharding.set(id, shard);
+                        this.postMessage({
+                            type: 'CONNECT_QUEUE_RESHARDING',
+                            shardId: id,
+                            workerId: workerData.workerId,
+                        });
+                    }
+                }
+                break;
             case 'SPAWN_SHARDS':
                 {
                     const onPacket = this.onPacket.bind(this);
                     const handlePayload = this.options?.handlePayload?.bind(this);
                     const self = this;
                     for (const id of workerData.shards) {
-                        let shard = this.shards.get(id);
-                        if (!shard) {
-                            shard = new websocket_1.Shard(id, {
-                                token: workerData.token,
-                                intents: workerData.intents,
-                                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 onPacket?.(payload, shardId);
+                        const existsShard = this.shards.has(id);
+                        if (existsShard) {
+                            this.logger.warn(`Trying to spawn existing shard #${id}`);
+                            continue;
+                        }
+                        const shard = new websocket_1.Shard(id, {
+                            token: workerData.token,
+                            intents: workerData.intents,
+                            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 onPacket(payload, shardId);
+                                if (self.options.sendPayloadToParent)
                                     self.postMessage({
                                         workerId: workerData.workerId,
                                         shardId,
                                         type: 'RECEIVE_PAYLOAD',
                                         payload,
                                     });
-                                },
-                            });
-                            this.shards.set(id, shard);
-                        }
+                            },
+                        });
+                        this.shards.set(id, shard);
                         this.postMessage({
                             type: 'CONNECT_QUEUE',
                             shardId: id,
@@ -284,14 +355,47 @@ class WorkerClient extends base_1.BaseClient {
                     evalResponse.resolve(data.response);
                 }
                 break;
+            case 'WORKER_ALREADY_EXISTS_RESHARDING':
+                {
+                    this.__handleGuildsResharding = new Set();
+                    this.postMessage({
+                        type: 'WORKER_START_RESHARDING',
+                        workerId: workerData.workerId,
+                    });
+                }
+                break;
+            case 'DISCONNECT_ALL_SHARDS_RESHARDING':
+                {
+                    for (const i of this.shards.values()) {
+                        await i.disconnect();
+                    }
+                    this.postMessage({
+                        type: 'DISCONNECTED_ALL_SHARDS_RESHARDING',
+                        workerId: workerData.workerId,
+                    });
+                }
+                break;
+            case 'CONNECT_ALL_SHARDS_RESHARDING':
+                {
+                    this.shards.clear();
+                    const handlePayload = this.options?.handlePayload?.bind(this);
+                    for (const [id, shard] of this.resharding) {
+                        this.shards.set(id, shard);
+                        shard.options.handlePayload = async (shardId, packet) => {
+                            await handlePayload?.(shardId, packet);
+                            return this.onPacket(packet, shardId);
+                        };
+                    }
+                    this.resharding.clear();
+                }
+                break;
         }
     }
-    generateNonce(large = true) {
+    generateNonce() {
         const uuid = (0, node_crypto_1.randomUUID)();
-        const nonce = large ? uuid : uuid.split('-')[0];
-        if (this.promises.has(nonce))
-            return this.generateNonce(large);
-        return nonce;
+        if (this.promises.has(uuid))
+            return this.generateNonce();
+        return uuid;
     }
     generateSendPromise(nonce, message = 'Timeout') {
         return new Promise((res, rej) => {
@@ -342,7 +446,7 @@ class WorkerClient extends base_1.BaseClient {
                     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);
+                        await this.cache.onPacket(packet);
                         this.postMessage({
                             type: 'WORKER_READY',
                             workerId: this.workerId,
@@ -351,7 +455,7 @@ class WorkerClient extends base_1.BaseClient {
                     }
                     if (!this.__handleGuilds?.size)
                         delete this.__handleGuilds;
-                    return this.cache.onPacket?.(packet);
+                    return this.cache.onPacket(packet);
                 }
                 await this.events?.execute(packet.t, packet, this, shardId);
                 break;
@@ -359,35 +463,48 @@ class WorkerClient extends base_1.BaseClient {
             default: {
                 switch (packet.t) {
                     case 'INTERACTION_CREATE':
-                        await this.events?.execute(packet.t, packet, this, shardId);
-                        await this.handleCommand.interaction(packet.d, shardId);
+                        {
+                            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);
+                        {
+                            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)) {
+                        {
+                            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._ready && [...this.shards.values()].every(shard => shard.data.session_id)) {
+                                this._ready = true;
                                 this.postMessage({
-                                    type: 'WORKER_READY',
+                                    type: 'WORKER_SHARDS_CONNECTED',
                                     workerId: this.workerId,
                                 });
-                                await this.events?.runEvent('WORKER_READY', this, this.me, -1);
+                                await this.events?.runEvent('WORKER_SHARDS_CONNECTED', this, this.me, -1);
+                            }
+                            if (!(0, common_1.hasIntent)(workerData.intents, 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;
                             }
-                            delete this.__handleGuilds;
+                            this.debugger?.debug(`#${shardId}[${packet.d.user.username}](${this.botId}) is online...`);
                         }
-                        this.debugger?.debug(`#${shardId}[${packet.d.user.username}](${this.botId}) is online...`);
                         break;
                     default:
                         await this.events?.execute(packet.t, packet, this, shardId);

package/lib/collection.d.ts

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

package/lib/commands/applications/chat.d.ts

@@ -1,12 +1,12 @@
-import { ApplicationCommandOptionType, ApplicationCommandType, type ApplicationIntegrationType, type InteractionContextType, type APIApplicationCommandBasicOption, type APIApplicationCommandOption, type LocaleString } from '../../types';
 import type { PermissionStrings, SeyfertNumberOption, SeyfertStringOption } from '../..';
 import type { Attachment } from '../../builders';
+import type { GuildRoleStructure, InteractionGuildMemberStructure, UserStructure } from '../../client/transformers';
 import { type Awaitable, type FlatObjectKeys } from '../../common';
 import type { AllChannels, AutocompleteInteraction } from '../../structures';
+import { type APIApplicationCommandBasicOption, type APIApplicationCommandOption, ApplicationCommandOptionType, ApplicationCommandType, type ApplicationIntegrationType, type InteractionContextType, type LocaleString } from '../../types';
 import type { Groups, RegisteredMiddlewares } from '../decorators';
 import type { CommandContext } from './chatcontext';
 import type { DefaultLocale, ExtraProps, IgnoreCommand, OKFunction, OnOptionsReturnObject, StopFunction, UsingClient } from './shared';
-import type { GuildRoleStructure, InteractionGuildMemberStructure, UserStructure } from '../../client/transformers';
 export interface ReturnOptionsTypes {
     1: never;
     2: never;
@@ -150,6 +150,6 @@ export declare abstract class SubCommand extends BaseCommand {
         contexts: BaseCommand["contexts"];
         integration_types: BaseCommand["integrationTypes"];
     };
-    abstract run(context: CommandContext<any>): any;
+    abstract run(context: CommandContext): any;
 }
 export {};

package/lib/commands/applications/chat.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SubCommand = exports.Command = exports.BaseCommand = void 0;
-const types_1 = require("../../types");
-const common_1 = require("../../common");
 const node_util_1 = require("node:util");
+const common_1 = require("../../common");
+const types_1 = require("../../types");
 class BaseCommand {
     middlewares = [];
     __filePath;
@@ -89,13 +89,12 @@ class BaseCommand {
                 running = false;
                 return res({ pass: true });
             };
-            function next(obj) {
+            function next(...args) {
                 if (!running) {
                     return;
                 }
-                if (arguments.length) {
-                    // @ts-expect-error
-                    context[global ? 'globalMetadata' : 'metadata'][middlewares[index]] = obj;
+                if (args.length) {
+                    context[global ? 'globalMetadata' : 'metadata'][middlewares[index]] = args[0];
                 }
                 if (++index >= middlewares.length) {
                     running = false;

package/lib/commands/applications/chatcontext.d.ts

@@ -1,4 +1,5 @@
-import type { AllChannels, InferWithPrefix, Message, ReturnCache } from '../..';
+import type { AllChannels, InferWithPrefix, ReturnCache } from '../..';
+import type { GuildMemberStructure, GuildStructure, InteractionGuildMemberStructure, MessageStructure, OptionResolverStructure, WebhookMessageStructure } from '../../client/transformers';
 import type { If, UnionToTuple, When } from '../../common';
 import type { InteractionCreateBodyRequest, InteractionMessageUpdateBodyRequest } from '../../common/types/write';
 import { ChatInputCommandInteraction } from '../../structures';
@@ -6,7 +7,6 @@ import { BaseContext } from '../basecontext';
 import type { RegisteredMiddlewares } from '../decorators';
 import type { Command, ContextOptions, OptionsRecord, SubCommand } from './chat';
 import type { CommandMetadata, ExtendContext, GlobalMetadata, UsingClient } from './shared';
-import type { GuildMemberStructure, GuildStructure, InteractionGuildMemberStructure, MessageStructure, OptionResolverStructure, WebhookMessageStructure } from '../../client/transformers';
 export interface CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never> extends BaseContext, ExtendContext {
 }
 export declare class CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never> extends BaseContext {
@@ -26,11 +26,11 @@ export declare class CommandContext<T extends OptionsRecord = {}, M extends keyo
         get(locale?: string): import("./shared").DefaultLocale;
     };
     get fullCommandName(): string;
-    write<FR extends boolean = false>(body: InteractionCreateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessageStructure | MessageStructure, void | WebhookMessageStructure | MessageStructure>>;
-    deferReply(ephemeral?: boolean): Promise<void | Message>;
-    editResponse(body: InteractionMessageUpdateBodyRequest): Promise<Message | import("../..").WebhookMessage>;
+    write<WR extends boolean = false>(body: InteractionCreateBodyRequest, withResponse?: WR): Promise<When<WR, WebhookMessageStructure | When<InferWithPrefix, MessageStructure, never>, void | WebhookMessageStructure | When<InferWithPrefix, MessageStructure, never>>>;
+    deferReply<WR extends boolean = false>(ephemeral?: boolean, withResponse?: WR): Promise<When<WR, WebhookMessageStructure | When<InferWithPrefix, MessageStructure, never>, When<InferWithPrefix, MessageStructure, never> | undefined>>;
+    editResponse(body: InteractionMessageUpdateBodyRequest): Promise<When<InferWithPrefix, WebhookMessageStructure | MessageStructure, WebhookMessageStructure>>;
     deleteResponse(): Promise<void>;
-    editOrReply<FR extends boolean = false>(body: InteractionCreateBodyRequest | InteractionMessageUpdateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessageStructure | MessageStructure, void | WebhookMessageStructure | MessageStructure>>;
+    editOrReply<WR extends boolean = false>(body: InteractionCreateBodyRequest | InteractionMessageUpdateBodyRequest, withResponse?: WR): Promise<When<WR, WebhookMessageStructure | When<InferWithPrefix, MessageStructure, never>, void | WebhookMessageStructure | When<InferWithPrefix, MessageStructure, never>>>;
     fetchResponse(): Promise<If<InferWithPrefix, WebhookMessageStructure | MessageStructure | undefined, WebhookMessageStructure | undefined>>;
     channel(mode?: 'rest' | 'flow'): Promise<If<InferWithPrefix, AllChannels | undefined, AllChannels>>;
     channel(mode?: 'cache'): ReturnCache<If<InferWithPrefix, AllChannels | undefined, AllChannels>>;

package/lib/commands/applications/chatcontext.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandContext = void 0;
-const types_1 = require("../../types");
 const structures_1 = require("../../structures");
+const types_1 = require("../../types");
 const basecontext_1 = require("../basecontext");
 class CommandContext extends basecontext_1.BaseContext {
     client;
@@ -37,21 +37,29 @@ class CommandContext extends basecontext_1.BaseContext {
     get fullCommandName() {
         return this.resolver.fullCommandName;
     }
-    async write(body, fetchReply) {
+    async write(body, withResponse) {
         if (this.interaction)
-            return this.interaction.write(body, fetchReply);
+            return this.interaction.write(body, withResponse);
         const options = this.client.options?.commands;
         return (this.messageResponse = await this.message[!this.messageResponse && options?.reply?.(this) ? 'reply' : 'write'](body));
     }
-    async deferReply(ephemeral = false) {
+    async deferReply(ephemeral = false, withResponse) {
         if (this.interaction)
-            return this.interaction.deferReply(ephemeral ? types_1.MessageFlags.Ephemeral : undefined);
+            return this.interaction.deferReply(ephemeral ? types_1.MessageFlags.Ephemeral : undefined, withResponse);
+        this.__deferred = true;
         const options = this.client.options?.commands;
         return (this.messageResponse = await this.message[options?.reply?.(this) ? 'reply' : 'write'](options?.deferReplyResponse?.(this) ?? { content: 'Thinking...' }));
     }
     async editResponse(body) {
         if (this.interaction)
             return this.interaction.editResponse(body);
+        if (this.__deferred && !this.__edited) {
+            this.__edited = true;
+            if (this.messageResponse?.content)
+                body.content ??= '';
+            if (this.messageResponse?.embeds.length)
+                body.embeds ??= [];
+        }
         return (this.messageResponse = await this.messageResponse.edit(body));
     }
     deleteResponse() {
@@ -59,13 +67,13 @@ class CommandContext extends basecontext_1.BaseContext {
             return this.interaction.deleteResponse();
         return this.messageResponse.delete();
     }
-    editOrReply(body, fetchReply) {
+    editOrReply(body, withResponse) {
         if (this.interaction)
-            return this.interaction.editOrReply(body, fetchReply);
+            return this.interaction.editOrReply(body, withResponse);
         if (this.messageResponse) {
             return this.editResponse(body);
         }
-        return this.write(body, fetchReply);
+        return this.write(body, withResponse);
     }
     async fetchResponse() {
         if (this.interaction)