baff.js 0.0.0-stage → 0.1.0

package/dist/cjs/rest/REST.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REST = void 0;
+exports.bucketKey = bucketKey;
+const BaffError_js_1 = require("../errors/BaffError.js");
+const constants_js_1 = require("../util/constants.js");
+const TypedEmitter_js_1 = require("../util/TypedEmitter.js");
+const files_js_1 = require("./files.js");
+const MESSAGE_WINDOW = { limit: 5, ms: 5000 };
+const IDEMPOTENT = new Set(['GET', 'PUT', 'DELETE']);
+const MAJOR = new Set(['channels', 'servers', 'webhooks', 'interactions', 'applications']);
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function bucketKey(method, path) {
+    const parts = path.split('?')[0].split('/').filter(Boolean);
+    const out = [];
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        const previous = parts[i - 1];
+        const isId = /^\d{5,}$/.test(part) || /^[0-9a-f]{32,}$/i.test(part);
+        out.push(isId && !(previous && MAJOR.has(previous)) ? ':id' : part);
+    }
+    return `${method} /${out.join('/')}`;
+}
+function isMessageSend(method, path) {
+    return method === 'POST' && (/^\/channels\/\d+\/messages$/.test(path) || /^\/interactions\/[^/]+\/[^/]+\/followup$/.test(path));
+}
+class Bucket {
+    blockedUntil = 0;
+    tail = Promise.resolve();
+    run(task) {
+        const result = this.tail.then(task, task);
+        this.tail = result.catch(() => undefined);
+        return result;
+    }
+}
+class REST extends TypedEmitter_js_1.TypedEmitter {
+    api;
+    token;
+    timeout;
+    retries;
+    maxRateLimitRetries;
+    userAgent;
+    fetchImpl;
+    buckets = new Map();
+    sent = [];
+    globalBlockedUntil = 0;
+    constructor(options = {}) {
+        super();
+        this.api = (options.api ?? constants_js_1.DEFAULT_API_URL).replace(/\/+$/, '');
+        this.token = options.token ?? null;
+        this.timeout = options.timeout ?? 15_000;
+        this.retries = options.retries ?? 3;
+        this.maxRateLimitRetries = options.maxRateLimitRetries ?? 5;
+        this.userAgent = options.userAgent ?? `baff.js/${constants_js_1.VERSION} (+https://docs.baff.gg)`;
+        this.fetchImpl = options.fetch ?? ((...args) => globalThis.fetch(...args));
+    }
+    setToken(token) {
+        this.token = token.replace(/^Bot\s+/i, '').trim();
+        return this;
+    }
+    get(path, options) {
+        return this.request('GET', path, options);
+    }
+    post(path, options) {
+        return this.request('POST', path, options);
+    }
+    put(path, options) {
+        return this.request('PUT', path, options);
+    }
+    patch(path, options) {
+        return this.request('PATCH', path, options);
+    }
+    delete(path, options) {
+        return this.request('DELETE', path, options);
+    }
+    request(method, path, options = {}) {
+        const key = bucketKey(method, path);
+        let bucket = this.buckets.get(key);
+        if (!bucket)
+            this.buckets.set(key, (bucket = new Bucket()));
+        return bucket.run(() => this.send(method, path, options, bucket));
+    }
+    async send(method, path, options, bucket) {
+        const url = this.url(path, options.query);
+        const useAuth = options.auth !== false;
+        if (useAuth && !this.token)
+            throw new BaffError_js_1.BaffError('NO_TOKEN', 'No token set. Pass one to Client or call login(token).');
+        let failures = 0;
+        let limited = 0;
+        for (;;) {
+            await this.waitTurn(method, path, bucket);
+            let res;
+            try {
+                res = await this.fetchImpl(url, this.init(method, options, useAuth));
+            }
+            catch (cause) {
+                if (options.signal?.aborted)
+                    throw cause;
+                if (failures < this.retries && IDEMPOTENT.has(method)) {
+                    await sleep(this.backoff(failures++));
+                    continue;
+                }
+                throw new BaffError_js_1.BaffError('NETWORK', `${method} ${path} failed: ${cause.message}`, { cause });
+            }
+            const text = await res.text();
+            const data = parse(text);
+            if (res.ok)
+                return (options.raw ? text : data);
+            if (res.status === 429) {
+                const retryAfter = retryAfterOf(res, data, limited);
+                const code = data?.error?.code;
+                if (code === 'slowmode' || ++limited > this.maxRateLimitRetries)
+                    throw new BaffError_js_1.BaffRateLimitError(method, path, data, retryAfter);
+                bucket.blockedUntil = Date.now() + retryAfter * 1000;
+                this.emit('rateLimited', { method, path, retryAfter, global: false });
+                continue;
+            }
+            if (res.status >= 500 && failures < this.retries && IDEMPOTENT.has(method)) {
+                await sleep(this.backoff(failures++));
+                continue;
+            }
+            throw new BaffError_js_1.BaffAPIError(res.status, method, path, data);
+        }
+    }
+    async waitTurn(method, path, bucket) {
+        const wait = Math.max(bucket.blockedUntil, this.globalBlockedUntil) - Date.now();
+        if (wait > 0)
+            await sleep(wait);
+        if (!isMessageSend(method, path))
+            return;
+        for (;;) {
+            const now = Date.now();
+            while (this.sent.length && now - this.sent[0] >= MESSAGE_WINDOW.ms)
+                this.sent.shift();
+            if (this.sent.length < MESSAGE_WINDOW.limit)
+                break;
+            await sleep(this.sent[0] + MESSAGE_WINDOW.ms - now + 5);
+        }
+        this.sent.push(Date.now());
+    }
+    url(path, query) {
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(query ?? {})) {
+            if (value === undefined || value === null)
+                continue;
+            params.set(key, Array.isArray(value) ? value.join(',') : String(value));
+        }
+        const qs = params.toString();
+        return `${this.api}${path}${qs ? `?${qs}` : ''}`;
+    }
+    init(method, options, auth) {
+        const headers = { 'user-agent': this.userAgent };
+        if (auth)
+            headers.authorization = `Bot ${this.token}`;
+        let body;
+        if (options.body instanceof FormData) {
+            body = options.body;
+        }
+        else if (options.files?.length) {
+            body = (0, files_js_1.buildForm)(options.body ?? {}, options.files);
+        }
+        else if (options.body !== undefined) {
+            headers['content-type'] = 'application/json';
+            body = JSON.stringify(options.body);
+        }
+        const timeout = AbortSignal.timeout(this.timeout);
+        const signal = options.signal ? AbortSignal.any([timeout, options.signal]) : timeout;
+        return { method, headers, body, signal };
+    }
+    backoff(attempt) {
+        return Math.min(250 * 2 ** attempt, 4000) + Math.floor(Math.random() * 100);
+    }
+}
+exports.REST = REST;
+function parse(text) {
+    if (!text)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function retryAfterOf(res, data, attempt) {
+    const header = Number(res.headers.get('retry-after'));
+    if (Number.isFinite(header) && header > 0)
+        return header;
+    const body = data?.error?.retryAfter;
+    if (typeof body === 'number' && body > 0)
+        return body;
+    return Math.min(1 + attempt, 5);
+}

package/dist/cjs/rest/Routes.d.ts

@@ -0,0 +1,54 @@
+export declare const Routes: {
+    me: () => "/auth/me";
+    presence: () => "/users/@me/presence";
+    userTags: () => "/users/tags";
+    userProfile: (userId: string) => `/users/${string}/profile`;
+    dms: () => "/users/@me/channels";
+    servers: () => "/servers";
+    server: (serverId: string) => `/servers/${string}`;
+    serverLeave: (serverId: string) => `/users/@me/servers/${string}`;
+    serverSettings: (serverId: string) => `/servers/${string}/settings`;
+    serverChannels: (serverId: string) => `/servers/${string}/channels`;
+    serverMembers: (serverId: string) => `/servers/${string}/members`;
+    serverMember: (serverId: string, userId: string) => `/servers/${string}/members/${string}`;
+    memberRole: (serverId: string, userId: string, roleId: string) => `/servers/${string}/members/${string}/roles/${string}`;
+    memberTimeout: (serverId: string, userId: string) => `/servers/${string}/members/${string}/timeout`;
+    serverBans: (serverId: string) => `/servers/${string}/bans`;
+    serverBan: (serverId: string, userId: string) => `/servers/${string}/bans/${string}`;
+    serverRoles: (serverId: string) => `/servers/${string}/roles`;
+    serverRole: (serverId: string, roleId: string) => `/servers/${string}/roles/${string}`;
+    serverInvites: (serverId: string) => `/servers/${string}/invites`;
+    serverInvite: (serverId: string, code: string) => `/servers/${string}/invites/${string}`;
+    serverEmojis: (serverId: string) => `/servers/${string}/emojis`;
+    serverEmoji: (serverId: string, emojiId: string) => `/servers/${string}/emojis/${string}`;
+    serverStickers: (serverId: string) => `/servers/${string}/stickers`;
+    serverSticker: (serverId: string, stickerId: string) => `/servers/${string}/stickers/${string}`;
+    serverEvents: (serverId: string) => `/servers/${string}/events`;
+    serverEvent: (serverId: string, eventId: string) => `/servers/${string}/events/${string}`;
+    auditLog: (serverId: string) => `/servers/${string}/audit-log`;
+    voiceStates: (serverId: string) => `/servers/${string}/voice-states`;
+    invite: (code: string) => `/invites/${string}`;
+    channel: (channelId: string) => `/channels/${string}`;
+    channelMessages: (channelId: string) => `/channels/${string}/messages`;
+    channelMessage: (channelId: string, messageId: string) => `/channels/${string}/messages/${string}`;
+    messageReaction: (channelId: string, messageId: string, emoji: string) => `/channels/${string}/messages/${string}/reactions/${string}`;
+    messageCrosspost: (channelId: string, messageId: string) => `/channels/${string}/messages/${string}/crosspost`;
+    channelPins: (channelId: string) => `/channels/${string}/pins`;
+    channelPin: (channelId: string, messageId: string) => `/channels/${string}/pins/${string}`;
+    channelTyping: (channelId: string) => `/channels/${string}/typing`;
+    channelThreads: (channelId: string) => `/channels/${string}/threads`;
+    channelPosts: (channelId: string) => `/channels/${string}/posts`;
+    channelWebhooks: (channelId: string) => `/channels/${string}/webhooks`;
+    channelVoice: (channelId: string) => `/channels/${string}/voice`;
+    channelVoiceStatus: (channelId: string) => `/channels/${string}/voice-status`;
+    pollExpire: (channelId: string, messageId: string) => `/channels/${string}/polls/${string}/expire`;
+    voice: () => "/voice";
+    webhook: (webhookId: string) => `/webhooks/${string}`;
+    webhookExecute: (webhookId: string, token: string) => `/webhooks/${string}/${string}`;
+    applicationCommands: (applicationId: string) => `/applications/${string}/commands`;
+    applicationCommand: (applicationId: string, commandId: string) => `/applications/${string}/commands/${string}`;
+    serverCommands: (applicationId: string, serverId: string) => `/applications/${string}/servers/${string}/commands`;
+    interactionCallback: (id: string, token: string) => `/interactions/${string}/${string}/callback`;
+    interactionFollowup: (id: string, token: string) => `/interactions/${string}/${string}/followup`;
+    interactionOriginal: (id: string, token: string) => `/interactions/${string}/${string}/original`;
+};

package/dist/cjs/rest/Routes.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Routes = void 0;
+const e = encodeURIComponent;
+exports.Routes = {
+    me: () => '/auth/me',
+    presence: () => '/users/@me/presence',
+    userTags: () => '/users/tags',
+    userProfile: (userId) => `/users/${userId}/profile`,
+    dms: () => '/users/@me/channels',
+    servers: () => '/servers',
+    server: (serverId) => `/servers/${serverId}`,
+    serverLeave: (serverId) => `/users/@me/servers/${serverId}`,
+    serverSettings: (serverId) => `/servers/${serverId}/settings`,
+    serverChannels: (serverId) => `/servers/${serverId}/channels`,
+    serverMembers: (serverId) => `/servers/${serverId}/members`,
+    serverMember: (serverId, userId) => `/servers/${serverId}/members/${userId}`,
+    memberRole: (serverId, userId, roleId) => `/servers/${serverId}/members/${userId}/roles/${roleId}`,
+    memberTimeout: (serverId, userId) => `/servers/${serverId}/members/${userId}/timeout`,
+    serverBans: (serverId) => `/servers/${serverId}/bans`,
+    serverBan: (serverId, userId) => `/servers/${serverId}/bans/${userId}`,
+    serverRoles: (serverId) => `/servers/${serverId}/roles`,
+    serverRole: (serverId, roleId) => `/servers/${serverId}/roles/${roleId}`,
+    serverInvites: (serverId) => `/servers/${serverId}/invites`,
+    serverInvite: (serverId, code) => `/servers/${serverId}/invites/${e(code)}`,
+    serverEmojis: (serverId) => `/servers/${serverId}/emojis`,
+    serverEmoji: (serverId, emojiId) => `/servers/${serverId}/emojis/${emojiId}`,
+    serverStickers: (serverId) => `/servers/${serverId}/stickers`,
+    serverSticker: (serverId, stickerId) => `/servers/${serverId}/stickers/${stickerId}`,
+    serverEvents: (serverId) => `/servers/${serverId}/events`,
+    serverEvent: (serverId, eventId) => `/servers/${serverId}/events/${eventId}`,
+    auditLog: (serverId) => `/servers/${serverId}/audit-log`,
+    voiceStates: (serverId) => `/servers/${serverId}/voice-states`,
+    invite: (code) => `/invites/${e(code)}`,
+    channel: (channelId) => `/channels/${channelId}`,
+    channelMessages: (channelId) => `/channels/${channelId}/messages`,
+    channelMessage: (channelId, messageId) => `/channels/${channelId}/messages/${messageId}`,
+    messageReaction: (channelId, messageId, emoji) => `/channels/${channelId}/messages/${messageId}/reactions/${e(emoji)}`,
+    messageCrosspost: (channelId, messageId) => `/channels/${channelId}/messages/${messageId}/crosspost`,
+    channelPins: (channelId) => `/channels/${channelId}/pins`,
+    channelPin: (channelId, messageId) => `/channels/${channelId}/pins/${messageId}`,
+    channelTyping: (channelId) => `/channels/${channelId}/typing`,
+    channelThreads: (channelId) => `/channels/${channelId}/threads`,
+    channelPosts: (channelId) => `/channels/${channelId}/posts`,
+    channelWebhooks: (channelId) => `/channels/${channelId}/webhooks`,
+    channelVoice: (channelId) => `/channels/${channelId}/voice`,
+    channelVoiceStatus: (channelId) => `/channels/${channelId}/voice-status`,
+    pollExpire: (channelId, messageId) => `/channels/${channelId}/polls/${messageId}/expire`,
+    voice: () => '/voice',
+    webhook: (webhookId) => `/webhooks/${webhookId}`,
+    webhookExecute: (webhookId, token) => `/webhooks/${webhookId}/${e(token)}`,
+    applicationCommands: (applicationId) => `/applications/${applicationId}/commands`,
+    applicationCommand: (applicationId, commandId) => `/applications/${applicationId}/commands/${commandId}`,
+    serverCommands: (applicationId, serverId) => `/applications/${applicationId}/servers/${serverId}/commands`,
+    interactionCallback: (id, token) => `/interactions/${id}/${e(token)}/callback`,
+    interactionFollowup: (id, token) => `/interactions/${id}/${e(token)}/followup`,
+    interactionOriginal: (id, token) => `/interactions/${id}/${e(token)}/original`
+};

package/dist/cjs/rest/files.d.ts

@@ -0,0 +1,19 @@
+export type FileData = Uint8Array | ArrayBuffer | Blob | string;
+export interface RawFile {
+    name: string;
+    data: FileData;
+    contentType?: string;
+}
+export declare class AttachmentBuilder {
+    readonly data: FileData;
+    name: string;
+    contentType?: string;
+    constructor(data: FileData, options?: {
+        name?: string;
+        contentType?: string;
+    });
+    setName(name: string): this;
+    toFile(): RawFile;
+}
+export declare function toBlob(file: RawFile): Blob;
+export declare function buildForm(payload: unknown, files: readonly RawFile[]): FormData;

package/dist/cjs/rest/files.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttachmentBuilder = void 0;
+exports.toBlob = toBlob;
+exports.buildForm = buildForm;
+class AttachmentBuilder {
+    data;
+    name;
+    contentType;
+    constructor(data, options = {}) {
+        this.data = data;
+        this.name = options.name ?? 'file';
+        this.contentType = options.contentType;
+    }
+    setName(name) {
+        this.name = name;
+        return this;
+    }
+    toFile() {
+        return { name: this.name, data: this.data, contentType: this.contentType };
+    }
+}
+exports.AttachmentBuilder = AttachmentBuilder;
+function toBlob(file) {
+    if (file.data instanceof Blob)
+        return file.data;
+    const type = file.contentType ?? 'application/octet-stream';
+    const part = file.data instanceof ArrayBuffer || typeof file.data === 'string' ? file.data : new Uint8Array(file.data);
+    return new Blob([part], { type });
+}
+function buildForm(payload, files) {
+    const form = new FormData();
+    form.append('payload_json', JSON.stringify(payload));
+    for (const file of files)
+        form.append('files', toBlob(file), file.name);
+    return form;
+}

package/dist/cjs/structures/Base.d.ts

@@ -0,0 +1,13 @@
+import type { Client } from '../client/Client.js';
+export declare abstract class Base {
+    readonly client: Client;
+    constructor(client: Client);
+    _clone(): this;
+    toString(): string;
+    toJSON(): Record<string, unknown>;
+}
+export declare abstract class Identified extends Base {
+    abstract readonly id: string;
+    get createdTimestamp(): number;
+    get createdAt(): Date;
+}

package/dist/cjs/structures/Base.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Identified = exports.Base = void 0;
+const Snowflake_js_1 = require("../util/Snowflake.js");
+class Base {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    _clone() {
+        return Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+    }
+    toString() {
+        return `${this.constructor.name}`;
+    }
+    toJSON() {
+        const { client: _client, ...rest } = this;
+        return rest;
+    }
+}
+exports.Base = Base;
+class Identified extends Base {
+    get createdTimestamp() {
+        return Snowflake_js_1.Snowflake.timestampOf(this.id);
+    }
+    get createdAt() {
+        return new Date(this.createdTimestamp);
+    }
+}
+exports.Identified = Identified;

package/dist/cjs/structures/Message.d.ts

@@ -0,0 +1,91 @@
+import type { Client } from '../client/Client.js';
+import type { MessageOptions } from '../builders/messagePayload.js';
+import { InteractionCollector, type InteractionCollectorOptions } from '../collectors/InteractionCollector.js';
+import type { APIAttachment, APIComponent, APIEmbed, APIMessage, APISticker, APIUser } from '../types.js';
+import { Collection } from '../util/Collection.js';
+import { type EmojiResolvable } from '../util/emoji.js';
+import { Identified } from './Base.js';
+import type { MessageComponentInteraction } from './interactions/ComponentInteraction.js';
+import type { TextBasedChannel } from './channels/TextBasedChannel.js';
+import type { ThreadChannel } from './channels/ServerChannels.js';
+import type { Server } from './Server.js';
+import type { ServerMember } from './ServerMember.js';
+import { User } from './User.js';
+export declare class MessageReaction {
+    readonly message: Message;
+    readonly emoji: string;
+    count: number;
+    me: boolean;
+    constructor(message: Message, emoji: string, count: number, me: boolean);
+    fetchUsers(): Promise<Collection<string, User>>;
+    remove(): Promise<void>;
+}
+export declare class MessageMentions {
+    private readonly message;
+    readonly userIds: string[];
+    readonly roleIds: string[];
+    readonly everyone: boolean;
+    constructor(message: Message, userIds: string[], roleIds: string[], everyone: boolean);
+    get users(): Collection<string, User>;
+    has(target: string | {
+        id: string;
+    }, options?: {
+        ignoreEveryone?: boolean;
+    }): boolean;
+}
+export declare class Message extends Identified {
+    readonly id: string;
+    readonly channelId: string;
+    serverId: string | null;
+    author: User;
+    content: string;
+    editedAt: Date | null;
+    type: number;
+    attachments: Collection<string, APIAttachment>;
+    embeds: APIEmbed[];
+    components: APIComponent[];
+    flags: number;
+    reactions: Collection<string, MessageReaction>;
+    mentions: MessageMentions;
+    reference: {
+        id: string;
+        author: APIUser;
+        content: string;
+    } | null;
+    replyDeleted: boolean;
+    pinned: boolean;
+    crossposted: boolean;
+    stickers: APISticker[];
+    poll: unknown;
+    forward: unknown;
+    interaction: {
+        user: APIUser;
+        name: string;
+    } | null;
+    nonce: string | null;
+    constructor(client: Client, data: APIMessage);
+    _patch(data: Partial<APIMessage>): this;
+    get channel(): TextBasedChannel;
+    get server(): Server | null;
+    get member(): ServerMember | null;
+    get url(): string;
+    get editable(): boolean;
+    get isComponentsV2(): boolean;
+    reply(options: string | MessageOptions): Promise<Message>;
+    edit(options: string | MessageOptions): Promise<Message>;
+    delete(): Promise<void>;
+    react(emoji: EmojiResolvable): Promise<void>;
+    unreact(emoji: EmojiResolvable): Promise<void>;
+    pin(): Promise<void>;
+    unpin(): Promise<void>;
+    crosspost(): Promise<void>;
+    startThread(options: {
+        name: string;
+        autoArchiveMinutes?: number;
+    }): Promise<ThreadChannel>;
+    endPoll(): Promise<void>;
+    fetch(): Promise<Message>;
+    createMessageComponentCollector(options?: InteractionCollectorOptions): InteractionCollector;
+    awaitMessageComponent(options?: InteractionCollectorOptions): Promise<MessageComponentInteraction>;
+    toString(): string;
+}