seyfert 1.3.3 → 1.5.0

package/lib/components/modalcontext.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModalContext = void 0;
+const v10_1 = require("discord-api-types/v10");
+const basecontext_1 = require("../commands/basecontext");
+/**
+ * Represents a context for interacting with components in a Discord bot.
+ * @template Type - The type of component interaction.
+ */
+class ModalContext extends basecontext_1.BaseContext {
+    client;
+    interaction;
+    /**
+     * Creates a new instance of the ComponentContext class.
+     * @param client - The UsingClient instance.
+     * @param interaction - The component interaction object.
+     */
+    constructor(client, interaction) {
+        super(client);
+        this.client = client;
+        this.interaction = interaction;
+    }
+    command;
+    metadata = {};
+    globalMetadata = {};
+    get customId() {
+        return this.interaction.customId;
+    }
+    get components() {
+        return this.interaction.components;
+    }
+    /**
+     * Gets the language object for the interaction's locale.
+     */
+    get t() {
+        return this.client.t(this.interaction?.locale ?? this.client.langs?.defaultLang ?? 'en-US');
+    }
+    /**
+     * Writes a response to the interaction.
+     * @param body - The body of the response.
+     * @param fetchReply - Whether to fetch the reply or not.
+     */
+    write(body, fetchReply) {
+        return this.interaction.write(body, fetchReply);
+    }
+    /**
+     * Defers the reply to the interaction.
+     * @param ephemeral - Whether the reply should be ephemeral or not.
+     */
+    deferReply(ephemeral = false) {
+        return this.interaction.deferReply(ephemeral ? v10_1.MessageFlags.Ephemeral : undefined);
+    }
+    /**
+     * Edits the response of the interaction.
+     * @param body - The updated body of the response.
+     */
+    editResponse(body) {
+        return this.interaction.editResponse(body);
+    }
+    /**
+     * Edits the response or replies to the interaction.
+     * @param body - The body of the response or updated body of the interaction.
+     * @param fetchReply - Whether to fetch the reply or not.
+     */
+    editOrReply(body, fetchReply) {
+        return this.interaction.editOrReply(body, fetchReply);
+    }
+    /**
+     * Deletes the response of the interaction.
+     * @returns A promise that resolves when the response is deleted.
+     */
+    deleteResponse() {
+        return this.interaction.deleteResponse();
+    }
+    modal(body) {
+        //@ts-expect-error
+        return this.interaction.modal(body);
+    }
+    channel(mode = 'cache') {
+        if (this.interaction?.channel && mode === 'cache')
+            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.adapter.isAsync ? Promise.resolve() : undefined) : Promise.resolve();
+        switch (mode) {
+            case 'cache':
+                return this.client.cache.members?.get(this.client.botId, this.guildId);
+            default:
+                return this.client.members.fetch(this.guildId, this.client.botId, mode === 'rest');
+        }
+    }
+    guild(mode = 'cache') {
+        if (!this.guildId)
+            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);
+            default:
+                return this.client.guilds.fetch(this.guildId, mode === 'rest');
+        }
+    }
+    /**
+     * Gets the ID of the guild of the interaction.
+     */
+    get guildId() {
+        return this.interaction.guildId;
+    }
+    /**
+     * Gets the ID of the channel of the interaction.
+     */
+    get channelId() {
+        return this.interaction.channelId;
+    }
+    /**
+     * Gets the author of the interaction.
+     */
+    get author() {
+        return this.interaction.user;
+    }
+    /**
+     * Gets the member of the interaction.
+     */
+    get member() {
+        return this.interaction.member;
+    }
+    isModal() {
+        return true;
+    }
+}
+exports.ModalContext = ModalContext;

package/lib/events/event.d.ts

@@ -1,16 +1,17 @@
 import type { UsingClient } from '../commands';
 import type { ClientEvents } from './hooks';
-export interface DeclareEventsOptions {
-    name: `${keyof ClientEvents}`;
-    once?: boolean;
+export interface CustomEvents {
 }
 export type ClientNameEvents = Extract<keyof ClientEvents, string>;
+export type CustomEventsKeys = Extract<keyof CustomEvents, string>;
 export interface ClientDataEvent {
     name: ClientNameEvents;
     once: boolean;
 }
 export type CallbackEventHandler = {
     [K in keyof ClientEvents]: (...data: [Awaited<ClientEvents[K]>, UsingClient, number]) => unknown;
+} & {
+    [K in keyof CustomEvents]: (...data: [Parameters<CustomEvents[K]>, UsingClient, number]) => unknown;
 };
 export type EventContext<T extends {
     data: {

package/lib/events/handler.d.ts

@@ -2,20 +2,26 @@ import type { GatewayDispatchPayload } from 'discord-api-types/v10';
 import type { Client, WorkerClient } from '../client';
 import { BaseHandler, type MakeRequired, type SnakeCase } from '../common';
 import type { ClientEvents } from '../events/hooks';
-import type { ClientEvent, ClientNameEvents } from './event';
+import type { ClientEvent, CustomEvents, CustomEventsKeys } from './event';
 export type EventValue = MakeRequired<ClientEvent, '__filePath'> & {
     fired?: boolean;
 };
 export type GatewayEvents = Uppercase<SnakeCase<keyof ClientEvents>>;
 export declare class EventHandler extends BaseHandler {
-    onFail: (event: GatewayEvents, err: unknown) => void;
+    protected client: Client | WorkerClient;
+    constructor(client: Client | WorkerClient);
+    onFail: (event: GatewayEvents | CustomEventsKeys, err: unknown) => void;
     protected filter: (path: string) => boolean;
-    values: Partial<Record<GatewayEvents, EventValue>>;
-    load(eventsDir: string): Promise<void>;
+    values: Partial<Record<GatewayEvents | CustomEventsKeys, EventValue>>;
+    load(eventsDir: string, instances?: {
+        file: ClientEvent;
+        path: string;
+    }[]): Promise<void>;
     execute(name: GatewayEvents, ...args: [GatewayDispatchPayload, Client<true> | WorkerClient<true>, number]): Promise<void>;
     runEvent(name: GatewayEvents, client: Client | WorkerClient, packet: any, shardId: number): Promise<void>;
-    reload(name: ClientNameEvents): Promise<any>;
-    reloadAll(): Promise<void>;
+    runCustom<T extends CustomEventsKeys>(name: T, ...args: Parameters<CustomEvents[T]>): Promise<void>;
+    reload(name: GatewayEvents | CustomEventsKeys): Promise<any>;
+    reloadAll(stopIfFail?: boolean): Promise<void>;
     setHandlers({ callback }: {
         callback: EventHandler['callback'];
     }): void;

package/lib/events/handler.js

@@ -27,11 +27,17 @@ exports.EventHandler = void 0;
 const common_1 = require("../common");
 const RawEvents = __importStar(require("../events/hooks"));
 class EventHandler extends common_1.BaseHandler {
+    client;
+    constructor(client) {
+        super(client.logger);
+        this.client = client;
+    }
     onFail = (event, err) => this.logger.warn('<Client>.events.onFail', err, event);
     filter = (path) => path.endsWith('.js') || (!path.endsWith('.d.ts') && path.endsWith('.ts'));
     values = {};
-    async load(eventsDir) {
-        for (const i of await this.loadFilesK(await this.getFiles(eventsDir))) {
+    async load(eventsDir, instances) {
+        const discordEvents = Object.keys(RawEvents).map(x => common_1.ReplaceRegex.camel(x.toLowerCase()));
+        for (const i of instances ?? (await this.loadFilesK(await this.getFiles(eventsDir)))) {
             const instance = this.callback(i.file);
             if (!instance)
                 continue;
@@ -40,21 +46,18 @@ class EventHandler extends common_1.BaseHandler {
                 continue;
             }
             instance.__filePath = i.path;
-            this.values[common_1.ReplaceRegex.snake(instance.data.name).toUpperCase()] = instance;
+            this.values[discordEvents.includes(instance.data.name)
+                ? common_1.ReplaceRegex.snake(instance.data.name).toUpperCase()
+                : instance.data.name] = instance;
         }
     }
     async execute(name, ...args) {
         switch (name) {
-            case 'GUILD_DELETE':
-            case 'CHANNEL_UPDATE':
-                await this.runEvent(args[0].t, args[1], args[0], args[2]);
-                await args[1].cache.onPacket(args[0]);
-                return;
             case 'MESSAGE_CREATE':
                 {
                     const { d: data } = args[0];
-                    if (args[1].components?.values.has(data.interaction?.id ?? data.id)) {
-                        args[1].components.values.get(data.interaction?.id ?? data.id).messageId = data.id;
+                    if (args[1].components?.values.has(data.interaction_metadata?.id ?? data.id)) {
+                        args[1].components.values.get(data.interaction_metadata?.id ?? data.id).messageId = data.id;
                     }
                 }
                 break;
@@ -80,39 +83,76 @@ class EventHandler extends common_1.BaseHandler {
                 }
                 break;
         }
-        await this.runEvent(args[0].t, args[1], args[0].d, args[2]);
+        await Promise.all([
+            this.runEvent(args[0].t, args[1], args[0].d, args[2]),
+            this.client.collectors.run(args[0].t, args[0].d),
+        ]);
     }
     async runEvent(name, client, packet, shardId) {
         const Event = this.values[name];
         if (!Event) {
-            return;
+            return this.client.cache.onPacket({
+                t: name,
+                d: packet,
+            });
         }
         try {
             if (Event.data.once && Event.fired) {
-                return;
+                return this.client.cache.onPacket({
+                    t: name,
+                    d: packet,
+                });
             }
             Event.fired = true;
             const hook = await RawEvents[name]?.(client, packet);
-            await Event.run(...[hook, client, shardId]);
+            if (name !== 'RAW')
+                await this.client.cache.onPacket({
+                    t: name,
+                    d: packet,
+                });
+            await Event.run(hook, client, shardId);
+        }
+        catch (e) {
+            await this.onFail(name, e);
+        }
+    }
+    async runCustom(name, ...args) {
+        const Event = this.values[name];
+        if (!Event) {
+            return this.client.collectors.run(name, args);
+        }
+        try {
+            if (Event.data.once && Event.fired) {
+                return this.client.collectors.run(name, args);
+            }
+            Event.fired = true;
+            this.logger.debug(`executed a custom event [${name}]`, Event.data.once ? 'once' : '');
+            await Promise.all([Event.run(args, this.client), this.client.collectors.run(name, args)]);
         }
         catch (e) {
             await this.onFail(name, e);
         }
     }
     async reload(name) {
-        const eventName = common_1.ReplaceRegex.snake(name).toUpperCase();
-        const event = this.values[eventName];
-        if (!event)
+        const event = this.values[name];
+        if (!event?.__filePath)
             return null;
         delete require.cache[event.__filePath];
         const imported = await (0, common_1.magicImport)(event.__filePath).then(x => x.default ?? x);
         imported.__filePath = event.__filePath;
-        this.values[eventName] = imported;
+        this.values[name] = imported;
         return imported;
     }
-    async reloadAll() {
+    async reloadAll(stopIfFail = true) {
         for (const i in this.values) {
-            await this.reload(common_1.ReplaceRegex.camel(i));
+            try {
+                await this.reload(i);
+            }
+            catch (e) {
+                if (stopIfFail) {
+                    throw e;
+                }
+            }
         }
     }
     setHandlers({ callback }) {

package/lib/events/hooks/application_command.d.ts

@@ -1,6 +1,6 @@
 import type { GatewayApplicationCommandPermissionsUpdateDispatchData } from 'discord-api-types/v10';
-import type { BaseClient } from '../../client/base';
-export declare const APPLICATION_COMMAND_PERMISSIONS_UPDATE: (_self: BaseClient, data: GatewayApplicationCommandPermissionsUpdateDispatchData) => {
+import type { UsingClient } from '../../commands';
+export declare const APPLICATION_COMMAND_PERMISSIONS_UPDATE: (_self: UsingClient, data: GatewayApplicationCommandPermissionsUpdateDispatchData) => {
     id: string;
     applicationId: string;
     guildId: string;

package/lib/events/hooks/auto_moderation.d.ts

@@ -1,7 +1,7 @@
 import type { GatewayAutoModerationActionExecutionDispatchData, GatewayAutoModerationRuleCreateDispatchData, GatewayAutoModerationRuleDeleteDispatchData, GatewayAutoModerationRuleUpdateDispatchData } from 'discord-api-types/v10';
-import type { BaseClient } from '../../client/base';
 import { AutoModerationRule } from '../../structures';
-export declare const AUTO_MODERATION_ACTION_EXECUTION: (_self: BaseClient, data: GatewayAutoModerationActionExecutionDispatchData) => {
+import type { UsingClient } from '../../commands';
+export declare const AUTO_MODERATION_ACTION_EXECUTION: (_self: UsingClient, data: GatewayAutoModerationActionExecutionDispatchData) => {
     guildId: string;
     action: {
         type: import("discord-api-types/v10").AutoModerationActionType;
@@ -21,6 +21,6 @@ export declare const AUTO_MODERATION_ACTION_EXECUTION: (_self: BaseClient, data:
     matchedKeyword: string | null;
     matchedContent: string | null;
 };
-export declare const AUTO_MODERATION_RULE_CREATE: (self: BaseClient, data: GatewayAutoModerationRuleCreateDispatchData) => AutoModerationRule;
-export declare const AUTO_MODERATION_RULE_DELETE: (self: BaseClient, data: GatewayAutoModerationRuleDeleteDispatchData) => AutoModerationRule;
-export declare const AUTO_MODERATION_RULE_UPDATE: (self: BaseClient, data: GatewayAutoModerationRuleUpdateDispatchData) => AutoModerationRule;
+export declare const AUTO_MODERATION_RULE_CREATE: (self: UsingClient, data: GatewayAutoModerationRuleCreateDispatchData) => AutoModerationRule;
+export declare const AUTO_MODERATION_RULE_DELETE: (self: UsingClient, data: GatewayAutoModerationRuleDeleteDispatchData) => AutoModerationRule;
+export declare const AUTO_MODERATION_RULE_UPDATE: (self: UsingClient, data: GatewayAutoModerationRuleUpdateDispatchData) => AutoModerationRule;

package/lib/events/hooks/channel.d.ts

@@ -1,11 +1,11 @@
 import type { GatewayChannelCreateDispatchData, GatewayChannelDeleteDispatchData, GatewayChannelPinsUpdateDispatchData, GatewayChannelUpdateDispatchData } from 'discord-api-types/v10';
-import type { BaseClient } from '../../client/base';
 import type { AllChannels } from '../../structures';
-export declare const CHANNEL_CREATE: (self: BaseClient, data: GatewayChannelCreateDispatchData) => AllChannels;
-export declare const CHANNEL_DELETE: (self: BaseClient, data: GatewayChannelDeleteDispatchData) => AllChannels;
-export declare const CHANNEL_PINS_UPDATE: (_self: BaseClient, data: GatewayChannelPinsUpdateDispatchData) => {
+import type { UsingClient } from '../../commands';
+export declare const CHANNEL_CREATE: (self: UsingClient, data: GatewayChannelCreateDispatchData) => AllChannels;
+export declare const CHANNEL_DELETE: (self: UsingClient, data: GatewayChannelDeleteDispatchData) => AllChannels;
+export declare const CHANNEL_PINS_UPDATE: (_self: UsingClient, data: GatewayChannelPinsUpdateDispatchData) => {
     guildId?: string | undefined;
     channelId: string;
     lastPinTimestamp?: string | null | undefined;
 };
-export declare const CHANNEL_UPDATE: (self: BaseClient, data: GatewayChannelUpdateDispatchData) => Promise<[channel: AllChannels, old?: AllChannels]>;
+export declare const CHANNEL_UPDATE: (self: UsingClient, data: GatewayChannelUpdateDispatchData) => Promise<[channel: AllChannels, old?: AllChannels]>;

package/lib/events/hooks/custom.d.ts

@@ -1,4 +1,4 @@
-import type { BaseClient } from '../../client/base';
+import type { UsingClient } from '../../commands';
 import type { ClientUser } from '../../structures';
-export declare const BOT_READY: (_self: BaseClient, me: ClientUser) => ClientUser;
-export declare const WORKER_READY: (_self: BaseClient, me: ClientUser) => ClientUser;
+export declare const BOT_READY: (_self: UsingClient, me: ClientUser) => ClientUser;
+export declare const WORKER_READY: (_self: UsingClient, me: ClientUser) => ClientUser;

package/lib/events/hooks/dispatch.d.ts

@@ -1,6 +1,6 @@
 import type { GatewayDispatchPayload, GatewayReadyDispatchData, GatewayResumedDispatch } from 'discord-api-types/v10';
-import type { BaseClient } from '../../client/base';
 import { ClientUser } from '../../structures';
-export declare const READY: (self: BaseClient, data: GatewayReadyDispatchData) => ClientUser;
-export declare const RESUMED: (_self: BaseClient, _data: GatewayResumedDispatch['d']) => void;
-export declare const RAW: (_self: BaseClient, data: GatewayDispatchPayload) => GatewayDispatchPayload;
+import type { UsingClient } from '../../commands';
+export declare const READY: (self: UsingClient, data: GatewayReadyDispatchData) => ClientUser;
+export declare const RESUMED: (_self: UsingClient, _data: GatewayResumedDispatch['d']) => void;
+export declare const RAW: (_self: UsingClient, data: GatewayDispatchPayload) => GatewayDispatchPayload;

package/lib/events/hooks/entitlement.d.ts

@@ -1,6 +1,6 @@
 import type { APIEntitlement } from 'discord-api-types/v10';
-import type { BaseClient } from '../../client/base';
-export declare const ENTITLEMENT_CREATE: (_: BaseClient, data: APIEntitlement) => {
+import type { UsingClient } from '../../commands';
+export declare const ENTITLEMENT_CREATE: (_: UsingClient, data: APIEntitlement) => {
     id: string;
     skuId: string;
     userId?: string | undefined;
@@ -12,7 +12,7 @@ export declare const ENTITLEMENT_CREATE: (_: BaseClient, data: APIEntitlement) =
     endsAt?: string | undefined;
     consumed?: boolean | undefined;
 };
-export declare const ENTITLEMENT_UPDATE: (_: BaseClient, data: APIEntitlement) => {
+export declare const ENTITLEMENT_UPDATE: (_: UsingClient, data: APIEntitlement) => {
     id: string;
     skuId: string;
     userId?: string | undefined;
@@ -24,7 +24,7 @@ export declare const ENTITLEMENT_UPDATE: (_: BaseClient, data: APIEntitlement) =
     endsAt?: string | undefined;
     consumed?: boolean | undefined;
 };
-export declare const ENTITLEMENT_DELETE: (_: BaseClient, data: APIEntitlement) => {
+export declare const ENTITLEMENT_DELETE: (_: UsingClient, data: APIEntitlement) => {
     id: string;
     skuId: string;
     userId?: string | undefined;