seyfert 0.1.0

package/lib/components/MentionableSelectMenuComponent.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MentionableSelectMenuComponent = void 0;
+const BaseSelectMenuComponent_1 = require("../structures/extra/BaseSelectMenuComponent");
+class MentionableSelectMenuComponent extends BaseSelectMenuComponent_1.BaseSelectMenuComponent {
+}
+exports.MentionableSelectMenuComponent = MentionableSelectMenuComponent;

package/lib/components/RoleSelectMenuComponent.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentType } from '../common';
+import { BaseSelectMenuComponent } from '../structures/extra/BaseSelectMenuComponent';
+export declare class RoleSelectMenuComponent extends BaseSelectMenuComponent<ComponentType.RoleSelect> {
+}

package/lib/components/RoleSelectMenuComponent.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoleSelectMenuComponent = void 0;
+const BaseSelectMenuComponent_1 = require("../structures/extra/BaseSelectMenuComponent");
+class RoleSelectMenuComponent extends BaseSelectMenuComponent_1.BaseSelectMenuComponent {
+}
+exports.RoleSelectMenuComponent = RoleSelectMenuComponent;

package/lib/components/StringSelectMenuComponent.d.ts

@@ -0,0 +1,6 @@
+import type { APISelectMenuOption, APIStringSelectComponent, ComponentType } from '../common';
+import { BaseSelectMenuComponent } from '../structures/extra/BaseSelectMenuComponent';
+export declare class StringSelectMenuComponent extends BaseSelectMenuComponent<ComponentType.StringSelect> {
+    constructor(data: APIStringSelectComponent);
+    options: APISelectMenuOption[];
+}

package/lib/components/StringSelectMenuComponent.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringSelectMenuComponent = void 0;
+const BaseSelectMenuComponent_1 = require("../structures/extra/BaseSelectMenuComponent");
+class StringSelectMenuComponent extends BaseSelectMenuComponent_1.BaseSelectMenuComponent {
+    constructor(data) {
+        super(data);
+        this.options = data.options;
+    }
+    options;
+}
+exports.StringSelectMenuComponent = StringSelectMenuComponent;

package/lib/components/TextInputComponent.d.ts

@@ -0,0 +1,7 @@
+import type { APIModalComponent, APITextInputComponent, ComponentType } from '../common';
+import { BaseComponent } from '../structures/extra/BaseComponent';
+export declare class TextInputComponent extends BaseComponent<ComponentType.TextInput> {
+    constructor(data: APITextInputComponent);
+    customId: string;
+    value: string | APIModalComponent;
+}

package/lib/components/TextInputComponent.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextInputComponent = void 0;
+const BaseComponent_1 = require("../structures/extra/BaseComponent");
+class TextInputComponent extends BaseComponent_1.BaseComponent {
+    constructor(data) {
+        super(data);
+        this.customId = data.custom_id;
+        this.value = data.value;
+    }
+    customId;
+    value;
+}
+exports.TextInputComponent = TextInputComponent;

package/lib/components/UserSelectMenuComponent.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentType } from '../common';
+import { BaseSelectMenuComponent } from '../structures/extra/BaseSelectMenuComponent';
+export declare class UserSelectMenuComponent extends BaseSelectMenuComponent<ComponentType.UserSelect> {
+}

package/lib/components/UserSelectMenuComponent.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserSelectMenuComponent = void 0;
+const BaseSelectMenuComponent_1 = require("../structures/extra/BaseSelectMenuComponent");
+class UserSelectMenuComponent extends BaseSelectMenuComponent_1.BaseSelectMenuComponent {
+}
+exports.UserSelectMenuComponent = UserSelectMenuComponent;

package/lib/components/command.d.ts

@@ -0,0 +1,23 @@
+import type { ComponentType } from 'discord-api-types/v10';
+import type { ComponentInteraction, ModalSubmitInteraction, StringSelectMenuInteraction } from '../structures';
+export declare const InteractionCommandType: {
+    readonly COMPONENT: 0;
+    readonly MODAL: 1;
+};
+export interface ComponentCommand {
+    __filePath?: string;
+}
+export declare abstract class ComponentCommand {
+    type: 0;
+    abstract componentType: ComponentType;
+    abstract filter(interaction: ComponentInteraction | StringSelectMenuInteraction): Promise<boolean> | boolean;
+    abstract run(interaction: ComponentInteraction | StringSelectMenuInteraction): any;
+}
+export interface ModalCommand {
+    __filePath?: string;
+}
+export declare abstract class ModalCommand {
+    type: 1;
+    abstract filter(interaction: ModalSubmitInteraction): Promise<boolean> | boolean;
+    abstract run(interaction: ModalSubmitInteraction): any;
+}

package/lib/components/command.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModalCommand = exports.ComponentCommand = exports.InteractionCommandType = void 0;
+exports.InteractionCommandType = {
+    COMPONENT: 0,
+    MODAL: 1,
+};
+class ComponentCommand {
+    type = exports.InteractionCommandType.COMPONENT;
+}
+exports.ComponentCommand = ComponentCommand;
+class ModalCommand {
+    type = exports.InteractionCommandType.MODAL;
+}
+exports.ModalCommand = ModalCommand;

package/lib/components/handler.d.ts

@@ -0,0 +1,48 @@
+/// <reference types="node" />
+import { type BuilderComponents } from '../builders';
+import type { ComponentCallback, ModalSubmitCallback } from '../builders/types';
+import type { BaseClient } from '../client/base';
+import { LimitedCollection } from '../collection';
+import { BaseHandler, type OnFailCallback, type APIMessage, type APIModalInteractionResponseCallbackData, type Logger } from '../common';
+import type { InteractionMessageUpdateBodyRequest, MessageCreateBodyRequest, MessageUpdateBodyRequest, ModalCreateBodyRequest, ResolverProps } from '../common/types/write';
+import type { ComponentInteraction, ModalSubmitInteraction, ReplyInteractionBody } from '../structures';
+import { ComponentCommand, ModalCommand } from './command';
+import { ComponentsListener } from './listener';
+type COMPONENTS = {
+    buttons: Partial<Record<string, {
+        callback: ComponentCallback;
+    }>>;
+    listener: ComponentsListener<BuilderComponents>;
+    messageId?: string;
+    idle?: NodeJS.Timeout;
+    timeout?: NodeJS.Timeout;
+};
+export declare class ComponentHandler extends BaseHandler {
+    protected client: BaseClient;
+    protected onFail?: OnFailCallback;
+    readonly values: Map<string, COMPONENTS>;
+    readonly modals: LimitedCollection<string, ModalSubmitCallback>;
+    readonly commands: (ComponentCommand | ModalCommand)[];
+    protected filter: (path: string) => boolean;
+    constructor(logger: Logger, client: BaseClient);
+    set OnFail(cb: OnFailCallback);
+    hasComponent(id: string, customId: string): boolean;
+    onComponent(id: string, interaction: ComponentInteraction): Promise<void>;
+    resetTimeouts(id: string): void;
+    hasModal(interaction: ModalSubmitInteraction): boolean;
+    onModalSubmit(interaction: ModalSubmitInteraction): any;
+    __setComponents(id: string, record: NonNullable<ResolverProps['components']>): void;
+    protected __setModal(id: string, record: APIModalInteractionResponseCallbackData | ModalCreateBodyRequest): void;
+    deleteValue(id: string, reason?: string): void;
+    onRequestInteraction(interactionId: string, interaction: ReplyInteractionBody): void;
+    onMessageDelete(id: string): void;
+    onRequestMessage(body: MessageCreateBodyRequest, message: APIMessage): void;
+    onRequestInteractionUpdate(body: InteractionMessageUpdateBodyRequest, message: APIMessage): void;
+    onRequestUpdateMessage(body: MessageUpdateBodyRequest, message: APIMessage): void;
+    load(componentsDir: string): Promise<void>;
+    reload(path: string): Promise<any>;
+    reloadAll(): Promise<void>;
+    executeComponent(interaction: ComponentInteraction): Promise<void>;
+    executeModal(interaction: ModalSubmitInteraction): Promise<void>;
+}
+export {};

package/lib/components/handler.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentHandler = void 0;
+const builders_1 = require("../builders");
+const collection_1 = require("../collection");
+const common_1 = require("../common");
+const command_1 = require("./command");
+const listener_1 = require("./listener");
+class ComponentHandler extends common_1.BaseHandler {
+    client;
+    onFail;
+    values = new Map();
+    // 10 minutes timeout, because discord dont send an event when the user cancel the modal
+    modals = new collection_1.LimitedCollection({ expire: 60e3 * 10 });
+    commands = [];
+    filter = (path) => path.endsWith('.js') || path.endsWith('.ts');
+    constructor(logger, client) {
+        super(logger);
+        this.client = client;
+    }
+    set OnFail(cb) {
+        this.onFail = cb;
+    }
+    hasComponent(id, customId) {
+        return !!this.values.get(id)?.buttons?.[customId];
+    }
+    async onComponent(id, interaction) {
+        const row = this.values.get(id);
+        const component = row?.buttons?.[interaction.customId];
+        if (!component)
+            return;
+        if (row.listener.options?.filter) {
+            if (!(await row.listener.options.filter(interaction)))
+                return;
+        }
+        row.idle?.refresh();
+        await component.callback(interaction, reason => {
+            row.listener.options?.onStop?.(reason ?? 'stop');
+            this.deleteValue(id);
+        }, () => {
+            this.resetTimeouts(id);
+        });
+    }
+    resetTimeouts(id) {
+        const listener = this.values.get(id);
+        if (listener) {
+            listener.timeout?.refresh();
+            listener.idle?.refresh();
+        }
+    }
+    hasModal(interaction) {
+        return this.modals.has(interaction.user.id);
+    }
+    onModalSubmit(interaction) {
+        setImmediate(() => this.modals.delete(interaction.user.id));
+        return this.modals.get(interaction.user.id)?.(interaction);
+    }
+    __setComponents(id, record) {
+        this.deleteValue(id);
+        if (!(record instanceof listener_1.ComponentsListener))
+            return;
+        const components = {
+            buttons: {},
+            listener: record,
+        };
+        if ((record.options.idle ?? -1) > 0) {
+            components.idle = setTimeout(() => {
+                clearTimeout(components.timeout);
+                clearTimeout(components.idle);
+                record.options?.onStop?.('idle', () => {
+                    this.__setComponents(id, record);
+                });
+                this.values.delete(id);
+            }, record.options.idle);
+        }
+        if ((record.options.timeout ?? -1) > 0) {
+            components.timeout = setTimeout(() => {
+                clearTimeout(components.timeout);
+                clearTimeout(components.idle);
+                record.options?.onStop?.('timeout', () => {
+                    this.__setComponents(id, record);
+                });
+                this.values.delete(id);
+            }, record.options.timeout);
+        }
+        for (const actionRow of record.components) {
+            for (const child of actionRow.components) {
+                if ((child instanceof builders_1.SelectMenu || child instanceof builders_1.Button) && 'custom_id' in child.data) {
+                    components.buttons[child.data.custom_id] = {
+                        callback: child.__exec,
+                    };
+                }
+            }
+        }
+        if (Object.entries(components.buttons).length) {
+            this.values.set(id, components);
+        }
+    }
+    __setModal(id, record) {
+        if ('__exec' in record) {
+            this.modals.set(id, record.__exec);
+        }
+    }
+    deleteValue(id, reason) {
+        const component = this.values.get(id);
+        if (component) {
+            if (reason !== undefined)
+                component.listener.options.onStop?.(reason);
+            clearTimeout(component.timeout);
+            clearTimeout(component.idle);
+            this.values.delete(id);
+        }
+    }
+    onRequestInteraction(interactionId, interaction) {
+        // @ts-expect-error dapi
+        if (!interaction.data) {
+            return;
+        }
+        switch (interaction.type) {
+            case common_1.InteractionResponseType.ChannelMessageWithSource:
+            case common_1.InteractionResponseType.UpdateMessage:
+                if (!interaction.data.components)
+                    return;
+                this.__setComponents(interactionId, interaction.data.components);
+                break;
+            case common_1.InteractionResponseType.Modal:
+                if (!(interaction.data instanceof builders_1.Modal))
+                    return;
+                this.__setModal(interactionId, interaction.data);
+                break;
+        }
+    }
+    onMessageDelete(id) {
+        this.deleteValue(id, 'messageDelete');
+    }
+    onRequestMessage(body, message) {
+        if (!body.components) {
+            return;
+        }
+        this.__setComponents(message.id, body.components);
+    }
+    onRequestInteractionUpdate(body, message) {
+        if (!body.components) {
+            return;
+        }
+        this.__setComponents(message.interaction.id, body.components);
+    }
+    onRequestUpdateMessage(body, message) {
+        if (!body.components)
+            return;
+        this.__setComponents(message.id, body.components);
+    }
+    async load(componentsDir) {
+        const paths = await this.loadFilesK(await this.getFiles(componentsDir));
+        for (let i = 0; i < paths.length; i++) {
+            let component;
+            try {
+                component = new paths[i].file();
+            }
+            catch (e) {
+                if (e instanceof Error && e.message === 'paths[i].file is not a constructor') {
+                    this.logger.warn(`${paths[i].path
+                        .split(process.cwd())
+                        .slice(1)
+                        .join(process.cwd())} doesn't export the class by \`export default <ComponentCommand>\``);
+                }
+                else
+                    this.logger.warn(e, paths[i]);
+                continue;
+            }
+            if (!(component instanceof command_1.ModalCommand) && !(component instanceof command_1.ComponentCommand))
+                continue;
+            component.__filePath = paths[i].path;
+            this.commands.push(component);
+        }
+    }
+    async reload(path) {
+        const component = this.client.components.commands.find(x => x.__filePath?.endsWith(`${path}.js`) ||
+            x.__filePath?.endsWith(`${path}.ts`) ||
+            x.__filePath?.endsWith(path) ||
+            x.__filePath === path);
+        if (!component || !component.__filePath)
+            return null;
+        delete require.cache[component.__filePath];
+        const index = this.client.components.commands.findIndex(x => x.__filePath === component.__filePath);
+        if (index === -1)
+            return null;
+        this.client.components.commands.splice(index, 1);
+        const imported = await (0, common_1.magicImport)(component.__filePath).then(x => x.default ?? x);
+        const command = new imported();
+        command.__filePath = component.__filePath;
+        this.client.components.commands.push(command);
+        return imported;
+    }
+    async reloadAll() {
+        for (const i of this.client.components.commands) {
+            if (!i.__filePath)
+                return this.logger.warn('Unknown command dont have __filePath property', i);
+            await this.reload(i.__filePath);
+        }
+    }
+    async executeComponent(interaction) {
+        for (const i of this.commands) {
+            try {
+                if (i.type === command_1.InteractionCommandType.COMPONENT &&
+                    i.componentType === interaction.componentType &&
+                    (await i.filter(interaction))) {
+                    await i.run(interaction);
+                    break;
+                }
+            }
+            catch (e) {
+                await this.onFail?.(e);
+            }
+        }
+    }
+    async executeModal(interaction) {
+        for (const i of this.commands) {
+            try {
+                if (i.type === command_1.InteractionCommandType.MODAL && (await i.filter(interaction))) {
+                    await i.run(interaction);
+                    break;
+                }
+            }
+            catch (e) {
+                await this.onFail?.(e);
+            }
+        }
+    }
+}
+exports.ComponentHandler = ComponentHandler;

package/lib/components/index.d.ts

@@ -0,0 +1,20 @@
+import type { APIMessageActionRowComponent } from '../common';
+import { BaseComponent } from '../structures/extra/BaseComponent';
+import { ButtonComponent, LinkButtonComponent } 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 ActionRowMessageComponents = Exclude<MessageComponents, TextInputComponent>;
+export * from './command';
+export * from './listener';
+/**
+ * Return a new component instance based on the component type.
+ *
+ * @param component The component to create.
+ * @returns The component instance.
+ */
+export declare function componentFactory(component: APIMessageActionRowComponent): ActionRowMessageComponents | BaseComponent<ActionRowMessageComponents['type']>;

package/lib/components/index.js

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 common_1 = require("../common");
+const BaseComponent_1 = require("../structures/extra/BaseComponent");
+const ButtonComponent_1 = require("./ButtonComponent");
+const ChannelSelectMenuComponent_1 = require("./ChannelSelectMenuComponent");
+const MentionableSelectMenuComponent_1 = require("./MentionableSelectMenuComponent");
+const RoleSelectMenuComponent_1 = require("./RoleSelectMenuComponent");
+const StringSelectMenuComponent_1 = require("./StringSelectMenuComponent");
+const UserSelectMenuComponent_1 = require("./UserSelectMenuComponent");
+__exportStar(require("./command"), exports);
+__exportStar(require("./listener"), exports);
+/**
+ * Return a new component instance based on the component type.
+ *
+ * @param component The component to create.
+ * @returns The component instance.
+ */
+function componentFactory(component) {
+    switch (component.type) {
+        case common_1.ComponentType.Button:
+            if (component.style === common_1.ButtonStyle.Link) {
+                return new ButtonComponent_1.LinkButtonComponent(component);
+            }
+            return new ButtonComponent_1.ButtonComponent(component);
+        case common_1.ComponentType.ChannelSelect:
+            return new ChannelSelectMenuComponent_1.ChannelSelectMenuComponent(component);
+        case common_1.ComponentType.RoleSelect:
+            return new RoleSelectMenuComponent_1.RoleSelectMenuComponent(component);
+        case common_1.ComponentType.StringSelect:
+            return new StringSelectMenuComponent_1.StringSelectMenuComponent(component);
+        case common_1.ComponentType.UserSelect:
+            return new UserSelectMenuComponent_1.UserSelectMenuComponent(component);
+        case common_1.ComponentType.MentionableSelect:
+            return new MentionableSelectMenuComponent_1.MentionableSelectMenuComponent(component);
+        default:
+            return new BaseComponent_1.BaseComponent(component);
+    }
+}
+exports.componentFactory = componentFactory;

package/lib/components/listener.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import type { ActionRow, BuilderComponents, ListenerOptions } from '../builders';
+import { type RestOrArray } from '../common';
+export declare class ComponentsListener<T extends BuilderComponents> {
+    readonly options: ListenerOptions;
+    components: ActionRow<T>[];
+    idle?: NodeJS.Timeout;
+    timeout?: NodeJS.Timeout;
+    constructor(options: ListenerOptions);
+    addRows(...row: RestOrArray<ActionRow<T>>): this;
+}

package/lib/components/listener.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentsListener = void 0;
+const common_1 = require("../common");
+class ComponentsListener {
+    options;
+    components = [];
+    idle;
+    timeout;
+    constructor(options) {
+        this.options = options;
+    }
+    addRows(...row) {
+        this.components = this.components.concat((0, common_1.fastFlat)(row));
+        return this;
+    }
+}
+exports.ComponentsListener = ComponentsListener;

package/lib/events/event.d.ts

@@ -0,0 +1,23 @@
+import type { UsingClient } from '../commands';
+import type { ClientEvents } from './hooks';
+export interface DeclareEventsOptions {
+    name: `${keyof ClientEvents}`;
+    once?: boolean;
+}
+export type ClientNameEvents = Extract<keyof ClientEvents, string>;
+export interface ClientDataEvent {
+    name: ClientNameEvents;
+    once: boolean;
+}
+export type Handler = {
+    [K in keyof ClientEvents]: (...data: [Awaited<ClientEvents[K]>, UsingClient, number]) => unknown;
+};
+export type EventContext<T extends {
+    data: {
+        name: ClientNameEvents;
+    };
+}> = Parameters<Handler[T['data']['name']]>;
+export interface ClientEvent {
+    data: ClientDataEvent;
+    run(...args: EventContext<any>): any;
+}

package/lib/events/event.js

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

package/lib/events/handler.d.ts

@@ -0,0 +1,19 @@
+import type { Client, WorkerClient } from '../client';
+import { BaseHandler, type OnFailCallback, type GatewayDispatchPayload, type MakeRequired, type SnakeCase } from '../common';
+import type { ClientEvents } from '../events/hooks';
+import type { ClientEvent, ClientNameEvents } from './event';
+type EventValue = MakeRequired<ClientEvent, '__filePath'> & {
+    fired?: boolean;
+};
+type GatewayEvents = Uppercase<SnakeCase<keyof ClientEvents>>;
+export declare class EventHandler extends BaseHandler {
+    protected onFail?: OnFailCallback;
+    protected filter: (path: string) => boolean;
+    values: Partial<Record<GatewayEvents, EventValue>>;
+    set OnFail(cb: OnFailCallback);
+    load(eventsDir: string): Promise<void>;
+    execute(name: GatewayEvents, ...args: [GatewayDispatchPayload, Client<true> | WorkerClient<true>, number]): Promise<void>;
+    reload(name: ClientNameEvents): Promise<any>;
+    reloadAll(): Promise<void>;
+}
+export {};