seyfert 1.0.0 → 1.1.0

package/lib/client/workerclient.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateShardInfo = exports.WorkerClient = void 0;
+const node_crypto_1 = require("node:crypto");
 const node_worker_threads_1 = require("node:worker_threads");
+const __1 = require("..");
 const cache_1 = require("../cache");
 const common_1 = require("../common");
 const events_1 = require("../events");
@@ -10,25 +12,41 @@ const websocket_1 = require("../websocket");
 const base_1 = require("./base");
 const oninteractioncreate_1 = require("./oninteractioncreate");
 const onmessagecreate_1 = require("./onmessagecreate");
-const workerData = node_worker_threads_1.workerData;
+let workerData;
+try {
+    workerData = {
+        debug: process.env.SEYFERT_WORKER_DEBUG === 'true',
+        intents: Number.parseInt(process.env.SEYFERT_WORKER_INTENTS),
+        path: process.env.SEYFERT_WORKER_PATH,
+        shards: process.env.SEYFERT_WORKER_SHARDS.split(',').map(id => Number.parseInt(id)),
+        token: process.env.SEYFERT_WORKER_TOKEN,
+        workerId: Number.parseInt(process.env.SEYFERT_WORKER_WORKERID),
+        workerProxy: process.env.SEYFERT_WORKER_WORKERPROXY === 'true',
+    };
+}
+catch { }
 class WorkerClient extends base_1.BaseClient {
-    __handleGuilds;
+    __handleGuilds = new Set();
     logger = new common_1.Logger({
         name: `[Worker #${workerData.workerId}]`,
     });
     events = new events_1.EventHandler(this.logger);
     me;
+    promises = new Map();
     shards = new Map();
     constructor(options) {
         super(options);
-        this.__handleGuilds = new Set();
-        if (!node_worker_threads_1.parentPort) {
+        if (!process.env.SEYFERT_SPAWNING) {
             throw new Error('WorkerClient cannot spawn without manager');
         }
-        node_worker_threads_1.parentPort.on('message', data => this.handleManagerMessages(data));
+        this.postMessage({
+            type: 'WORKER_START',
+            workerId: workerData.workerId,
+        });
+        (node_worker_threads_1.parentPort ?? process).on('message', (data) => this.handleManagerMessages(data));
         this.setServices({
             cache: {
-                adapter: new cache_1.WorkerAdapter(node_worker_threads_1.parentPort),
+                adapter: new cache_1.WorkerAdapter(workerData),
                 disabledCache: options?.disabledCache,
             },
         });
@@ -38,10 +56,24 @@ class WorkerClient extends base_1.BaseClient {
                 logLevel: common_1.LogLevels.Debug,
             });
         }
+        if (workerData.workerProxy) {
+            this.setServices({
+                rest: new __1.ApiHandler({
+                    token: workerData.token,
+                    workerProxy: true,
+                    debug: workerData.debug,
+                }),
+            });
+        }
     }
     get workerId() {
         return workerData.workerId;
     }
+    get latency() {
+        let acc = 0;
+        this.shards.forEach(s => (acc += s.latency));
+        return acc / this.shards.size;
+    }
     async start(options = {}) {
         await super.start(options);
         await this.loadEvents(options.eventsDir);
@@ -54,6 +86,11 @@ class WorkerClient extends base_1.BaseClient {
             this.logger.info('EventHandler loaded');
         }
     }
+    postMessage(body) {
+        if (node_worker_threads_1.parentPort)
+            return node_worker_threads_1.parentPort.postMessage(body);
+        return process.send(body);
+    }
     async handleManagerMessages(data) {
         switch (data.type) {
             case 'CACHE_RESULT':
@@ -74,9 +111,10 @@ class WorkerClient extends base_1.BaseClient {
                     await shard.send(0, {
                         ...data,
                     });
-                    node_worker_threads_1.parentPort.postMessage({
+                    this.postMessage({
                         type: 'RESULT_PAYLOAD',
                         nonce: data.nonce,
+                        workerId: this.workerId,
                     });
                 }
                 break;
@@ -93,9 +131,9 @@ class WorkerClient extends base_1.BaseClient {
                 break;
             case 'SPAWN_SHARDS':
                 {
-                    const cache = this.cache;
                     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) {
@@ -107,9 +145,9 @@ class WorkerClient extends base_1.BaseClient {
                                 debugger: this.debugger,
                                 async handlePayload(shardId, payload) {
                                     await handlePayload?.(shardId, payload);
-                                    await cache.onPacket(payload);
+                                    await self.cache.onPacket(payload);
                                     await onPacket?.(payload, shardId);
-                                    node_worker_threads_1.parentPort.postMessage({
+                                    self.postMessage({
                                         workerId: workerData.workerId,
                                         shardId,
                                         type: 'RECEIVE_PAYLOAD',
@@ -119,7 +157,7 @@ class WorkerClient extends base_1.BaseClient {
                             });
                             this.shards.set(id, shard);
                         }
-                        node_worker_threads_1.parentPort.postMessage({
+                        this.postMessage({
                             type: 'CONNECT_QUEUE',
                             shardId: id,
                             workerId: workerData.workerId,
@@ -134,16 +172,17 @@ class WorkerClient extends base_1.BaseClient {
                         this.logger.fatal('Worker trying get non-existent shard');
                         return;
                     }
-                    node_worker_threads_1.parentPort.postMessage({
+                    this.postMessage({
                         ...generateShardInfo(shard),
                         nonce: data.nonce,
                         type: 'SHARD_INFO',
+                        workerId: this.workerId,
                     });
                 }
                 break;
             case 'WORKER_INFO':
                 {
-                    node_worker_threads_1.parentPort.postMessage({
+                    this.postMessage({
                         shards: [...this.shards.values()].map(generateShardInfo),
                         workerId: workerData.workerId,
                         type: 'WORKER_INFO',
@@ -152,13 +191,84 @@ class WorkerClient extends base_1.BaseClient {
                 }
                 break;
             case 'BOT_READY':
-                if (this.events.values.BOT_READY &&
-                    (this.events.values.BOT_READY.fired ? !this.events.values.BOT_READY.data.once : true)) {
-                    await this.events.runEvent('BOT_READY', this, this.me, -1);
+                await this.events.runEvent('BOT_READY', this, this.me, -1);
+                break;
+            case 'API_RESPONSE':
+                {
+                    const promise = this.rest.workerPromises.get(data.nonce);
+                    if (!promise)
+                        return;
+                    this.rest.workerPromises.delete(data.nonce);
+                    if (data.error)
+                        return promise.reject(data.error);
+                    promise.resolve(data.response);
+                }
+                break;
+            case 'EXECUTE_EVAL':
+                {
+                    let result;
+                    try {
+                        // biome-ignore lint/security/noGlobalEval: yes
+                        result = await eval(`
+					(${data.func})(this)
+					`);
+                    }
+                    catch (e) {
+                        result = e;
+                    }
+                    this.postMessage({
+                        type: 'EVAL_RESPONSE',
+                        response: result,
+                        workerId: workerData.workerId,
+                        nonce: data.nonce,
+                    });
+                }
+                break;
+            case 'EVAL_RESPONSE':
+                {
+                    const evalResponse = this.promises.get(data.nonce);
+                    if (!evalResponse)
+                        return;
+                    this.promises.delete(data.nonce);
+                    clearTimeout(evalResponse.timeout);
+                    evalResponse.resolve(data.response);
                 }
                 break;
         }
     }
+    generateNonce(large = true) {
+        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;
+    }
+    generateSendPromise(nonce, message = 'Timeout') {
+        let resolve = (_) => {
+            /**/
+        };
+        let timeout = -1;
+        const promise = new Promise((res, rej) => {
+            resolve = res;
+            timeout = setTimeout(() => {
+                this.promises.delete(nonce);
+                rej(new Error(message));
+            }, 60e3);
+        });
+        this.promises.set(nonce, { resolve, timeout });
+        return promise;
+    }
+    tellWorker(workerId, func) {
+        const nonce = this.generateNonce();
+        this.postMessage({
+            type: 'EVAL',
+            func: func.toString(),
+            toWorkerId: workerId,
+            workerId: workerData.workerId,
+            nonce,
+        });
+        return this.generateSendPromise(nonce);
+    }
     async onPacket(packet, shardId) {
         await this.events.execute('RAW', packet, this, shardId);
         switch (packet.t) {
@@ -181,17 +291,16 @@ class WorkerClient extends base_1.BaseClient {
                             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) {
-                                if ([...this.shards.values()].every(shard => shard.data.session_id) &&
-                                    this.events.values.WORKER_READY &&
-                                    (this.events.values.WORKER_READY.fired ? !this.events.values.WORKER_READY.data.once : true)) {
-                                    node_worker_threads_1.parentPort.postMessage({
+                            if (!this.__handleGuilds?.size ||
+                                !((workerData.intents & common_1.GatewayIntentBits.Guilds) === common_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...`);
                             break;
@@ -204,16 +313,15 @@ class WorkerClient extends base_1.BaseClient {
                         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.events.values.WORKER_READY &&
-                                    (this.events.values.WORKER_READY.fired ? !this.events.values.WORKER_READY.data.once : true)) {
-                                    node_worker_threads_1.parentPort.postMessage({
+                                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;
                             }
                         }

package/lib/collection.js

@@ -197,7 +197,7 @@ exports.Collection = Collection;
 class LimitedCollection {
     static default = {
         resetOnDemand: false,
-        limit: Infinity,
+        limit: Number.POSITIVE_INFINITY,
         expire: 0,
     };
     data = new Map();
@@ -233,7 +233,7 @@ class LimitedCollection {
                 this.delete(iter.next().value);
             }
         }
-        if (this.closer.expireOn === expireOn) {
+        if (this.closer?.expireOn === expireOn) {
             this.resetTimeout();
         }
     }

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

@@ -1,11 +1,11 @@
 import type { SeyfertNumberOption, SeyfertStringOption } from '../..';
 import type { Attachment } from '../../builders';
-import type { APIApplicationCommandBasicOption, APIApplicationCommandOption, LocaleString, PermissionStrings } from '../../common';
+import type { APIApplicationCommandBasicOption, APIApplicationCommandOption, FlatObjectKeys, LocaleString, PermissionStrings } from '../../common';
 import { ApplicationCommandOptionType, ApplicationCommandType } from '../../common';
 import type { AllChannels, AutocompleteInteraction, GuildRole, InteractionGuildMember, User } from '../../structures';
-import type { Groups, RegisteredMiddlewares } from '../decorators';
+import type { Groups, IntegrationTypes, InteractionContextTypes, RegisteredMiddlewares } from '../decorators';
 import type { CommandContext } from './chatcontext';
-import type { OKFunction, OnOptionsReturnObject, StopFunction, UsingClient } from './shared';
+import type { DefaultLocale, OKFunction, OnOptionsReturnObject, StopFunction, UsingClient } from './shared';
 export interface ReturnOptionsTypes {
     1: never;
     2: never;
@@ -29,6 +29,10 @@ type Wrap<N extends ApplicationCommandOptionType> = N extends ApplicationCommand
     description: string;
     description_localizations?: APIApplicationCommandBasicOption['description_localizations'];
     name_localizations?: APIApplicationCommandBasicOption['name_localizations'];
+    locales?: {
+        name?: FlatObjectKeys<DefaultLocale>;
+        description?: FlatObjectKeys<DefaultLocale>;
+    };
 };
 export type __TypeWrapper<T extends ApplicationCommandOptionType> = Wrap<T>;
 export type __TypesWrapper = {
@@ -79,8 +83,9 @@ declare class BaseCommand {
     nsfw?: boolean;
     description: string;
     default_member_permissions?: string;
+    integration_types?: IntegrationTypes[];
+    contexts?: InteractionContextTypes[];
     botPermissions?: bigint;
-    dm?: boolean;
     name_localizations?: Partial<Record<LocaleString, string>>;
     description_localizations?: Partial<Record<LocaleString, string>>;
     options?: CommandOption[] | SubCommand[];
@@ -93,7 +98,8 @@ declare class BaseCommand {
         description_localizations: BaseCommand['description_localizations'];
         guild_id: BaseCommand['guild_id'];
         default_member_permissions: BaseCommand['default_member_permissions'];
-        dm_permission?: boolean | undefined;
+        contexts: BaseCommand['contexts'];
+        integration_types: BaseCommand['integration_types'];
     };
     reload(): Promise<void>;
     run?(context: CommandContext<any>): any;
@@ -117,7 +123,8 @@ export declare class Command extends BaseCommand {
         description_localizations: Partial<Record<"id" | "en-US" | "en-GB" | "bg" | "zh-CN" | "zh-TW" | "hr" | "cs" | "da" | "nl" | "fi" | "fr" | "de" | "el" | "hi" | "hu" | "it" | "ja" | "ko" | "lt" | "no" | "pl" | "pt-BR" | "ro" | "ru" | "es-ES" | "es-419" | "sv-SE" | "th" | "tr" | "uk" | "vi", string>> | undefined;
         guild_id: string[] | undefined;
         default_member_permissions: string | undefined;
-        dm_permission?: boolean | undefined;
+        contexts: InteractionContextTypes[] | undefined;
+        integration_types: IntegrationTypes[] | undefined;
     };
     onRunError(context: CommandContext<any>, error: unknown): any;
     onOptionsError(context: CommandContext<{}, never>, metadata: OnOptionsReturnObject): any;
@@ -139,7 +146,8 @@ export declare abstract class SubCommand extends BaseCommand {
         description_localizations: Partial<Record<"id" | "en-US" | "en-GB" | "bg" | "zh-CN" | "zh-TW" | "hr" | "cs" | "da" | "nl" | "fi" | "fr" | "de" | "el" | "hi" | "hu" | "it" | "ja" | "ko" | "lt" | "no" | "pl" | "pt-BR" | "ro" | "ru" | "es-ES" | "es-419" | "sv-SE" | "th" | "tr" | "uk" | "vi", string>> | undefined;
         guild_id: string[] | undefined;
         default_member_permissions: string | undefined;
-        dm_permission?: boolean | undefined;
+        contexts: InteractionContextTypes[] | undefined;
+        integration_types: IntegrationTypes[] | undefined;
     };
     abstract run(context: CommandContext<any>): any;
 }

package/lib/commands/applications/chat.js

@@ -14,22 +14,22 @@ class BaseCommand {
     nsfw;
     description;
     default_member_permissions;
+    integration_types;
+    contexts;
     botPermissions;
-    dm;
     name_localizations;
     description_localizations;
     options;
     /** @internal */
     async __runOptions(ctx, resolver) {
-        const command = resolver.getCommand();
-        if (!command?.options?.length) {
+        if (!this?.options?.length) {
             return [false, {}];
         }
         const data = {};
         let errored = false;
-        for (const i of command.options ?? []) {
+        for (const i of this.options ?? []) {
             try {
-                const option = command.options.find(x => x.name === i.name);
+                const option = this.options.find(x => x.name === i.name);
                 const value = resolver.getHoisted(i.name)?.value !== undefined
                     ? await new Promise((res, rej) => option.value?.({ context: ctx, value: resolver.getValue(i.name) }, res, rej) ||
                         res(resolver.getValue(i.name)))
@@ -117,9 +117,9 @@ class BaseCommand {
             description_localizations: this.description_localizations,
             guild_id: this.guild_id,
             default_member_permissions: this.default_member_permissions,
+            contexts: this.contexts,
+            integration_types: this.integration_types,
         };
-        if ('dm' in this)
-            data.dm_permission = this.dm;
         return data;
     }
     async reload() {

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

@@ -1,21 +1,22 @@
 import { MenuCommandContext, User, type AllChannels, type Guild, type InferWithPrefix, type MessageCommandInteraction, type ReturnCache, type UserCommandInteraction, type WebhookMessage } from '../..';
-import { type When, type If, type UnionToTuple } from '../../common';
+import { type If, type UnionToTuple, type When } from '../../common';
 import type { InteractionCreateBodyRequest, InteractionMessageUpdateBodyRequest } from '../../common/types/write';
 import { Message, type ChatInputCommandInteraction, type GuildMember, type InteractionGuildMember } from '../../structures';
 import type { RegisteredMiddlewares } from '../decorators';
 import type { OptionResolver } from '../optionresolver';
-import type { ContextOptions, OptionsRecord } from './chat';
+import type { Command, ContextOptions, OptionsRecord, SubCommand } from './chat';
 import type { CommandMetadata, ExtendContext, GlobalMetadata, UsingClient } from './shared';
 export interface CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never> extends ExtendContext {
 }
 export declare class CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never> {
     readonly client: UsingClient;
-    resolver: OptionResolver;
+    readonly resolver: OptionResolver;
     readonly shardId: number;
+    readonly command: Command | SubCommand;
     message: If<InferWithPrefix, Message | undefined, undefined>;
     interaction: If<InferWithPrefix, ChatInputCommandInteraction | undefined, ChatInputCommandInteraction>;
     messageResponse?: If<InferWithPrefix, Message | undefined>;
-    constructor(client: UsingClient, data: ChatInputCommandInteraction | Message, resolver: OptionResolver, shardId: number);
+    constructor(client: UsingClient, data: ChatInputCommandInteraction | Message, resolver: OptionResolver, shardId: number, command: Command | SubCommand);
     options: ContextOptions<T>;
     metadata: CommandMetadata<UnionToTuple<M>>;
     globalMetadata: GlobalMetadata;
@@ -23,6 +24,7 @@ export declare class CommandContext<T extends OptionsRecord = {}, M extends keyo
     get t(): import("../..").__InternalParseLocale<import("./shared").DefaultLocale> & {
         get(locale?: string | undefined): import("./shared").DefaultLocale;
     };
+    get fullCommandName(): string;
     write<FR extends boolean = false>(body: InteractionCreateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessage | Message, void | WebhookMessage | Message>>;
     deferReply(ephemeral?: boolean): Promise<void | Message>;
     editResponse(body: InteractionMessageUpdateBodyRequest): Promise<Message>;

package/lib/commands/applications/chatcontext.js

@@ -8,13 +8,15 @@ class CommandContext {
     client;
     resolver;
     shardId;
+    command;
     message;
     interaction;
     messageResponse;
-    constructor(client, data, resolver, shardId) {
+    constructor(client, data, resolver, shardId, command) {
         this.client = client;
         this.resolver = resolver;
         this.shardId = shardId;
+        this.command = command;
         if (data instanceof structures_1.Message) {
             this.message = data;
         }
@@ -31,6 +33,9 @@ class CommandContext {
     get t() {
         return this.client.langs.get(this.interaction?.locale ?? this.client.langs.defaultLang ?? 'en-US');
     }
+    get fullCommandName() {
+        return this.resolver.fullCommandName;
+    }
     async write(body, fetchReply) {
         if (this.interaction)
             return this.interaction.write(body, fetchReply);
@@ -69,22 +74,22 @@ class CommandContext {
     }
     channel(mode = 'cache') {
         if (this.interaction?.channel && mode === 'cache')
-            return this.client.cache.asyncCache ? Promise.resolve(this.interaction.channel) : this.interaction.channel;
+            return this.client.cache.adapter.isAsync ? Promise.resolve(this.interaction.channel) : this.interaction.channel;
         switch (mode) {
             case 'cache':
                 return (this.client.cache.channels?.get(this.channelId) ||
-                    (this.client.cache.asyncCache ? Promise.resolve() : undefined));
+                    (this.client.cache.adapter.isAsync ? Promise.resolve() : undefined));
             default:
                 return this.client.channels.fetch(this.channelId, mode === 'rest');
         }
     }
     me(mode = 'cache') {
         if (!this.guildId)
-            return mode === 'cache' ? (this.client.cache.asyncCache ? Promise.resolve() : undefined) : Promise.resolve();
+            return mode === 'cache' ? (this.client.cache.adapter.isAsync ? Promise.resolve() : undefined) : Promise.resolve();
         switch (mode) {
             case 'cache':
                 return (this.client.cache.members?.get(this.client.botId, this.guildId) ||
-                    (this.client.cache.asyncCache ? Promise.resolve() : undefined));
+                    (this.client.cache.adapter.isAsync ? Promise.resolve() : undefined));
             default:
                 return this.client.members.fetch(this.guildId, this.client.botId, mode === 'rest');
         }
@@ -92,14 +97,14 @@ class CommandContext {
     guild(mode = 'cache') {
         if (!this.guildId)
             return (mode === 'cache'
-                ? this.client.cache.asyncCache
+                ? this.client.cache.adapter.isAsync
                     ? Promise.resolve()
                     : undefined
                 : Promise.resolve());
         switch (mode) {
             case 'cache':
                 return (this.client.cache.guilds?.get(this.guildId) ||
-                    (this.client.cache.asyncCache ? Promise.resolve() : undefined));
+                    (this.client.cache.adapter.isAsync ? Promise.resolve() : undefined));
             default:
                 return this.client.guilds.fetch(this.guildId, mode === 'rest');
         }

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

@@ -1,5 +1,5 @@
 import { type ApplicationCommandType, type LocaleString, type PermissionStrings } from '../../common';
-import type { RegisteredMiddlewares } from '../decorators';
+import type { IntegrationTypes, InteractionContextTypes, RegisteredMiddlewares } from '../decorators';
 import type { MenuCommandContext } from './menucontext';
 import type { UsingClient } from './shared';
 export declare abstract class ContextMenuCommand {
@@ -13,6 +13,8 @@ export declare abstract class ContextMenuCommand {
     name: string;
     type: ApplicationCommandType.User | ApplicationCommandType.Message;
     nsfw?: boolean;
+    integration_types?: IntegrationTypes[];
+    contexts?: InteractionContextTypes[];
     description: string;
     default_member_permissions?: string;
     botPermissions?: bigint;
@@ -29,6 +31,8 @@ export declare abstract class ContextMenuCommand {
         guild_id: string[] | undefined;
         dm_permission: boolean | undefined;
         default_member_permissions: string | undefined;
+        contexts: InteractionContextTypes[] | undefined;
+        integration_types: IntegrationTypes[] | undefined;
     };
     reload(): Promise<void>;
     abstract run?(context: MenuCommandContext<any>): any;

package/lib/commands/applications/menu.js

@@ -10,6 +10,8 @@ class ContextMenuCommand {
     name;
     type;
     nsfw;
+    integration_types;
+    contexts;
     description;
     default_member_permissions;
     botPermissions;
@@ -73,6 +75,8 @@ class ContextMenuCommand {
             guild_id: this.guild_id,
             dm_permission: this.dm,
             default_member_permissions: this.default_member_permissions,
+            contexts: this.contexts,
+            integration_types: this.integration_types,
         };
     }
     async reload() {

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

@@ -1,5 +1,5 @@
-import { CommandContext, type WebhookMessage, type ReturnCache } from '../..';
-import { type When, type InteractionCreateBodyRequest, type InteractionMessageUpdateBodyRequest, type UnionToTuple } from '../../common';
+import { CommandContext, type ContextMenuCommand, type ReturnCache, type WebhookMessage } from '../..';
+import { type InteractionCreateBodyRequest, type InteractionMessageUpdateBodyRequest, type UnionToTuple, type When } from '../../common';
 import { Message, User, type AllChannels, type Guild, type GuildMember, type MessageCommandInteraction, type UserCommandInteraction } from '../../structures';
 import type { RegisteredMiddlewares } from '../decorators';
 import type { CommandMetadata, ExtendContext, GlobalMetadata, UsingClient } from './shared';
@@ -10,7 +10,8 @@ export declare class MenuCommandContext<T extends MessageCommandInteraction | Us
     readonly client: UsingClient;
     readonly interaction: T;
     readonly shardId: number;
-    constructor(client: UsingClient, interaction: T, shardId: number);
+    readonly command: ContextMenuCommand;
+    constructor(client: UsingClient, interaction: T, shardId: number, command: ContextMenuCommand);
     metadata: CommandMetadata<UnionToTuple<M>>;
     globalMetadata: GlobalMetadata;
     get proxy(): import("../..").APIRoutes;
@@ -18,6 +19,7 @@ export declare class MenuCommandContext<T extends MessageCommandInteraction | Us
     get t(): import("../..").__InternalParseLocale<import("./shared").DefaultLocale> & {
         get(locale?: string | undefined): import("./shared").DefaultLocale;
     };
+    get fullCommandName(): string;
     write<FR extends boolean = false>(body: InteractionCreateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessage, void | WebhookMessage>>;
     get modal(): ((body: import("../../common").ModalCreateBodyRequest) => Promise<void>) | ((body: import("../../common").ModalCreateBodyRequest) => Promise<void>);
     deferReply(ephemeral?: boolean): Promise<void>;

package/lib/commands/applications/menucontext.js

@@ -8,10 +8,12 @@ class MenuCommandContext {
     client;
     interaction;
     shardId;
-    constructor(client, interaction, shardId) {
+    command;
+    constructor(client, interaction, shardId, command) {
         this.client = client;
         this.interaction = interaction;
         this.shardId = shardId;
+        this.command = command;
     }
     metadata = {};
     globalMetadata = {};
@@ -34,6 +36,9 @@ class MenuCommandContext {
     get t() {
         return this.client.langs.get(this.interaction.locale);
     }
+    get fullCommandName() {
+        return this.command.name;
+    }
     write(body, fetchReply) {
         return this.interaction.write(body, fetchReply);
     }
@@ -57,12 +62,12 @@ class MenuCommandContext {
     }
     channel(mode = 'cache') {
         if (this.interaction?.channel && mode === 'cache')
-            return this.client.cache.asyncCache ? Promise.resolve(this.interaction.channel) : this.interaction.channel;
+            return this.client.cache.adapter.isAsync ? Promise.resolve(this.interaction.channel) : this.interaction.channel;
         return this.client.channels.fetch(this.channelId, mode === 'rest');
     }
     me(mode = 'cache') {
         if (!this.guildId)
-            return mode === 'cache' ? (this.client.cache.asyncCache ? Promise.resolve() : undefined) : Promise.resolve();
+            return mode === 'cache' ? (this.client.cache.adapter.isAsync ? Promise.resolve() : undefined) : Promise.resolve();
         switch (mode) {
             case 'cache':
                 return this.client.cache.members?.get(this.client.botId, this.guildId);
@@ -72,7 +77,7 @@ class MenuCommandContext {
     }
     guild(mode = 'cache') {
         if (!this.guildId)
-            return (mode === 'cache' ? (this.client.cache.asyncCache ? Promise.resolve() : undefined) : Promise.resolve());
+            return (mode === 'cache' ? (this.client.cache.adapter.isAsync ? Promise.resolve() : undefined) : Promise.resolve());
         switch (mode) {
             case 'cache':
                 return this.client.cache.guilds?.get(this.guildId);

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

@@ -63,5 +63,4 @@ export declare function createNumberOption<T extends SeyfertNumberOption = Seyfe
 export declare function createAttachmentOption<T extends SeyfertAttachmentOption = SeyfertAttachmentOption>(data: T): T & {
     readonly type: ApplicationCommandOptionType.Attachment;
 };
-export type ParseMiddlewareType<T> = T extends MiddlewareContext<any, CommandContext | MenuCommandContext<MessageCommandInteraction<boolean> | UserCommandInteraction<boolean>>> ? T : MiddlewareContext<T, CommandContext | MenuCommandContext<MessageCommandInteraction<boolean> | UserCommandInteraction<boolean>>>;
-export declare function createMiddleware<T = ParseMiddlewareType<unknown>>(data: ParseMiddlewareType<T>): ParseMiddlewareType<T>;
+export declare function createMiddleware<T = any, C extends CommandContext | MenuCommandContext<MessageCommandInteraction<boolean> | UserCommandInteraction<boolean>> = CommandContext | MenuCommandContext<MessageCommandInteraction<boolean> | UserCommandInteraction<boolean>>>(data: MiddlewareContext<T, C>): MiddlewareContext<T, C>;