baff.js 0.0.0-stage → 0.1.0

package/dist/esm/client/events.d.ts

@@ -0,0 +1,129 @@
+import type { Channel } from '../structures/channels/ServerChannels.js';
+import type { ThreadChannel } from '../structures/channels/ServerChannels.js';
+import type { DMChannel } from '../structures/channels/DMChannel.js';
+import type { TextBasedChannel } from '../structures/channels/TextBasedChannel.js';
+import type { BaseInteraction } from '../structures/interactions/BaseInteraction.js';
+import type { Message } from '../structures/Message.js';
+import type { Role } from '../structures/Role.js';
+import type { ScheduledEvent } from '../structures/ScheduledEvent.js';
+import type { Server } from '../structures/Server.js';
+import type { ServerMember } from '../structures/ServerMember.js';
+import type { User } from '../structures/User.js';
+import type { APIVoiceState } from '../types.js';
+import type { Client } from './Client.js';
+export interface ServerRemoval {
+    id: string;
+    reason: string | null;
+    server: Server | null;
+}
+export interface MessageDeleteEvent {
+    id: string;
+    channelId: string;
+    channel: TextBasedChannel;
+    message: Message | null;
+}
+export interface ReactionEvent {
+    channelId: string;
+    messageId: string;
+    userId: string;
+    emoji: string;
+    channel: TextBasedChannel;
+    message: Message | null;
+    user: User | null;
+}
+export interface MessagePinEvent {
+    channelId: string;
+    messageId: string;
+    pinned: boolean;
+    channel: TextBasedChannel;
+}
+export interface TypingEvent {
+    channelId: string;
+    userId: string;
+    channel: TextBasedChannel;
+    user: User | null;
+}
+export interface MentionEvent {
+    channelId: string;
+    messageId: string;
+    serverId: string | null;
+}
+export interface MemberRemoval {
+    serverId: string;
+    userId: string;
+    member: ServerMember | null;
+    user: User | null;
+}
+export interface PresenceEvent {
+    userId: string;
+    status: string;
+    customStatus: string | null;
+    user: User | null;
+}
+export type ClientEvents = {
+    ready: [client: Client];
+    reconnected: [client: Client];
+    reconnecting: [attempt: number, delayMs: number];
+    disconnect: [code: number, reason: string];
+    raw: [packet: {
+        t: string;
+        d: unknown;
+    }];
+    debug: [message: string];
+    error: [error: Error];
+    serverCreate: [server: Server];
+    serverUpdate: [before: Server, after: Server];
+    serverRemove: [removal: ServerRemoval];
+    channelCreate: [channel: Channel];
+    channelUpdate: [before: Channel, after: Channel];
+    channelDelete: [channel: Channel];
+    roleCreate: [role: Role];
+    roleUpdate: [before: Role, after: Role];
+    roleDelete: [role: Role];
+    threadCreate: [thread: ThreadChannel];
+    threadUpdate: [before: ThreadChannel, after: ThreadChannel];
+    messageCreate: [message: Message];
+    messageUpdate: [before: Message | null, after: Message];
+    messageDelete: [event: MessageDeleteEvent];
+    messageReactionAdd: [event: ReactionEvent];
+    messageReactionRemove: [event: ReactionEvent];
+    messagePin: [event: MessagePinEvent];
+    typingStart: [event: TypingEvent];
+    mention: [event: MentionEvent];
+    pollVote: [data: Record<string, unknown>];
+    memberAdd: [member: ServerMember];
+    memberRemove: [removal: MemberRemoval];
+    memberUpdate: [before: ServerMember | null, after: ServerMember];
+    presenceUpdate: [event: PresenceEvent];
+    userUpdate: [before: User | null, after: User];
+    clanTagUpdate: [data: Record<string, unknown>];
+    dmOpen: [channel: DMChannel];
+    voiceStateUpdate: [before: APIVoiceState | null, after: APIVoiceState];
+    soundboardPlay: [data: Record<string, unknown>];
+    callAlone: [data: Record<string, unknown>];
+    stageInstanceCreate: [data: Record<string, unknown>];
+    stageInstanceUpdate: [data: Record<string, unknown>];
+    stageInstanceDelete: [data: Record<string, unknown>];
+    voiceChannelStatusUpdate: [data: Record<string, unknown>];
+    serverStickersUpdate: [data: Record<string, unknown>];
+    serverSoundboardUpdate: [data: Record<string, unknown>];
+    serverEventCreate: [event: ScheduledEvent];
+    serverEventUpdate: [event: ScheduledEvent];
+    serverEventDelete: [data: {
+        serverId: string;
+        id: string;
+    }];
+    serverEventUserAdd: [data: {
+        serverId: string;
+        eventId: string;
+        userId: string;
+        interestedCount: number;
+    }];
+    serverEventUserRemove: [data: {
+        serverId: string;
+        eventId: string;
+        userId: string;
+        interestedCount: number;
+    }];
+    interactionCreate: [interaction: BaseInteraction];
+};

package/dist/esm/client/events.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/collectors/Collector.d.ts

@@ -0,0 +1,37 @@
+import { BaffError } from '../errors/BaffError.js';
+import { Collection } from '../util/Collection.js';
+import { TypedEmitter } from '../util/TypedEmitter.js';
+export interface CollectorOptions<V> {
+    filter?: (item: V, collected: Collection<string, V>) => boolean | Promise<boolean>;
+    time?: number;
+    idle?: number;
+    max?: number;
+    maxProcessed?: number;
+}
+type CollectorEvents<V> = {
+    collect: [item: V];
+    ignore: [item: V];
+    end: [collected: Collection<string, V>, reason: string];
+};
+export declare class CollectorError extends BaffError {
+    readonly collected: Collection<string, unknown>;
+    readonly reason: string;
+    constructor(collected: Collection<string, unknown>, reason: string);
+}
+export declare abstract class Collector<V> extends TypedEmitter<CollectorEvents<V>> {
+    protected readonly options: CollectorOptions<V>;
+    readonly collected: Collection<string, V>;
+    ended: boolean;
+    endReason: string | null;
+    private processed;
+    private timer;
+    private idleTimer;
+    constructor(options?: CollectorOptions<V>);
+    protected abstract keyOf(item: V): string;
+    protected handle(item: V): Promise<void>;
+    stop(reason?: string): void;
+    protected abstract cleanup(): void;
+    private resetIdle;
+}
+export declare function awaitCollector<V>(collector: Collector<V>, errors?: string[]): Promise<Collection<string, V>>;
+export {};

package/dist/esm/collectors/Collector.js

@@ -0,0 +1,78 @@
+import { BaffError } from '../errors/BaffError.js';
+import { Collection } from '../util/Collection.js';
+import { TypedEmitter } from '../util/TypedEmitter.js';
+export class CollectorError extends BaffError {
+    collected;
+    reason;
+    constructor(collected, reason) {
+        super('COLLECTOR_ENDED', `The collector ended with reason "${reason}".`);
+        this.collected = collected;
+        this.reason = reason;
+        this.name = 'CollectorError';
+    }
+}
+export class Collector extends TypedEmitter {
+    options;
+    collected = new Collection();
+    ended = false;
+    endReason = null;
+    processed = 0;
+    timer = null;
+    idleTimer = null;
+    constructor(options = {}) {
+        super();
+        this.options = options;
+        if (options.time)
+            this.timer = setTimeout(() => this.stop('time'), options.time);
+        this.resetIdle();
+    }
+    async handle(item) {
+        if (this.ended)
+            return;
+        this.processed++;
+        const pass = this.options.filter ? await this.options.filter(item, this.collected) : true;
+        if (this.ended)
+            return;
+        if (pass) {
+            this.collected.set(this.keyOf(item), item);
+            this.emit('collect', item);
+            this.resetIdle();
+        }
+        else {
+            this.emit('ignore', item);
+        }
+        if (this.options.max && this.collected.size >= this.options.max)
+            this.stop('limit');
+        else if (this.options.maxProcessed && this.processed >= this.options.maxProcessed)
+            this.stop('processedLimit');
+    }
+    stop(reason = 'user') {
+        if (this.ended)
+            return;
+        this.ended = true;
+        this.endReason = reason;
+        if (this.timer)
+            clearTimeout(this.timer);
+        if (this.idleTimer)
+            clearTimeout(this.idleTimer);
+        this.cleanup();
+        this.emit('end', this.collected, reason);
+    }
+    resetIdle() {
+        if (!this.options.idle)
+            return;
+        if (this.idleTimer)
+            clearTimeout(this.idleTimer);
+        this.idleTimer = setTimeout(() => this.stop('idle'), this.options.idle);
+    }
+}
+export function awaitCollector(collector, errors = []) {
+    return new Promise((resolve, reject) => {
+        collector.once('end', (collected, reason) => {
+            if (errors.includes(reason))
+                reject(new CollectorError(collected, reason));
+            else
+                resolve(collected);
+        });
+    });
+}

package/dist/esm/collectors/InteractionCollector.d.ts

@@ -0,0 +1,21 @@
+import type { Client } from '../client/Client.js';
+import type { BaseInteraction } from '../structures/interactions/BaseInteraction.js';
+import { Collector, type CollectorOptions } from './Collector.js';
+export interface InteractionCollectorOptions extends CollectorOptions<BaseInteraction> {
+    channelId?: string;
+    serverId?: string;
+    messageId?: string;
+    customId?: string;
+    componentType?: number;
+    userId?: string;
+    interactionType?: 'component' | 'modal_submit' | 'command';
+}
+export declare class InteractionCollector extends Collector<BaseInteraction> {
+    private readonly client;
+    private readonly criteria;
+    private readonly listener;
+    constructor(client: Client, criteria?: InteractionCollectorOptions);
+    protected keyOf(interaction: BaseInteraction): string;
+    protected cleanup(): void;
+    private matches;
+}

package/dist/esm/collectors/InteractionCollector.js

@@ -0,0 +1,40 @@
+import { Collector } from './Collector.js';
+export class InteractionCollector extends Collector {
+    client;
+    criteria;
+    listener = (interaction) => {
+        if (this.matches(interaction))
+            void this.handle(interaction);
+    };
+    constructor(client, criteria = {}) {
+        super(criteria);
+        this.client = client;
+        this.criteria = criteria;
+        client.on('interactionCreate', this.listener);
+    }
+    keyOf(interaction) {
+        return interaction.id;
+    }
+    cleanup() {
+        this.client.off('interactionCreate', this.listener);
+    }
+    matches(i) {
+        const c = this.criteria;
+        const kind = c.interactionType ?? 'component';
+        if (kind === 'component' ? !i.isMessageComponent() : kind === 'modal_submit' ? !i.isModalSubmit() : !i.isChatInputCommand())
+            return false;
+        if (c.channelId && i.channelId !== c.channelId)
+            return false;
+        if (c.serverId && i.serverId !== c.serverId)
+            return false;
+        if (c.userId && i.user.id !== c.userId)
+            return false;
+        if (c.messageId && i.message?.id !== c.messageId)
+            return false;
+        if (c.customId && (i.isMessageComponent() || i.isModalSubmit() ? i.customId : null) !== c.customId)
+            return false;
+        if (c.componentType !== undefined && (!i.isMessageComponent() || i.componentType !== c.componentType))
+            return false;
+        return true;
+    }
+}

package/dist/esm/collectors/MessageCollector.d.ts

@@ -0,0 +1,14 @@
+import type { TextBasedChannel } from '../structures/channels/TextBasedChannel.js';
+import type { Message } from '../structures/Message.js';
+import { Collector, type CollectorOptions } from './Collector.js';
+export type MessageCollectorOptions = CollectorOptions<Message>;
+export interface AwaitMessagesOptions extends MessageCollectorOptions {
+    errors?: string[];
+}
+export declare class MessageCollector extends Collector<Message> {
+    readonly channel: TextBasedChannel;
+    private readonly listener;
+    constructor(channel: TextBasedChannel, options?: MessageCollectorOptions);
+    protected keyOf(message: Message): string;
+    protected cleanup(): void;
+}

package/dist/esm/collectors/MessageCollector.js

@@ -0,0 +1,19 @@
+import { Collector } from './Collector.js';
+export class MessageCollector extends Collector {
+    channel;
+    listener = (message) => {
+        if (message.channelId === this.channel.id)
+            void this.handle(message);
+    };
+    constructor(channel, options = {}) {
+        super(options);
+        this.channel = channel;
+        channel.client.on('messageCreate', this.listener);
+    }
+    keyOf(message) {
+        return message.id;
+    }
+    cleanup() {
+        this.channel.client.off('messageCreate', this.listener);
+    }
+}

package/dist/esm/errors/BaffError.d.ts

@@ -0,0 +1,26 @@
+export declare class BaffError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string, options?: {
+        cause?: unknown;
+    });
+}
+export interface APIErrorBody {
+    error?: {
+        code?: string;
+        message?: string;
+        field?: string | null;
+        limitedUntil?: string;
+    };
+}
+export declare class BaffAPIError extends BaffError {
+    readonly status: number;
+    readonly method: string;
+    readonly path: string;
+    readonly field: string | null;
+    readonly body: unknown;
+    constructor(status: number, method: string, path: string, body: unknown);
+}
+export declare class BaffRateLimitError extends BaffAPIError {
+    readonly retryAfter: number;
+    constructor(method: string, path: string, body: unknown, retryAfter: number);
+}

package/dist/esm/errors/BaffError.js

@@ -0,0 +1,33 @@
+export class BaffError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.name = 'BaffError';
+        this.code = code;
+    }
+}
+export class BaffAPIError extends BaffError {
+    status;
+    method;
+    path;
+    field;
+    body;
+    constructor(status, method, path, body) {
+        const detail = body?.error;
+        super(detail?.code ?? `HTTP_${status}`, detail?.message ?? `${method} ${path} failed with status ${status}.`);
+        this.name = 'BaffAPIError';
+        this.status = status;
+        this.method = method;
+        this.path = path;
+        this.field = detail?.field ?? null;
+        this.body = body;
+    }
+}
+export class BaffRateLimitError extends BaffAPIError {
+    retryAfter;
+    constructor(method, path, body, retryAfter) {
+        super(429, method, path, body);
+        this.name = 'BaffRateLimitError';
+        this.retryAfter = retryAfter;
+    }
+}

package/dist/esm/gateway/Gateway.d.ts

@@ -0,0 +1,53 @@
+import { TypedEmitter } from '../util/TypedEmitter.js';
+export interface WebSocketLike {
+    readyState: number;
+    close(code?: number, reason?: string): void;
+    onopen: ((event: unknown) => void) | null;
+    onmessage: ((event: {
+        data: unknown;
+    }) => void) | null;
+    onclose: ((event: {
+        code: number;
+        reason: string;
+    }) => void) | null;
+    onerror: ((event: unknown) => void) | null;
+}
+export type WebSocketConstructor = new (url: string, options?: {
+    headers?: Record<string, string>;
+}) => WebSocketLike;
+export interface GatewayOptions {
+    url?: string;
+    token: string;
+    WebSocket?: WebSocketConstructor;
+    reconnect?: boolean;
+    initialBackoff?: number;
+    maxBackoff?: number;
+}
+type GatewayEvents = {
+    dispatch: [event: string, data: unknown];
+    ready: [data: unknown];
+    reconnected: [data: unknown];
+    disconnect: [code: number, reason: string];
+    reconnecting: [attempt: number, delay: number];
+    debug: [message: string];
+};
+export declare class Gateway extends TypedEmitter<GatewayEvents> {
+    private readonly options;
+    private socket;
+    private timer;
+    private attempt;
+    private destroyed;
+    private everReady;
+    private readonly url;
+    private readonly WebSocketImpl;
+    private readonly reconnect;
+    private readonly initialBackoff;
+    private readonly maxBackoff;
+    constructor(options: GatewayOptions);
+    get connected(): boolean;
+    connect(): Promise<unknown>;
+    destroy(code?: number, reason?: string): void;
+    private open;
+    private scheduleReconnect;
+}
+export {};

package/dist/esm/gateway/Gateway.js

@@ -0,0 +1,124 @@
+import { BaffError } from '../errors/BaffError.js';
+import { DEFAULT_GATEWAY_URL } from '../util/constants.js';
+import { TypedEmitter } from '../util/TypedEmitter.js';
+const OPEN = 1;
+export class Gateway extends TypedEmitter {
+    options;
+    socket = null;
+    timer = null;
+    attempt = 0;
+    destroyed = false;
+    everReady = false;
+    url;
+    WebSocketImpl;
+    reconnect;
+    initialBackoff;
+    maxBackoff;
+    constructor(options) {
+        super();
+        this.options = options;
+        this.url = options.url ?? DEFAULT_GATEWAY_URL;
+        this.reconnect = options.reconnect ?? true;
+        this.initialBackoff = options.initialBackoff ?? 1000;
+        this.maxBackoff = options.maxBackoff ?? 30_000;
+        this.WebSocketImpl = options.WebSocket ?? defaultWebSocket();
+    }
+    get connected() {
+        return this.socket?.readyState === OPEN;
+    }
+    connect() {
+        this.destroyed = false;
+        return new Promise((resolve, reject) => this.open(resolve, reject));
+    }
+    destroy(code = 1000, reason = 'client destroyed') {
+        this.destroyed = true;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+        const socket = this.socket;
+        this.socket = null;
+        if (!socket)
+            return;
+        socket.onclose = socket.onerror = socket.onmessage = socket.onopen = null;
+        try {
+            socket.close(code, reason);
+        }
+        catch {
+            // already closed
+        }
+    }
+    open(resolve, reject) {
+        let socket;
+        try {
+            socket = new this.WebSocketImpl(this.url, { headers: { Authorization: `Bot ${this.options.token}` } });
+        }
+        catch (cause) {
+            const error = new BaffError('GATEWAY_CONNECT', `Could not open the gateway: ${cause.message}`, { cause });
+            if (reject && !this.everReady)
+                return reject(error);
+            return this.scheduleReconnect(resolve, reject);
+        }
+        this.socket = socket;
+        let settled = false;
+        socket.onmessage = (event) => {
+            const frame = parseFrame(event.data);
+            if (!frame)
+                return;
+            if (frame.t === 'READY') {
+                const first = !this.everReady;
+                this.everReady = true;
+                this.attempt = 0;
+                settled = true;
+                this.emit(first ? 'ready' : 'reconnected', frame.d);
+                resolve?.(frame.d);
+                return;
+            }
+            this.emit('dispatch', frame.t, frame.d);
+        };
+        socket.onerror = () => {
+            this.emit('debug', 'socket error');
+        };
+        socket.onclose = (event) => {
+            if (this.socket !== socket)
+                return;
+            this.socket = null;
+            this.emit('disconnect', event.code, event.reason);
+            if (this.destroyed)
+                return;
+            if (!settled && !this.everReady && reject) {
+                reject(new BaffError('GATEWAY_CONNECT', `The gateway closed the connection before READY (code ${event.code}). Check the token and the gateway URL.`));
+                return;
+            }
+            this.scheduleReconnect(resolve, reject);
+        };
+    }
+    scheduleReconnect(resolve, reject) {
+        if (!this.reconnect || this.destroyed)
+            return;
+        const delay = Math.min(this.initialBackoff * 2 ** this.attempt, this.maxBackoff);
+        this.attempt++;
+        this.emit('reconnecting', this.attempt, delay);
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            if (!this.destroyed)
+                this.open(resolve, reject);
+        }, delay);
+    }
+}
+function parseFrame(data) {
+    const text = typeof data === 'string' ? data : data instanceof ArrayBuffer ? new TextDecoder().decode(data) : String(data);
+    try {
+        const frame = JSON.parse(text);
+        return typeof frame.t === 'string' ? { t: frame.t, d: frame.d } : null;
+    }
+    catch {
+        return null;
+    }
+}
+function defaultWebSocket() {
+    const ctor = globalThis.WebSocket;
+    if (typeof ctor !== 'function') {
+        throw new BaffError('NO_WEBSOCKET', 'This runtime has no global WebSocket. Use Node 22+, Bun or Deno, run Node 20 with --experimental-websocket, or pass the ws package as the WebSocket option.');
+    }
+    return ctor;
+}

package/dist/esm/http/handler.d.ts

@@ -0,0 +1,11 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { Client } from '../client/Client.js';
+import { type VerifyOptions } from './verify.js';
+export interface InteractionsHandlerOptions extends VerifyOptions {
+    secret: string;
+    client?: Client;
+    answerWithinMs?: number;
+}
+export type InteractionsHandler = (request: Request) => Promise<Response>;
+export declare function createInteractionsHandler(options: InteractionsHandlerOptions): InteractionsHandler;
+export declare function toNodeListener(handler: InteractionsHandler): (req: IncomingMessage, res: ServerResponse) => void;

package/dist/esm/http/handler.js

@@ -0,0 +1,68 @@
+import { Client } from '../client/Client.js';
+import { createInteraction } from '../structures/interactions/createInteraction.js';
+import { verifyRequestHeaders } from './verify.js';
+export function createInteractionsHandler(options) {
+    const client = options.client ?? new Client();
+    const answerWithinMs = options.answerWithinMs ?? 2800;
+    return async (request) => {
+        if (request.method !== 'POST')
+            return new Response('method not allowed', { status: 405 });
+        const body = await request.text();
+        if (!verifyRequestHeaders(request.headers, body, options.secret, options))
+            return new Response('bad signature', { status: 401 });
+        let raw;
+        try {
+            raw = JSON.parse(body);
+        }
+        catch {
+            return new Response('bad request', { status: 400 });
+        }
+        if (raw.type === 'ping')
+            return Response.json({ type: 'pong' });
+        client.setApplicationId(raw.applicationId);
+        let respond;
+        const answered = new Promise((resolve) => (respond = resolve));
+        const timeout = new Promise((resolve) => {
+            const timer = setTimeout(() => resolve(new Response(null, { status: 200 })), answerWithinMs);
+            void answered.then(() => clearTimeout(timer));
+        });
+        try {
+            const interaction = createInteraction(client, raw);
+            interaction._setSink((answer) => respond(Response.json(answer)));
+            client.emit('interactionCreate', interaction);
+            const response = await Promise.race([answered, timeout]);
+            interaction._setSink(null);
+            return response;
+        }
+        catch (error) {
+            client.emit('debug', `Interaction handler failed: ${error.message}`);
+            return new Response('internal error', { status: 500 });
+        }
+    };
+}
+export function toNodeListener(handler) {
+    return (req, res) => {
+        const chunks = [];
+        req.on('data', (chunk) => chunks.push(chunk));
+        req.on('end', () => {
+            const headers = new Headers();
+            for (const [key, value] of Object.entries(req.headers)) {
+                if (Array.isArray(value))
+                    value.forEach((v) => headers.append(key, v));
+                else if (value !== undefined)
+                    headers.set(key, value);
+            }
+            const request = new Request(`http://${req.headers.host ?? 'localhost'}${req.url ?? '/'}`, {
+                method: req.method,
+                headers,
+                body: req.method === 'GET' || req.method === 'HEAD' ? undefined : Buffer.concat(chunks)
+            });
+            handler(request).then(async (response) => {
+                res.writeHead(response.status, Object.fromEntries(response.headers));
+                res.end(Buffer.from(await response.arrayBuffer()));
+            }, () => {
+                res.writeHead(500).end('internal error');
+            });
+        });
+    };
+}

package/dist/esm/http/verify.d.ts

@@ -0,0 +1,11 @@
+export declare const SIGNATURE_HEADERS: readonly ["x-bafflux-signature", "x-baff.gg-signature"];
+export declare const TIMESTAMP_HEADERS: readonly ["x-bafflux-timestamp", "x-baff.gg-timestamp"];
+export interface VerifyOptions {
+    toleranceSeconds?: number;
+    now?: () => number;
+}
+export declare function sign(secret: string, timestamp: string | number, body: string | Uint8Array): string;
+export declare function verifyKey(body: string | Uint8Array, signature: string | null | undefined, timestamp: string | null | undefined, secret: string, options?: VerifyOptions): boolean;
+export declare function verifyRequestHeaders(headers: {
+    get(name: string): string | null;
+}, body: string | Uint8Array, secret: string, options?: VerifyOptions): boolean;