seyfert 1.5.0 → 2.1.0

package/lib/components/handler.js

@@ -117,44 +117,67 @@ class ComponentHandler extends common_1.BaseHandler {
     onMessageDelete(id) {
         this.deleteValue(id, 'messageDelete');
     }
-    async load(componentsDir, instances) {
-        const paths = instances?.map(x => {
-            const i = new x();
-            return { file: x, path: i.__filePath ?? '*' };
-        }) ?? (await this.loadFilesK(await this.getFiles(componentsDir)));
-        for (const value of paths) {
+    stablishDefaults(component) {
+        component.props ??= this.client.options.commands?.defaults?.props ?? {};
+        const is = component instanceof modalcommand_1.ModalCommand ? 'modals' : 'components';
+        component.onInternalError ??= this.client.options?.[is]?.defaults?.onInternalError;
+        component.onMiddlewaresError ??= this.client.options?.[is]?.defaults?.onMiddlewaresError;
+        component.onRunError ??= this.client.options?.[is]?.defaults?.onRunError;
+        component.onAfterRun ??= this.client.options?.[is]?.defaults?.onAfterRun;
+    }
+    set(instances) {
+        for (const i of instances) {
             let component;
             try {
-                component = this.callback(value.file);
+                component = this.callback(i);
                 if (!component)
                     continue;
             }
             catch (e) {
-                if (e instanceof Error && e.message.includes('is not a constructor')) {
-                    this.logger.warn(`${value.path
-                        .split(process.cwd())
-                        .slice(1)
-                        .join(process.cwd())} doesn't export the class by \`export default <ComponentCommand>\``);
-                }
-                else
-                    this.logger.warn(e, value);
+                this.logger.warn(e, i);
                 continue;
             }
-            if (!(component instanceof modalcommand_1.ModalCommand || component instanceof componentcommand_1.ComponentCommand))
-                continue;
-            component.props ??= this.client.options.commands?.defaults?.props ?? {};
-            const is = component instanceof modalcommand_1.ModalCommand ? 'modals' : 'components';
-            component.onInternalError ??= this.client.options?.[is]?.defaults?.onInternalError;
-            component.onMiddlewaresError ??= this.client.options?.[is]?.defaults?.onMiddlewaresError;
-            component.onRunError ??= this.client.options?.[is]?.defaults?.onRunError;
-            component.onAfterRun ??= this.client.options?.[is]?.defaults?.onAfterRun;
-            component.__filePath = value.path;
+            this.stablishDefaults(component);
             this.commands.push(component);
         }
     }
+    async load(componentsDir) {
+        const paths = await this.loadFilesK(await this.getFiles(componentsDir));
+        for (const { components, file } of paths.map(x => ({ components: this.onFile(x.file), file: x }))) {
+            if (!components)
+                continue;
+            for (const value of components) {
+                let component;
+                try {
+                    component = this.callback(value);
+                    if (!component)
+                        continue;
+                }
+                catch (e) {
+                    if (e instanceof Error && e.message.includes('is not a constructor')) {
+                        this.logger.warn(`${file.path
+                            .split(process.cwd())
+                            .slice(1)
+                            .join(process.cwd())} doesn't export the class by \`export default <ComponentCommand>\``);
+                    }
+                    else
+                        this.logger.warn(e, value);
+                    continue;
+                }
+                if (!(component instanceof modalcommand_1.ModalCommand || component instanceof componentcommand_1.ComponentCommand))
+                    continue;
+                this.stablishDefaults(component);
+                component.__filePath = file.path;
+                this.commands.push(component);
+            }
+        }
+    }
     async reload(path) {
         if (!this.client.components)
             return;
+        if ((0, common_1.isCloudfareWorker)()) {
+            throw new Error('Reload in cloudfare worker is not supported');
+        }
         const component = this.client.components.commands.find(x => x.__filePath?.endsWith(`${path}.js`) ||
             x.__filePath?.endsWith(`${path}.ts`) ||
             x.__filePath?.endsWith(path) ||
@@ -184,6 +207,41 @@ class ComponentHandler extends common_1.BaseHandler {
             }
         }
     }
+    async execute(i, context) {
+        try {
+            const resultRunGlobalMiddlewares = await commands_1.BaseCommand.__runMiddlewares(context, (context.client.options?.globalMiddlewares ?? []), true);
+            if (resultRunGlobalMiddlewares.pass) {
+                return;
+            }
+            if ('error' in resultRunGlobalMiddlewares) {
+                return i.onMiddlewaresError?.(context, resultRunGlobalMiddlewares.error ?? 'Unknown error');
+            }
+            const resultRunMiddlewares = await commands_1.BaseCommand.__runMiddlewares(context, i.middlewares, false);
+            if (resultRunMiddlewares.pass) {
+                return;
+            }
+            if ('error' in resultRunMiddlewares) {
+                return i.onMiddlewaresError?.(context, resultRunMiddlewares.error ?? 'Unknown error');
+            }
+            try {
+                await i.run(context);
+                await i.onAfterRun?.(context, undefined);
+            }
+            catch (error) {
+                await i.onRunError?.(context, error);
+                await i.onAfterRun?.(context, error);
+            }
+        }
+        catch (error) {
+            try {
+                await i.onInternalError?.(this.client, error);
+            }
+            catch (e) {
+                // supress error
+                this.logger.error(e);
+            }
+        }
+    }
     async executeComponent(context) {
         for (const i of this.commands) {
             try {
@@ -191,39 +249,7 @@ class ComponentHandler extends common_1.BaseHandler {
                     i.cType === context.interaction.componentType &&
                     (await i.filter(context))) {
                     context.command = i;
-                    try {
-                        const resultRunGlobalMiddlewares = await commands_1.BaseCommand.__runMiddlewares(context, (context.client.options?.globalMiddlewares ?? []), true);
-                        if (resultRunGlobalMiddlewares.pass) {
-                            return;
-                        }
-                        if ('error' in resultRunGlobalMiddlewares) {
-                            return i.onMiddlewaresError?.(context, resultRunGlobalMiddlewares.error ?? 'Unknown error');
-                        }
-                        const resultRunMiddlewares = await commands_1.BaseCommand.__runMiddlewares(context, i.middlewares, false);
-                        if (resultRunMiddlewares.pass) {
-                            return;
-                        }
-                        if ('error' in resultRunMiddlewares) {
-                            return i.onMiddlewaresError?.(context, resultRunMiddlewares.error ?? 'Unknown error');
-                        }
-                        try {
-                            await i.run(context);
-                            await i.onAfterRun?.(context, undefined);
-                        }
-                        catch (error) {
-                            await i.onRunError?.(context, error);
-                            await i.onAfterRun?.(context, error);
-                        }
-                    }
-                    catch (error) {
-                        try {
-                            await i.onInternalError?.(this.client, error);
-                        }
-                        catch {
-                            // supress error
-                        }
-                    }
-                    break;
+                    await this.execute(i, context);
                 }
             }
             catch (e) {
@@ -236,39 +262,7 @@ class ComponentHandler extends common_1.BaseHandler {
             try {
                 if (i.type === componentcommand_1.InteractionCommandType.MODAL && (await i.filter(context))) {
                     context.command = i;
-                    try {
-                        const resultRunGlobalMiddlewares = await commands_1.BaseCommand.__runMiddlewares(context, (context.client.options?.globalMiddlewares ?? []), true);
-                        if (resultRunGlobalMiddlewares.pass) {
-                            return;
-                        }
-                        if ('error' in resultRunGlobalMiddlewares) {
-                            return i.onMiddlewaresError?.(context, resultRunGlobalMiddlewares.error ?? 'Unknown error');
-                        }
-                        const resultRunMiddlewares = await commands_1.BaseCommand.__runMiddlewares(context, i.middlewares, false);
-                        if (resultRunMiddlewares.pass) {
-                            return;
-                        }
-                        if ('error' in resultRunMiddlewares) {
-                            return i.onMiddlewaresError?.(context, resultRunMiddlewares.error ?? 'Unknown error');
-                        }
-                        try {
-                            await i.run(context);
-                            await i.onAfterRun?.(context, undefined);
-                        }
-                        catch (error) {
-                            await i.onRunError?.(context, error);
-                            await i.onAfterRun?.(context, error);
-                        }
-                    }
-                    catch (error) {
-                        try {
-                            await i.onInternalError?.(this.client, error);
-                        }
-                        catch {
-                            // supress error
-                        }
-                    }
-                    break;
+                    await this.execute(i, context);
                 }
             }
             catch (e) {
@@ -276,9 +270,11 @@ class ComponentHandler extends common_1.BaseHandler {
             }
         }
     }
-    setHandlers({ callback }) {
-        this.callback = callback;
+    onFile(file) {
+        return file.default ? [file.default] : undefined;
+    }
+    callback(file) {
+        return new file();
     }
-    callback = (file) => new file();
 }
 exports.ComponentHandler = ComponentHandler;

package/lib/components/index.d.ts

@@ -1,13 +1,13 @@
-import { type APIMessageActionRowComponent } from 'discord-api-types/v10';
+import { type APIMessageActionRowComponent } from '../types';
 import { BaseComponent } from './BaseComponent';
-import { ButtonComponent, LinkButtonComponent } from './ButtonComponent';
+import { ButtonComponent, LinkButtonComponent, SKUButtonComponent } from './ButtonComponent';
 import { ChannelSelectMenuComponent } from './ChannelSelectMenuComponent';
 import { MentionableSelectMenuComponent } from './MentionableSelectMenuComponent';
 import { RoleSelectMenuComponent } from './RoleSelectMenuComponent';
 import { StringSelectMenuComponent } from './StringSelectMenuComponent';
 import type { TextInputComponent } from './TextInputComponent';
 import { UserSelectMenuComponent } from './UserSelectMenuComponent';
-export type MessageComponents = ButtonComponent | LinkButtonComponent | RoleSelectMenuComponent | UserSelectMenuComponent | StringSelectMenuComponent | ChannelSelectMenuComponent | MentionableSelectMenuComponent | TextInputComponent;
+export type MessageComponents = ButtonComponent | LinkButtonComponent | SKUButtonComponent | RoleSelectMenuComponent | UserSelectMenuComponent | StringSelectMenuComponent | ChannelSelectMenuComponent | MentionableSelectMenuComponent | TextInputComponent;
 export type ActionRowMessageComponents = Exclude<MessageComponents, TextInputComponent>;
 export * from './componentcommand';
 export * from './componentcontext';

package/lib/components/index.js

@@ -14,8 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.componentFactory = void 0;
-const v10_1 = require("discord-api-types/v10");
+exports.componentFactory = componentFactory;
+const types_1 = require("../types");
 const BaseComponent_1 = require("./BaseComponent");
 const ButtonComponent_1 = require("./ButtonComponent");
 const ChannelSelectMenuComponent_1 = require("./ChannelSelectMenuComponent");
@@ -35,23 +35,25 @@ __exportStar(require("./modalcontext"), exports);
  */
 function componentFactory(component) {
     switch (component.type) {
-        case v10_1.ComponentType.Button:
-            if (component.style === v10_1.ButtonStyle.Link) {
+        case types_1.ComponentType.Button:
+            if (component.style === types_1.ButtonStyle.Link) {
                 return new ButtonComponent_1.LinkButtonComponent(component);
             }
+            if (component.style === types_1.ButtonStyle.Premium) {
+                return new ButtonComponent_1.SKUButtonComponent(component);
+            }
             return new ButtonComponent_1.ButtonComponent(component);
-        case v10_1.ComponentType.ChannelSelect:
+        case types_1.ComponentType.ChannelSelect:
             return new ChannelSelectMenuComponent_1.ChannelSelectMenuComponent(component);
-        case v10_1.ComponentType.RoleSelect:
+        case types_1.ComponentType.RoleSelect:
             return new RoleSelectMenuComponent_1.RoleSelectMenuComponent(component);
-        case v10_1.ComponentType.StringSelect:
+        case types_1.ComponentType.StringSelect:
             return new StringSelectMenuComponent_1.StringSelectMenuComponent(component);
-        case v10_1.ComponentType.UserSelect:
+        case types_1.ComponentType.UserSelect:
             return new UserSelectMenuComponent_1.UserSelectMenuComponent(component);
-        case v10_1.ComponentType.MentionableSelect:
+        case types_1.ComponentType.MentionableSelect:
             return new MentionableSelectMenuComponent_1.MentionableSelectMenuComponent(component);
         default:
             return new BaseComponent_1.BaseComponent(component);
     }
 }
-exports.componentFactory = componentFactory;

package/lib/components/modalcontext.d.ts

@@ -1,7 +1,8 @@
-import type { AllChannels, Guild, GuildMember, Message, ModalCommand, ModalSubmitInteraction, ReturnCache, WebhookMessage } from '..';
+import type { AllChannels, ModalCommand, ModalSubmitInteraction, ReturnCache } from '..';
 import type { CommandMetadata, ExtendContext, GlobalMetadata, RegisteredMiddlewares, UsingClient } from '../commands';
 import { BaseContext } from '../commands/basecontext';
 import type { InteractionCreateBodyRequest, InteractionMessageUpdateBodyRequest, ModalCreateBodyRequest, UnionToTuple, When } from '../common';
+import type { GuildMemberStructure, GuildStructure, MessageStructure, WebhookMessageStructure } from '../client/transformers';
 export interface ModalContext extends BaseContext, ExtendContext {
 }
 /**
@@ -23,24 +24,24 @@ export declare class ModalContext<M extends keyof RegisteredMiddlewares = never>
     get customId(): string;
     get components(): {
         components: {
-            type: import("discord-api-types/v10").ComponentType;
+            type: import("../types").ComponentType;
             customId: string;
             value: string;
         }[];
-        type: import("discord-api-types/v10").ComponentType.ActionRow;
+        type: import("../types").ComponentType.ActionRow;
     }[];
     /**
      * Gets the language object for the interaction's locale.
      */
     get t(): import("..").__InternalParseLocale<import("..").DefaultLocale> & {
-        get(locale?: string | undefined): import("..").DefaultLocale;
+        get(locale?: string): import("..").DefaultLocale;
     };
     /**
      * Writes a response to the interaction.
      * @param body - The body of the response.
      * @param fetchReply - Whether to fetch the reply or not.
      */
-    write<FR extends boolean = false>(body: InteractionCreateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessage, void>>;
+    write<FR extends boolean = false>(body: InteractionCreateBodyRequest, fetchReply?: FR): Promise<When<FR, import("..").WebhookMessage, void>>;
     /**
      * Defers the reply to the interaction.
      * @param ephemeral - Whether the reply should be ephemeral or not.
@@ -50,13 +51,13 @@ export declare class ModalContext<M extends keyof RegisteredMiddlewares = never>
      * Edits the response of the interaction.
      * @param body - The updated body of the response.
      */
-    editResponse(body: InteractionMessageUpdateBodyRequest): Promise<WebhookMessage>;
+    editResponse(body: InteractionMessageUpdateBodyRequest): Promise<import("..").WebhookMessage>;
     /**
      * 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<FR extends boolean = false>(body: InteractionCreateBodyRequest | InteractionMessageUpdateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessage | Message, void | WebhookMessage | Message>>;
+    editOrReply<FR extends boolean = false>(body: InteractionCreateBodyRequest | InteractionMessageUpdateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessageStructure | MessageStructure, void | WebhookMessageStructure | MessageStructure>>;
     /**
      * Deletes the response of the interaction.
      * @returns A promise that resolves when the response is deleted.
@@ -75,15 +76,15 @@ export declare class ModalContext<M extends keyof RegisteredMiddlewares = never>
      * @param mode - The mode to fetch the member.
      * @returns A promise that resolves to the bot member.
      */
-    me(mode?: 'rest' | 'flow'): Promise<GuildMember>;
-    me(mode?: 'cache'): ReturnCache<GuildMember | undefined>;
+    me(mode?: 'rest' | 'flow'): Promise<GuildMemberStructure>;
+    me(mode?: 'cache'): ReturnCache<GuildMemberStructure | undefined>;
     /**
      * Gets the guild of the interaction.
      * @param mode - The mode to fetch the guild.
      * @returns A promise that resolves to the guild.
      */
-    guild(mode?: 'rest' | 'flow'): Promise<Guild<'cached' | 'api'> | undefined>;
-    guild(mode?: 'cache'): ReturnCache<Guild<'cached'> | undefined>;
+    guild(mode?: 'rest' | 'flow'): Promise<GuildStructure<'cached' | 'api'> | undefined>;
+    guild(mode?: 'cache'): ReturnCache<GuildStructure<'cached'> | undefined>;
     /**
      * Gets the ID of the guild of the interaction.
      */

package/lib/components/modalcontext.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModalContext = void 0;
-const v10_1 = require("discord-api-types/v10");
+const types_1 = require("../types");
 const basecontext_1 = require("../commands/basecontext");
 /**
  * Represents a context for interacting with components in a Discord bot.
@@ -48,7 +48,7 @@ class ModalContext extends basecontext_1.BaseContext {
      * @param ephemeral - Whether the reply should be ephemeral or not.
      */
     deferReply(ephemeral = false) {
-        return this.interaction.deferReply(ephemeral ? v10_1.MessageFlags.Ephemeral : undefined);
+        return this.interaction.deferReply(ephemeral ? types_1.MessageFlags.Ephemeral : undefined);
     }
     /**
      * Edits the response of the interaction.

package/lib/deps/mixer.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Mixes a class with other classes.
+ * @param args The classes to mix.
+ * @returns The mixed class.
+ */
+export declare function Mixin<T, C extends TypeClass[]>(...args: C): C[number] & T;
+export type TypeClass<InstanceType = {}, StaticType = {}> = (abstract new (...args: any[]) => InstanceType) & StaticType;
+export declare const mix: (...ingredients: TypeClass[]) => (decoratedClass: any) => any;

package/lib/deps/mixer.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mix = void 0;
+exports.Mixin = Mixin;
+/**
+ * Gets the descriptors of a class.
+ * @param c The class to get the descriptors of.
+ * @returns The descriptors of the class.
+ */
+function getDescriptors(c) {
+    let proto = c.prototype;
+    const result = [];
+    while (proto) {
+        const descriptors = Object.getOwnPropertyDescriptors(proto);
+        // @ts-expect-error this is not a function in all cases
+        if (descriptors.valueOf.configurable)
+            break;
+        result.push(descriptors);
+        proto = proto.__proto__;
+    }
+    return result;
+}
+/**
+ * Mixes a class with other classes.
+ * @param args The classes to mix.
+ * @returns The mixed class.
+ */
+function Mixin(...args) {
+    const ignoreOverwriteToString = Object.keys(Object.getOwnPropertyDescriptors(args[0].prototype)).includes('toString');
+    function MixedClass(...constructorArgs) {
+        for (const i of args) {
+            const descriptors = getDescriptors(i);
+            for (const j of descriptors) {
+                // @ts-expect-error
+                Object.assign(this, new j.constructor.value(...constructorArgs));
+                for (const descriptorK in j) {
+                    if (descriptorK === 'constructor')
+                        continue;
+                    if (descriptorK in MixedClass.prototype && descriptorK !== 'toString')
+                        continue;
+                    const descriptor = j[descriptorK];
+                    if (descriptor.value) {
+                        if (descriptorK === 'toString' && ignoreOverwriteToString) {
+                            MixedClass.prototype[descriptorK] = args[0].prototype.toString;
+                            continue;
+                        }
+                        MixedClass.prototype[descriptorK] = descriptor.value;
+                        continue;
+                    }
+                    if (descriptor.get || descriptor.set) {
+                        Object.defineProperty(MixedClass.prototype, descriptorK, {
+                            get: descriptor.get,
+                            set: descriptor.set,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return MixedClass;
+}
+const mix = (...ingredients) => (decoratedClass) => {
+    ingredients.unshift(decoratedClass);
+    const mixedClass = Mixin(...ingredients);
+    Object.defineProperty(mixedClass, 'name', {
+        value: decoratedClass.name,
+        writable: false,
+    });
+    return mixedClass;
+};
+exports.mix = mix;

package/lib/events/handler.d.ts

@@ -1,29 +1,51 @@
-import type { GatewayDispatchPayload } from 'discord-api-types/v10';
+import type { GatewayDispatchPayload } from '../types';
 import type { Client, WorkerClient } from '../client';
-import { BaseHandler, type MakeRequired, type SnakeCase } from '../common';
+import { BaseHandler, type CamelCase, type MakeRequired, type SnakeCase } from '../common';
 import type { ClientEvents } from '../events/hooks';
-import type { ClientEvent, CustomEvents, CustomEventsKeys } from './event';
+import type { ClientEvent, CustomEvents, CustomEventsKeys, ClientNameEvents, EventContext } from './event';
+import type { FileLoaded } from '../commands/handler';
+import type { UsingClient } from '../commands';
 export type EventValue = MakeRequired<ClientEvent, '__filePath'> & {
     fired?: boolean;
 };
 export type GatewayEvents = Uppercase<SnakeCase<keyof ClientEvents>>;
+export type ResolveEventParams<T extends ClientNameEvents | CustomEventsKeys | GatewayEvents> = T extends CustomEventsKeys ? [...Parameters<CustomEvents[T]>, UsingClient] : T extends GatewayEvents ? EventContext<{
+    data: {
+        name: CamelCase<T>;
+    };
+}> : T extends ClientNameEvents ? EventContext<{
+    data: {
+        name: T;
+    };
+}> : never;
+export type ResolveEventRunParams<T extends ClientNameEvents | CustomEventsKeys | GatewayEvents> = T extends CustomEventsKeys ? Parameters<CustomEvents[T]> : T extends GatewayEvents ? EventContext<{
+    data: {
+        name: CamelCase<T>;
+    };
+}> : T extends ClientNameEvents ? EventContext<{
+    data: {
+        name: T;
+    };
+}> : never;
+export type EventValues = {
+    [K in CustomEventsKeys | GatewayEvents]: Omit<EventValue, 'run'> & {
+        run(...args: ResolveEventRunParams<K>): any;
+    };
+};
 export declare class EventHandler extends BaseHandler {
     protected client: Client | WorkerClient;
     constructor(client: Client | WorkerClient);
     onFail: (event: GatewayEvents | CustomEventsKeys, err: unknown) => void;
     protected filter: (path: string) => boolean;
-    values: Partial<Record<GatewayEvents | CustomEventsKeys, EventValue>>;
-    load(eventsDir: string, instances?: {
-        file: ClientEvent;
-        path: string;
-    }[]): Promise<void>;
+    values: Partial<EventValues>;
+    discordEvents: ClientNameEvents[];
+    set(events: ClientEvent[]): void;
+    load(eventsDir: 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>;
-    runCustom<T extends CustomEventsKeys>(name: T, ...args: Parameters<CustomEvents[T]>): Promise<void>;
+    runEvent(name: GatewayEvents, client: Client | WorkerClient, packet: any, shardId: number, runCache?: boolean): Promise<void>;
+    runCustom<T extends CustomEventsKeys>(name: T, ...args: ResolveEventRunParams<T>): Promise<void>;
     reload(name: GatewayEvents | CustomEventsKeys): Promise<any>;
     reloadAll(stopIfFail?: boolean): Promise<void>;
-    setHandlers({ callback }: {
-        callback: EventHandler['callback'];
-    }): void;
+    onFile(file: FileLoaded<ClientEvent>): ClientEvent[] | undefined;
     callback: (file: ClientEvent) => ClientEvent | false;
 }