baff.js 0.0.0-stage → 0.1.0

package/dist/esm/structures/interactions/BaseInteraction.js

@@ -0,0 +1,217 @@
+import { resolveMessage } from '../../builders/messagePayload.js';
+import { BaffAPIError, BaffError } from '../../errors/BaffError.js';
+import { Routes } from '../../rest/Routes.js';
+import { PermissionsBitField } from '../../util/Permissions.js';
+import { Identified } from '../Base.js';
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+export class BaseInteraction extends Identified {
+    raw;
+    id;
+    token;
+    applicationId;
+    channelId;
+    serverId;
+    user;
+    roleIds;
+    memberPermissions;
+    appPermissions;
+    replied = false;
+    deferred = false;
+    ephemeral = false;
+    answeredWith = null;
+    replyMessage = null;
+    sink = null;
+    viaResponse = false;
+    constructor(client, raw) {
+        super(client);
+        this.raw = raw;
+        this.id = raw.id;
+        this.token = raw.token;
+        this.applicationId = raw.applicationId;
+        this.channelId = raw.channelId;
+        this.serverId = raw.serverId;
+        this.user = client.users._add(raw.user);
+        this.roleIds = raw.user.roles ?? [];
+        this.memberPermissions = raw.user.permissions !== undefined ? PermissionsBitField.fromBits(raw.user.permissions) : null;
+        this.appPermissions = raw.appPermissions !== undefined ? PermissionsBitField.fromBits(raw.appPermissions) : null;
+    }
+    get fullCommandName() {
+        return this.commandName;
+    }
+    get channel() {
+        return this.client.channels._textChannel(this.channelId, this.serverId);
+    }
+    get server() {
+        return this.serverId ? (this.client.servers.cache.get(this.serverId) ?? null) : null;
+    }
+    get member() {
+        return this.server?.members.cache.get(this.user.id) ?? null;
+    }
+    get message() {
+        return null;
+    }
+    get responded() {
+        return this.replied || this.deferred;
+    }
+    _setSink(sink) {
+        this.sink = sink;
+        if (sink)
+            this.viaResponse = true;
+    }
+    isChatInputCommand() {
+        return this.raw.type === 'command';
+    }
+    isMessageComponent() {
+        return this.raw.type === 'component';
+    }
+    isButton() {
+        return this.isMessageComponent() && this.raw.data.componentType === 2;
+    }
+    isAnySelectMenu() {
+        return this.isMessageComponent() && [3, 5, 6, 7, 8].includes(this.raw.data.componentType ?? 0);
+    }
+    isStringSelectMenu() {
+        return this.isMessageComponent() && this.raw.data.componentType === 3;
+    }
+    isUserSelectMenu() {
+        return this.isMessageComponent() && this.raw.data.componentType === 5;
+    }
+    isRoleSelectMenu() {
+        return this.isMessageComponent() && this.raw.data.componentType === 6;
+    }
+    isMentionableSelectMenu() {
+        return this.isMessageComponent() && this.raw.data.componentType === 7;
+    }
+    isChannelSelectMenu() {
+        return this.isMessageComponent() && this.raw.data.componentType === 8;
+    }
+    isModalSubmit() {
+        return this.raw.type === 'modal_submit';
+    }
+    isRepliable() {
+        return true;
+    }
+    async reply(options) {
+        this.assertFresh();
+        const { body, files } = resolveMessage(options, { allowEphemeral: true });
+        if (files.length)
+            throw new BaffError('INVALID_MESSAGE', 'Interaction answers cannot carry files. Send the files with channel.send or after a defer.');
+        await this.callback({ type: 'message', ...body });
+        this.mark('message', typeof options === 'object' && options.ephemeral === true);
+    }
+    async deferReply(options = {}) {
+        this.assertFresh();
+        await this.callback({ type: 'defer' });
+        this.mark('defer', options.ephemeral === true);
+    }
+    async update(options) {
+        this.assertFresh();
+        this.assertFromMessage();
+        const { body } = resolveMessage(options);
+        await this.callback({ type: 'update', ...body });
+        this.mark('update', false);
+    }
+    async deferUpdate() {
+        this.assertFresh();
+        this.assertFromMessage();
+        await this.callback({ type: 'deferUpdate' });
+        this.mark('deferUpdate', false);
+    }
+    async showModal(modal) {
+        this.assertFresh();
+        if (this.isModalSubmit())
+            throw new BaffError('INVALID_INTERACTION', 'A modal submit cannot be answered with another modal.');
+        await this.callback({ type: 'modal', ...('toJSON' in modal ? modal.toJSON() : modal) });
+        this.mark('modal', false);
+    }
+    async editReply(options) {
+        if (!this.responded)
+            throw new BaffError('INTERACTION_NOT_REPLIED', 'Reply to or defer the interaction before editing its reply.');
+        if (this.answeredWith === 'update' || this.answeredWith === 'deferUpdate') {
+            const { body } = resolveMessage(options);
+            await this.afterAnswer(() => this.client.rest.patch(Routes.interactionOriginal(this.id, this.token), { body, auth: false }));
+            return;
+        }
+        if (this.answeredWith === 'defer' && this.deferred) {
+            const { body, files } = resolveMessage(options, { allowEphemeral: true });
+            await this.afterAnswer(() => this.client.rest.post(Routes.interactionFollowup(this.id, this.token), { body: { ...body, ephemeral: this.ephemeral }, files, auth: false }));
+            this.deferred = false;
+            this.replied = true;
+            return;
+        }
+        if (this.ephemeral)
+            throw new BaffError('CANNOT_EDIT_REPLY', 'baff.gg cannot edit an ephemeral reply after it was sent. Send a new follow-up or answer with update on a component.');
+        return (await this.fetchReply()).edit(options);
+    }
+    async followUp(options) {
+        if (!this.responded)
+            throw new BaffError('INTERACTION_NOT_REPLIED', 'Reply to or defer the interaction before sending a follow-up.');
+        const { body, files } = resolveMessage(options, { allowEphemeral: true });
+        await this.afterAnswer(() => this.client.rest.post(Routes.interactionFollowup(this.id, this.token), { body, files, auth: false }));
+        if (this.deferred) {
+            this.deferred = false;
+            this.replied = true;
+        }
+    }
+    async deleteReply() {
+        if (this.ephemeral)
+            throw new BaffError('CANNOT_DELETE_REPLY', 'baff.gg cannot delete an ephemeral reply.');
+        await (await this.fetchReply()).delete();
+        this.replyMessage = null;
+    }
+    async fetchReply() {
+        if (this.replyMessage)
+            return this.replyMessage;
+        if (!this.replied)
+            throw new BaffError('INTERACTION_NOT_REPLIED', 'There is no reply yet.');
+        if (this.ephemeral)
+            throw new BaffError('CANNOT_FETCH_REPLY', 'Ephemeral replies are not stored, so they cannot be fetched.');
+        const self = await this.client.fetchSelf();
+        for (let attempt = 0; attempt < (this.viaResponse ? 20 : 3); attempt++) {
+            const list = await this.client.rest.get(Routes.channelMessages(this.channelId), { query: { after: this.id, limit: 25 } });
+            const found = list.find((m) => m.author.id === self.id && m.interaction?.name === this.fullCommandName && m.interaction.user.id === this.user.id);
+            if (found)
+                return (this.replyMessage = this.channel.messages._add({ serverId: this.serverId, ...found }));
+            await sleep(this.viaResponse ? 100 : 150);
+        }
+        throw new BaffError('REPLY_NOT_FOUND', 'Could not find the reply message in this channel.');
+    }
+    async afterAnswer(request) {
+        for (let attempt = 0;; attempt++) {
+            try {
+                return await request();
+            }
+            catch (error) {
+                const early = error instanceof BaffAPIError && error.code === 'not_answered';
+                if (!early || !this.viaResponse || attempt >= 20)
+                    throw error;
+                await sleep(100);
+            }
+        }
+    }
+    async callback(body) {
+        if (this.sink) {
+            const sink = this.sink;
+            this.sink = null;
+            sink(body);
+            return;
+        }
+        await this.client.rest.post(Routes.interactionCallback(this.id, this.token), { body, auth: false });
+    }
+    mark(kind, ephemeral) {
+        this.answeredWith = kind;
+        this.ephemeral = ephemeral;
+        if (kind === 'defer')
+            this.deferred = true;
+        else
+            this.replied = true;
+    }
+    assertFresh() {
+        if (this.responded)
+            throw new BaffError('INTERACTION_ALREADY_REPLIED', 'This interaction was already answered. Use followUp or editReply.');
+    }
+    assertFromMessage() {
+        if (!this.raw.message)
+            throw new BaffError('INVALID_INTERACTION', 'Only interactions from a component can update a message.');
+    }
+}

package/dist/esm/structures/interactions/CommandInteraction.d.ts

@@ -0,0 +1,44 @@
+import type { Client } from '../../client/Client.js';
+import type { APIInteraction, APIInteractionOption } from '../../types.js';
+import type { Role } from '../Role.js';
+import type { User } from '../User.js';
+import type { Channel } from '../channels/ServerChannels.js';
+import { BaseInteraction } from './BaseInteraction.js';
+export declare class CommandInteractionOptions {
+    private readonly client;
+    private readonly serverId;
+    readonly data: APIInteractionOption[];
+    readonly subcommandGroup: string | null;
+    readonly subcommand: string | null;
+    private readonly values;
+    constructor(client: Client, serverId: string | null, options?: APIInteractionOption[]);
+    get(name: string, required?: boolean): APIInteractionOption | null;
+    getSubcommand(required?: boolean): string | null;
+    getSubcommandGroup(required?: boolean): string | null;
+    getString(name: string, required: true): string;
+    getString(name: string, required?: boolean): string | null;
+    getInteger(name: string, required: true): number;
+    getInteger(name: string, required?: boolean): number | null;
+    getNumber(name: string, required: true): number;
+    getNumber(name: string, required?: boolean): number | null;
+    getBoolean(name: string, required: true): boolean;
+    getBoolean(name: string, required?: boolean): boolean | null;
+    getUserId(name: string, required: true): string;
+    getUserId(name: string, required?: boolean): string | null;
+    getRoleId(name: string, required: true): string;
+    getRoleId(name: string, required?: boolean): string | null;
+    getChannelId(name: string, required: true): string;
+    getChannelId(name: string, required?: boolean): string | null;
+    getUser(name: string): User | null;
+    fetchUser(name: string): Promise<User | null>;
+    getRole(name: string): Role | null;
+    getChannel(name: string): Channel | null;
+    private typed;
+}
+export declare class ChatInputCommandInteraction extends BaseInteraction {
+    readonly commandId: string;
+    readonly commandName: string;
+    readonly options: CommandInteractionOptions;
+    constructor(client: Client, raw: APIInteraction);
+    get fullCommandName(): string;
+}

package/dist/esm/structures/interactions/CommandInteraction.js

@@ -0,0 +1,104 @@
+import { BaffError } from '../../errors/BaffError.js';
+import { BaseInteraction } from './BaseInteraction.js';
+export class CommandInteractionOptions {
+    client;
+    serverId;
+    data;
+    subcommandGroup;
+    subcommand;
+    values;
+    constructor(client, serverId, options = []) {
+        this.client = client;
+        this.serverId = serverId;
+        let level = options;
+        let group = null;
+        let sub = null;
+        if (level[0]?.type === 'subcommand_group') {
+            group = level[0].name;
+            level = level[0].options ?? [];
+        }
+        if (level[0]?.type === 'subcommand') {
+            sub = level[0].name;
+            level = level[0].options ?? [];
+        }
+        this.data = level;
+        this.subcommandGroup = group;
+        this.subcommand = sub;
+        this.values = new Map(level.map((o) => [o.name, o]));
+    }
+    get(name, required = false) {
+        const option = this.values.get(name) ?? null;
+        if (!option && required)
+            throw new BaffError('COMMAND_OPTION_MISSING', `Required option "${name}" was not provided.`);
+        return option;
+    }
+    getSubcommand(required = true) {
+        if (!this.subcommand && required)
+            throw new BaffError('COMMAND_SUBCOMMAND_MISSING', 'This interaction has no subcommand.');
+        return this.subcommand;
+    }
+    getSubcommandGroup(required = false) {
+        if (!this.subcommandGroup && required)
+            throw new BaffError('COMMAND_SUBCOMMAND_GROUP_MISSING', 'This interaction has no subcommand group.');
+        return this.subcommandGroup;
+    }
+    getString(name, required = false) {
+        return this.typed(name, 'string', required);
+    }
+    getInteger(name, required = false) {
+        return this.typed(name, 'integer', required);
+    }
+    getNumber(name, required = false) {
+        return this.typed(name, 'number', required);
+    }
+    getBoolean(name, required = false) {
+        return this.typed(name, 'boolean', required);
+    }
+    getUserId(name, required = false) {
+        return this.typed(name, 'user', required);
+    }
+    getRoleId(name, required = false) {
+        return this.typed(name, 'role', required);
+    }
+    getChannelId(name, required = false) {
+        return this.typed(name, 'channel', required);
+    }
+    getUser(name) {
+        const id = this.getUserId(name);
+        return id ? (this.client.users.cache.get(id) ?? null) : null;
+    }
+    async fetchUser(name) {
+        const id = this.getUserId(name);
+        return id ? this.client.users.fetch(id) : null;
+    }
+    getRole(name) {
+        const id = this.getRoleId(name);
+        return id && this.serverId ? (this.client.servers.cache.get(this.serverId)?.roles.cache.get(id) ?? null) : null;
+    }
+    getChannel(name) {
+        const id = this.getChannelId(name);
+        return id ? (this.client.channels.cache.get(id) ?? null) : null;
+    }
+    typed(name, type, required) {
+        const option = this.get(name, required);
+        if (!option)
+            return null;
+        if (option.type !== type)
+            throw new BaffError('COMMAND_OPTION_TYPE', `Option "${name}" is a ${option.type}, not a ${type}.`);
+        return option.value ?? null;
+    }
+}
+export class ChatInputCommandInteraction extends BaseInteraction {
+    commandId;
+    commandName;
+    options;
+    constructor(client, raw) {
+        super(client, raw);
+        this.commandId = raw.data.id ?? '';
+        this.commandName = raw.data.name ?? '';
+        this.options = new CommandInteractionOptions(client, raw.serverId, raw.data.options);
+    }
+    get fullCommandName() {
+        return [this.commandName, this.options.subcommandGroup, this.options.subcommand].filter(Boolean).join(' ');
+    }
+}

package/dist/esm/structures/interactions/ComponentInteraction.d.ts

@@ -0,0 +1,44 @@
+import type { Client } from '../../client/Client.js';
+import type { APIInteraction } from '../../types.js';
+import { Collection } from '../../util/Collection.js';
+import type { Message } from '../Message.js';
+import type { User } from '../User.js';
+import { BaseInteraction } from './BaseInteraction.js';
+export declare class MessageComponentInteraction extends BaseInteraction {
+    readonly customId: string;
+    readonly componentType: number;
+    readonly commandName: string;
+    private readonly source;
+    constructor(client: Client, raw: APIInteraction);
+    get message(): Message;
+}
+export declare class ButtonInteraction extends MessageComponentInteraction {
+    readonly label: string | null;
+    constructor(client: Client, raw: APIInteraction);
+}
+export declare class SelectMenuInteraction extends MessageComponentInteraction {
+    readonly values: string[];
+    readonly users: Collection<string, User>;
+    readonly roles: Collection<string, {
+        id: string;
+        name: string;
+        color: string | null;
+    }>;
+    readonly channels: Collection<string, {
+        id: string;
+        name: string;
+        type: number;
+        parentId: string | null;
+    }>;
+    constructor(client: Client, raw: APIInteraction);
+}
+export declare class StringSelectMenuInteraction extends SelectMenuInteraction {
+}
+export declare class UserSelectMenuInteraction extends SelectMenuInteraction {
+}
+export declare class RoleSelectMenuInteraction extends SelectMenuInteraction {
+}
+export declare class MentionableSelectMenuInteraction extends SelectMenuInteraction {
+}
+export declare class ChannelSelectMenuInteraction extends SelectMenuInteraction {
+}

package/dist/esm/structures/interactions/ComponentInteraction.js

@@ -0,0 +1,53 @@
+import { Collection } from '../../util/Collection.js';
+import { BaseInteraction } from './BaseInteraction.js';
+export class MessageComponentInteraction extends BaseInteraction {
+    customId;
+    componentType;
+    commandName;
+    source;
+    constructor(client, raw) {
+        super(client, raw);
+        this.customId = raw.data.customId ?? '';
+        this.componentType = raw.data.componentType ?? 0;
+        this.commandName = raw.message?.interactionName ?? '';
+        const channel = client.channels._textChannel(raw.channelId, raw.serverId);
+        this.source = channel.messages._add({ serverId: raw.serverId, ...raw.message });
+    }
+    get message() {
+        return this.source;
+    }
+}
+export class ButtonInteraction extends MessageComponentInteraction {
+    label;
+    constructor(client, raw) {
+        super(client, raw);
+        this.label = raw.data.label ?? null;
+    }
+}
+export class SelectMenuInteraction extends MessageComponentInteraction {
+    values;
+    users = new Collection();
+    roles = new Collection();
+    channels = new Collection();
+    constructor(client, raw) {
+        super(client, raw);
+        this.values = raw.data.values ?? [];
+        const resolved = raw.data.resolved ?? {};
+        for (const [id, user] of Object.entries(resolved.users ?? {}))
+            this.users.set(id, client.users._add(user));
+        for (const [id, role] of Object.entries(resolved.roles ?? {}))
+            this.roles.set(id, role);
+        for (const [id, channel] of Object.entries(resolved.channels ?? {}))
+            this.channels.set(id, channel);
+    }
+}
+export class StringSelectMenuInteraction extends SelectMenuInteraction {
+}
+export class UserSelectMenuInteraction extends SelectMenuInteraction {
+}
+export class RoleSelectMenuInteraction extends SelectMenuInteraction {
+}
+export class MentionableSelectMenuInteraction extends SelectMenuInteraction {
+}
+export class ChannelSelectMenuInteraction extends SelectMenuInteraction {
+}

package/dist/esm/structures/interactions/ModalSubmitInteraction.d.ts

@@ -0,0 +1,29 @@
+import type { Client } from '../../client/Client.js';
+import type { APIInteraction } from '../../types.js';
+import { Collection } from '../../util/Collection.js';
+import type { Message } from '../Message.js';
+import { BaseInteraction } from './BaseInteraction.js';
+export declare class ModalSubmitFields {
+    readonly fields: Collection<string, {
+        customId: string;
+        value: string;
+    }>;
+    constructor(list: {
+        customId: string;
+        value: string;
+    }[]);
+    getField(customId: string): {
+        customId: string;
+        value: string;
+    };
+    getTextInputValue(customId: string): string;
+}
+export declare class ModalSubmitInteraction extends BaseInteraction {
+    readonly customId: string;
+    readonly fields: ModalSubmitFields;
+    readonly commandName: string;
+    private readonly source;
+    constructor(client: Client, raw: APIInteraction);
+    get message(): Message | null;
+    isFromMessage(): boolean;
+}

package/dist/esm/structures/interactions/ModalSubmitInteraction.js

@@ -0,0 +1,37 @@
+import { BaffError } from '../../errors/BaffError.js';
+import { Collection } from '../../util/Collection.js';
+import { BaseInteraction } from './BaseInteraction.js';
+export class ModalSubmitFields {
+    fields;
+    constructor(list) {
+        this.fields = new Collection(list.map((f) => [f.customId, f]));
+    }
+    getField(customId) {
+        const field = this.fields.get(customId);
+        if (!field)
+            throw new BaffError('MODAL_FIELD_MISSING', `The modal has no field "${customId}".`);
+        return field;
+    }
+    getTextInputValue(customId) {
+        return this.getField(customId).value;
+    }
+}
+export class ModalSubmitInteraction extends BaseInteraction {
+    customId;
+    fields;
+    commandName;
+    source;
+    constructor(client, raw) {
+        super(client, raw);
+        this.customId = raw.data.customId ?? '';
+        this.fields = new ModalSubmitFields(raw.data.fields ?? []);
+        this.commandName = raw.message?.interactionName ?? '';
+        this.source = raw.message ? client.channels._textChannel(raw.channelId, raw.serverId).messages._add({ serverId: raw.serverId, ...raw.message }) : null;
+    }
+    get message() {
+        return this.source;
+    }
+    isFromMessage() {
+        return this.source !== null;
+    }
+}

package/dist/esm/structures/interactions/createInteraction.d.ts

@@ -0,0 +1,4 @@
+import type { Client } from '../../client/Client.js';
+import type { APIInteraction } from '../../types.js';
+import type { BaseInteraction } from './BaseInteraction.js';
+export declare function createInteraction(client: Client, raw: APIInteraction): BaseInteraction;

package/dist/esm/structures/interactions/createInteraction.js

@@ -0,0 +1,31 @@
+import { BaffError } from '../../errors/BaffError.js';
+import { ChatInputCommandInteraction } from './CommandInteraction.js';
+import { ButtonInteraction, ChannelSelectMenuInteraction, MentionableSelectMenuInteraction, MessageComponentInteraction, RoleSelectMenuInteraction, StringSelectMenuInteraction, UserSelectMenuInteraction } from './ComponentInteraction.js';
+import { ModalSubmitInteraction } from './ModalSubmitInteraction.js';
+export function createInteraction(client, raw) {
+    switch (raw.type) {
+        case 'command':
+            return new ChatInputCommandInteraction(client, raw);
+        case 'modal_submit':
+            return new ModalSubmitInteraction(client, raw);
+        case 'component':
+            switch (raw.data.componentType) {
+                case 2:
+                    return new ButtonInteraction(client, raw);
+                case 3:
+                    return new StringSelectMenuInteraction(client, raw);
+                case 5:
+                    return new UserSelectMenuInteraction(client, raw);
+                case 6:
+                    return new RoleSelectMenuInteraction(client, raw);
+                case 7:
+                    return new MentionableSelectMenuInteraction(client, raw);
+                case 8:
+                    return new ChannelSelectMenuInteraction(client, raw);
+                default:
+                    return new MessageComponentInteraction(client, raw);
+            }
+        default:
+            throw new BaffError('UNKNOWN_INTERACTION', `Unknown interaction type "${String(raw.type)}".`);
+    }
+}