baff.js 0.0.0-stage → 0.1.1

package/dist/esm/managers/MessageManager.d.ts

@@ -0,0 +1,32 @@
+import { type MessageOptions } from '../builders/messagePayload.js';
+import type { TextBasedChannel } from '../structures/channels/TextBasedChannel.js';
+import { Message } from '../structures/Message.js';
+import type { APIMessage } from '../types.js';
+import { Collection } from '../util/Collection.js';
+import { type EmojiResolvable } from '../util/emoji.js';
+export interface FetchMessagesOptions {
+    limit?: number;
+    before?: string;
+    after?: string;
+    around?: string;
+}
+export declare class MessageManager {
+    readonly channel: TextBasedChannel;
+    readonly cache: Collection<string, Message>;
+    constructor(channel: TextBasedChannel);
+    private get client();
+    _add(data: APIMessage): Message;
+    _remove(id: string): Message | null;
+    private trim;
+    fetch(id: string, options?: {
+        force?: boolean;
+    }): Promise<Message>;
+    fetch(options?: FetchMessagesOptions): Promise<Collection<string, Message>>;
+    fetchPinned(): Promise<Collection<string, Message>>;
+    send(options: string | MessageOptions): Promise<Message>;
+    edit(id: string, options: string | MessageOptions): Promise<Message>;
+    delete(id: string): Promise<void>;
+    react(id: string, emoji: EmojiResolvable): Promise<void>;
+    pin(id: string): Promise<void>;
+    unpin(id: string): Promise<void>;
+}

package/dist/esm/managers/MessageManager.js

@@ -0,0 +1,75 @@
+import { resolveMessage } from '../builders/messagePayload.js';
+import { BaffAPIError } from '../errors/BaffError.js';
+import { Routes } from '../rest/Routes.js';
+import { Message } from '../structures/Message.js';
+import { Collection } from '../util/Collection.js';
+import { resolveEmoji } from '../util/emoji.js';
+export class MessageManager {
+    channel;
+    cache = new Collection();
+    constructor(channel) {
+        this.channel = channel;
+    }
+    get client() {
+        return this.channel.client;
+    }
+    _add(data) {
+        const existing = this.cache.get(data.id);
+        const message = existing ? existing._patch(data) : new Message(this.client, data);
+        this.cache.delete(message.id);
+        this.cache.set(message.id, message);
+        this.trim();
+        return message;
+    }
+    _remove(id) {
+        const message = this.cache.get(id) ?? null;
+        this.cache.delete(id);
+        return message;
+    }
+    trim() {
+        const limit = this.client.options.messageCacheLimit;
+        while (this.cache.size > limit)
+            this.cache.delete(this.cache.firstKey());
+    }
+    async fetch(arg = {}, options = {}) {
+        if (typeof arg === 'string') {
+            const cached = this.cache.get(arg);
+            if (cached && !options.force)
+                return cached;
+            const list = await this.client.rest.get(Routes.channelMessages(this.channel.id), { query: { around: arg, limit: 1 } });
+            const found = list.find((m) => m.id === arg);
+            if (!found)
+                throw new BaffAPIError(404, 'GET', Routes.channelMessage(this.channel.id, arg), { error: { code: 'unknown_message', message: 'Message not found.' } });
+            return this._add(found);
+        }
+        const list = await this.client.rest.get(Routes.channelMessages(this.channel.id), { query: { ...arg } });
+        return new Collection(list.map((data) => [data.id, this._add(data)]));
+    }
+    async fetchPinned() {
+        const list = await this.client.rest.get(Routes.channelPins(this.channel.id));
+        return new Collection(list.map((data) => [data.id, this._add(data)]));
+    }
+    async send(options) {
+        const { body, files } = resolveMessage(options);
+        const data = await this.client.rest.post(Routes.channelMessages(this.channel.id), { body, files });
+        return this._add({ serverId: this.channel.serverId, ...data });
+    }
+    async edit(id, options) {
+        const { body } = resolveMessage(options);
+        const data = await this.client.rest.patch(Routes.channelMessage(this.channel.id, id), { body });
+        return this._add({ serverId: this.channel.serverId, ...data });
+    }
+    async delete(id) {
+        await this.client.rest.delete(Routes.channelMessage(this.channel.id, id));
+        this._remove(id);
+    }
+    async react(id, emoji) {
+        await this.client.rest.put(Routes.messageReaction(this.channel.id, id, resolveEmoji(emoji)));
+    }
+    async pin(id) {
+        await this.client.rest.put(Routes.channelPin(this.channel.id, id));
+    }
+    async unpin(id) {
+        await this.client.rest.delete(Routes.channelPin(this.channel.id, id));
+    }
+}

package/dist/esm/managers/RoleManager.d.ts

@@ -0,0 +1,22 @@
+import type { Client } from '../client/Client.js';
+import { Role, type RoleEditData } from '../structures/Role.js';
+import type { APIRole } from '../types.js';
+import { Collection } from '../util/Collection.js';
+import { CachedManager } from './CachedManager.js';
+export declare class RoleManager extends CachedManager<Role> {
+    readonly serverId: string;
+    constructor(client: Client, serverId: string);
+    _add(data: APIRole): Role;
+    _setAll(list: APIRole[]): {
+        created: Role[];
+        updated: [Role, Role][];
+        deleted: Role[];
+    };
+    get everyone(): Role | null;
+    get highest(): Role | null;
+    fetch(): Promise<Collection<string, Role>>;
+    create(data?: RoleEditData): Promise<Role>;
+    edit(role: string | Role, data: RoleEditData): Promise<Role>;
+    delete(role: string | Role): Promise<void>;
+    reorder(ids: string[]): Promise<void>;
+}

package/dist/esm/managers/RoleManager.js

@@ -0,0 +1,69 @@
+import { Routes } from '../rest/Routes.js';
+import { Role, roleEditBody } from '../structures/Role.js';
+import { CachedManager } from './CachedManager.js';
+export class RoleManager extends CachedManager {
+    serverId;
+    constructor(client, serverId) {
+        super(client);
+        this.serverId = serverId;
+    }
+    _add(data) {
+        const existing = this.cache.get(data.id);
+        if (existing)
+            return existing._patch(data);
+        const role = new Role(this.client, this.serverId, data);
+        this.cache.set(role.id, role);
+        return role;
+    }
+    _setAll(list) {
+        const created = [];
+        const updated = [];
+        const seen = new Set();
+        for (const data of list) {
+            seen.add(data.id);
+            const existing = this.cache.get(data.id);
+            if (!existing)
+                created.push(this._add(data));
+            else
+                updated.push([existing._clone(), this._add(data)]);
+        }
+        const deleted = [];
+        for (const [id, role] of [...this.cache]) {
+            if (!seen.has(id)) {
+                this.cache.delete(id);
+                deleted.push(role);
+            }
+        }
+        return { created, updated, deleted };
+    }
+    get everyone() {
+        return this.cache.get(this.serverId) ?? null;
+    }
+    get highest() {
+        return this.cache.toSorted((a, b) => b.position - a.position).first() ?? null;
+    }
+    async fetch() {
+        this._setAll(await this.client.rest.get(Routes.serverRoles(this.serverId)));
+        return this.cache;
+    }
+    async create(data = {}) {
+        const created = await this.client.rest.post(Routes.serverRoles(this.serverId), { body: data.name ? { name: data.name } : {} });
+        const role = this._add(created);
+        const { name: _name, ...rest } = data;
+        return Object.keys(rest).length ? role.edit(rest) : role;
+    }
+    async edit(role, data) {
+        const target = typeof role === 'string' ? this.cache.get(role) : role;
+        if (target)
+            return target.edit(data);
+        return this._add(await this.client.rest.patch(Routes.serverRole(this.serverId, role), { body: roleEditBody(data) }));
+    }
+    async delete(role) {
+        const id = this.resolveId(role);
+        await this.client.rest.delete(Routes.serverRole(this.serverId, id));
+        this.cache.delete(id);
+    }
+    async reorder(ids) {
+        await this.client.rest.put(Routes.serverRoles(this.serverId), { body: { ids } });
+    }
+}

package/dist/esm/managers/ServerChannelManager.d.ts

@@ -0,0 +1,20 @@
+import type { Client } from '../client/Client.js';
+import type { Channel, ServerChannel } from '../structures/channels/ServerChannels.js';
+import type { ChannelKind } from '../types.js';
+import type { Collection } from '../util/Collection.js';
+export interface CreateChannelOptions {
+    name: string;
+    kind?: Exclude<ChannelKind, 'thread' | 'dm' | 'group_dm' | 'stage'>;
+    parentId?: string | null;
+}
+export declare class ServerChannelManager {
+    private readonly client;
+    readonly serverId: string;
+    constructor(client: Client, serverId: string);
+    get cache(): Collection<string, ServerChannel>;
+    create(options: CreateChannelOptions): Promise<ServerChannel>;
+    delete(channel: string | {
+        id: string;
+    }): Promise<void>;
+    resolve(id: string): Channel | null;
+}

package/dist/esm/managers/ServerChannelManager.js

@@ -0,0 +1,26 @@
+import { Routes } from '../rest/Routes.js';
+export class ServerChannelManager {
+    client;
+    serverId;
+    constructor(client, serverId) {
+        this.client = client;
+        this.serverId = serverId;
+    }
+    get cache() {
+        return this.client.channels.forServer(this.serverId);
+    }
+    async create(options) {
+        const data = await this.client.rest.post(Routes.serverChannels(this.serverId), {
+            body: { name: options.name, kind: options.kind ?? 'text', parentId: options.parentId ?? null }
+        });
+        return this.client.channels._upsert({ ...data, serverId: this.serverId });
+    }
+    async delete(channel) {
+        const id = typeof channel === 'string' ? channel : channel.id;
+        await this.client.rest.delete(Routes.channel(id));
+        this.client.channels._remove(id);
+    }
+    resolve(id) {
+        return this.cache.get(id) ?? null;
+    }
+}

package/dist/esm/managers/ServerManager.d.ts

@@ -0,0 +1,12 @@
+import { Server } from '../structures/Server.js';
+import type { APIServer, APIServerSummary } from '../types.js';
+import { Collection } from '../util/Collection.js';
+import { CachedManager, type FetchOptions } from './CachedManager.js';
+export declare class ServerManager extends CachedManager<Server> {
+    _add(data: APIServerSummary | APIServer): Server;
+    _remove(id: string): Server | null;
+    fetch(): Promise<Collection<string, Server>>;
+    fetch(id: string, options?: FetchOptions): Promise<Server>;
+    fetch(id: undefined, options: FetchOptions): Promise<Collection<string, Server>>;
+    leave(id: string): Promise<void>;
+}

package/dist/esm/managers/ServerManager.js

@@ -0,0 +1,58 @@
+import { Routes } from '../rest/Routes.js';
+import { Server } from '../structures/Server.js';
+import { Collection } from '../util/Collection.js';
+import { CachedManager } from './CachedManager.js';
+const isDetail = (data) => 'channels' in data && 'roles' in data;
+export class ServerManager extends CachedManager {
+    _add(data) {
+        let server = this.cache.get(data.id);
+        if (!server) {
+            server = new Server(this.client, data);
+            this.cache.set(server.id, server);
+        }
+        else {
+            server._patch(data);
+        }
+        if (isDetail(data))
+            server._applyDetail(data);
+        return server;
+    }
+    _remove(id) {
+        const server = this.cache.get(id) ?? null;
+        this.cache.delete(id);
+        for (const channel of server?.channels.cache.values() ?? [])
+            this.client.channels._remove(channel.id);
+        return server;
+    }
+    async fetch(id, options = {}) {
+        if (id !== undefined) {
+            const cached = this.cache.get(id);
+            if (cached?.detailed && !options.force)
+                return cached;
+            return this._add(await this.client.rest.get(Routes.server(id)));
+        }
+        const list = await this.client.rest.get(Routes.servers());
+        const out = new Collection();
+        const queue = [...list];
+        const worker = async () => {
+            for (let next = queue.shift(); next; next = queue.shift()) {
+                try {
+                    out.set(next.id, this._add(await this.client.rest.get(Routes.server(next.id))));
+                }
+                catch (error) {
+                    this.client.emit('debug', `Could not load server ${next.id}: ${error.message}`);
+                    out.set(next.id, this._add(next));
+                }
+            }
+        };
+        await Promise.all(Array.from({ length: Math.min(4, queue.length) }, worker));
+        for (const id of this.cache.keys())
+            if (!list.some((s) => s.id === id))
+                this._remove(id);
+        return out;
+    }
+    async leave(id) {
+        await this.client.rest.delete(Routes.serverLeave(id));
+        this._remove(id);
+    }
+}

package/dist/esm/managers/ThreadManager.d.ts

@@ -0,0 +1,12 @@
+import type { TextChannel, ThreadChannel } from '../structures/channels/ServerChannels.js';
+import { Collection } from '../util/Collection.js';
+export declare class ThreadManager {
+    private readonly channel;
+    constructor(channel: TextChannel);
+    create(options: {
+        name: string;
+        messageId?: string;
+        autoArchiveMinutes?: 60 | 1440 | 4320 | 10080;
+    }): Promise<ThreadChannel>;
+    fetch(): Promise<Collection<string, ThreadChannel>>;
+}

package/dist/esm/managers/ThreadManager.js

@@ -0,0 +1,16 @@
+import { Routes } from '../rest/Routes.js';
+import { Collection } from '../util/Collection.js';
+export class ThreadManager {
+    channel;
+    constructor(channel) {
+        this.channel = channel;
+    }
+    async create(options) {
+        const data = await this.channel.client.rest.post(Routes.channelThreads(this.channel.id), { body: options });
+        return this.channel.client.channels._addThread(data);
+    }
+    async fetch() {
+        const list = await this.channel.client.rest.get(Routes.channelThreads(this.channel.id));
+        return new Collection(list.map((data) => [data.id, this.channel.client.channels._addThread(data)]));
+    }
+}

package/dist/esm/managers/UserManager.d.ts

@@ -0,0 +1,11 @@
+import type { DMChannel } from '../structures/channels/DMChannel.js';
+import { User } from '../structures/User.js';
+import type { APIUser } from '../types.js';
+import { CachedManager, type FetchOptions } from './CachedManager.js';
+export declare class UserManager extends CachedManager<User> {
+    private readonly tags;
+    _add(data: APIUser): User;
+    fetchTags(): Promise<void>;
+    fetch(id: string, options?: FetchOptions): Promise<User>;
+    createDM(userId: string): Promise<DMChannel>;
+}

package/dist/esm/managers/UserManager.js

@@ -0,0 +1,34 @@
+import { Routes } from '../rest/Routes.js';
+import { User } from '../structures/User.js';
+import { CachedManager } from './CachedManager.js';
+export class UserManager extends CachedManager {
+    tags = new Map();
+    _add(data) {
+        const known = data.tag === undefined ? this.tags.get(data.id) : undefined;
+        const patch = known ? { ...data, tag: known } : data;
+        const existing = this.cache.get(data.id);
+        if (existing)
+            return existing._patch(patch);
+        const user = new User(this.client, patch);
+        this.cache.set(user.id, user);
+        return user;
+    }
+    async fetchTags() {
+        const list = await this.client.rest.get(Routes.userTags());
+        for (const { id, tag } of list) {
+            this.tags.set(id, tag);
+            this.cache.get(id)?._patch({ tag });
+        }
+    }
+    async fetch(id, options = {}) {
+        const cached = this.cache.get(id);
+        if (cached && !options.force)
+            return cached;
+        const profile = await this.client.rest.get(Routes.userProfile(id));
+        return this._add(profile.user);
+    }
+    async createDM(userId) {
+        const data = await this.client.rest.post(Routes.dms(), { body: { recipientId: userId } });
+        return this.client.channels._addDM(data);
+    }
+}

package/dist/esm/managers/VoiceManager.d.ts

@@ -0,0 +1,8 @@
+import type { Client } from '../client/Client.js';
+import type { APIVoiceJoin } from '../types.js';
+export declare class VoiceManager {
+    private readonly client;
+    constructor(client: Client);
+    join(channelId: string): Promise<APIVoiceJoin>;
+    leave(serverId?: string): Promise<void>;
+}

package/dist/esm/managers/VoiceManager.js

@@ -0,0 +1,13 @@
+import { Routes } from '../rest/Routes.js';
+export class VoiceManager {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    join(channelId) {
+        return this.client.rest.post(Routes.channelVoice(channelId));
+    }
+    async leave(serverId) {
+        await this.client.rest.delete(Routes.voice(), { query: { serverId } });
+    }
+}

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/esm/rest/REST.d.ts

@@ -0,0 +1,58 @@
+import { TypedEmitter } from '../util/TypedEmitter.js';
+import { type RawFile } from './files.js';
+export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+export type QueryValue = string | number | boolean | undefined | null | readonly (string | number)[];
+export interface RESTOptions {
+    api?: string;
+    token?: string;
+    timeout?: number;
+    retries?: number;
+    maxRateLimitRetries?: number;
+    userAgent?: string;
+    fetch?: typeof fetch;
+}
+export interface RequestOptions {
+    query?: Record<string, QueryValue>;
+    body?: unknown;
+    files?: readonly RawFile[];
+    auth?: boolean;
+    signal?: AbortSignal;
+    raw?: boolean;
+}
+export interface RateLimitInfo {
+    method: HTTPMethod;
+    path: string;
+    retryAfter: number;
+    global: boolean;
+}
+type RESTEvents = {
+    rateLimited: [RateLimitInfo];
+    debug: [string];
+};
+export declare function bucketKey(method: HTTPMethod, path: string): string;
+export declare class REST extends TypedEmitter<RESTEvents> {
+    readonly api: string;
+    token: string | null;
+    private readonly timeout;
+    private readonly retries;
+    private readonly maxRateLimitRetries;
+    private readonly userAgent;
+    private readonly fetchImpl;
+    private readonly buckets;
+    private readonly sent;
+    private globalBlockedUntil;
+    constructor(options?: RESTOptions);
+    setToken(token: string): this;
+    get<T = unknown>(path: string, options?: RequestOptions): Promise<T>;
+    post<T = unknown>(path: string, options?: RequestOptions): Promise<T>;
+    put<T = unknown>(path: string, options?: RequestOptions): Promise<T>;
+    patch<T = unknown>(path: string, options?: RequestOptions): Promise<T>;
+    delete<T = unknown>(path: string, options?: RequestOptions): Promise<T>;
+    request<T = unknown>(method: HTTPMethod, path: string, options?: RequestOptions): Promise<T>;
+    private send;
+    private waitTurn;
+    private url;
+    private init;
+    private backoff;
+}
+export {};

package/dist/esm/rest/REST.js

@@ -0,0 +1,188 @@
+import { BaffAPIError, BaffError, BaffRateLimitError } from '../errors/BaffError.js';
+import { DEFAULT_API_URL, VERSION } from '../util/constants.js';
+import { TypedEmitter } from '../util/TypedEmitter.js';
+import { buildForm } from './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));
+export 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;
+    }
+}
+export class REST extends TypedEmitter {
+    api;
+    token;
+    timeout;
+    retries;
+    maxRateLimitRetries;
+    userAgent;
+    fetchImpl;
+    buckets = new Map();
+    sent = [];
+    globalBlockedUntil = 0;
+    constructor(options = {}) {
+        super();
+        this.api = (options.api ?? 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/${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('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('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 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 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 = 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);
+    }
+}
+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);
+}