baff.js 0.0.0-stage → 0.1.0

package/dist/esm/util/Permissions.js

@@ -0,0 +1,109 @@
+import { BaffError } from '../errors/BaffError.js';
+export const PermissionFlagsBits = {
+    Administrator: 1n << 0n,
+    ManageServer: 1n << 1n,
+    ManageRoles: 1n << 2n,
+    ManageChannels: 1n << 3n,
+    KickMembers: 1n << 4n,
+    BanMembers: 1n << 5n,
+    CreateInvite: 1n << 6n,
+    SendMessages: 1n << 7n,
+    ManageMessages: 1n << 8n,
+    AttachFiles: 1n << 9n,
+    AddReactions: 1n << 10n,
+    ManageExpressions: 1n << 11n,
+    MentionEveryone: 1n << 12n,
+    ViewChannel: 1n << 13n,
+    ManageWebhooks: 1n << 14n,
+    Connect: 1n << 15n,
+    Speak: 1n << 16n,
+    Video: 1n << 17n,
+    BaffleUpload: 1n << 18n,
+    BaffleWithdraw: 1n << 19n,
+    ManageBaffles: 1n << 20n,
+    ModerateMembers: 1n << 21n,
+    ViewAuditLog: 1n << 22n,
+    UseSoundboard: 1n << 23n,
+    ManageThreads: 1n << 24n,
+    ManageStage: 1n << 25n,
+    ChangeNickname: 1n << 26n,
+    ManageNicknames: 1n << 27n,
+    ManageEvents: 1n << 28n,
+    SetVoiceChannelStatus: 1n << 29n,
+    RequestToSpeak: 1n << 30n
+};
+const ALL = Object.values(PermissionFlagsBits).reduce((acc, bit) => acc | bit, 0n);
+export class PermissionsBitField {
+    static Flags = PermissionFlagsBits;
+    static All = new PermissionsBitField(ALL);
+    bitfield;
+    constructor(bits = 0n) {
+        this.bitfield = PermissionsBitField.resolve(bits);
+    }
+    static fromBits(bits) {
+        return new PermissionsBitField(BigInt(bits));
+    }
+    static resolve(bits) {
+        if (bits instanceof PermissionsBitField)
+            return bits.bitfield;
+        if (typeof bits === 'bigint')
+            return bits;
+        if (typeof bits === 'number')
+            return BigInt(bits);
+        if (Array.isArray(bits))
+            return bits.reduce((acc, bit) => acc | PermissionsBitField.resolve(bit), 0n);
+        if (typeof bits === 'string') {
+            if (/^\d+$/.test(bits))
+                return BigInt(bits);
+            const flag = PermissionFlagsBits[bits];
+            if (flag === undefined)
+                throw new BaffError('INVALID_PERMISSION', `Unknown permission "${bits}".`);
+            return flag;
+        }
+        throw new BaffError('INVALID_PERMISSION', `Cannot read ${String(bits)} as a permission.`);
+    }
+    has(permission, checkAdmin = true) {
+        if (checkAdmin && (this.bitfield & PermissionFlagsBits.Administrator) !== 0n)
+            return true;
+        const bit = PermissionsBitField.resolve(permission);
+        return (this.bitfield & bit) === bit;
+    }
+    any(permission, checkAdmin = true) {
+        if (checkAdmin && (this.bitfield & PermissionFlagsBits.Administrator) !== 0n)
+            return true;
+        return (this.bitfield & PermissionsBitField.resolve(permission)) !== 0n;
+    }
+    missing(permission, checkAdmin = true) {
+        return PermissionsBitField.names(PermissionsBitField.resolve(permission)).filter((name) => !this.has(name, checkAdmin));
+    }
+    add(...permissions) {
+        return new PermissionsBitField(permissions.reduce((acc, p) => acc | PermissionsBitField.resolve(p), this.bitfield));
+    }
+    remove(...permissions) {
+        return new PermissionsBitField(permissions.reduce((acc, p) => acc & ~PermissionsBitField.resolve(p), this.bitfield));
+    }
+    equals(other) {
+        return this.bitfield === PermissionsBitField.resolve(other);
+    }
+    toArray() {
+        return PermissionsBitField.names(this.bitfield);
+    }
+    serialize(checkAdmin = true) {
+        const out = {};
+        for (const name of Object.keys(PermissionFlagsBits))
+            out[name] = this.has(name, checkAdmin);
+        return out;
+    }
+    toJSON() {
+        return this.bitfield.toString();
+    }
+    toString() {
+        return this.bitfield.toString();
+    }
+    valueOf() {
+        return this.bitfield;
+    }
+    static names(bits) {
+        return Object.keys(PermissionFlagsBits).filter((name) => (bits & PermissionFlagsBits[name]) !== 0n);
+    }
+}

package/dist/esm/util/Snowflake.d.ts

@@ -0,0 +1,20 @@
+export interface DeconstructedSnowflake {
+    timestamp: number;
+    date: Date;
+    workerId: number;
+    sequence: number;
+    binary: string;
+}
+export interface SnowflakeParts {
+    timestamp?: number | Date;
+    workerId?: number;
+    sequence?: number;
+}
+export declare const Snowflake: {
+    EPOCH: number;
+    deconstruct(id: string | bigint): DeconstructedSnowflake;
+    timestampOf(id: string | bigint): number;
+    generate({ timestamp, workerId, sequence }?: SnowflakeParts): string;
+    compare(a: string, b: string): -1 | 0 | 1;
+    isValid(value: unknown): value is string;
+};

package/dist/esm/util/Snowflake.js

@@ -0,0 +1,37 @@
+const EPOCH = 1767225600000n;
+const WORKER_BITS = 10n;
+const SEQUENCE_BITS = 12n;
+const WORKER_MASK = (1n << WORKER_BITS) - 1n;
+const SEQUENCE_MASK = (1n << SEQUENCE_BITS) - 1n;
+export const Snowflake = {
+    EPOCH: Number(EPOCH),
+    deconstruct(id) {
+        const value = BigInt(id);
+        const timestamp = Number((value >> (WORKER_BITS + SEQUENCE_BITS)) + EPOCH);
+        return {
+            timestamp,
+            date: new Date(timestamp),
+            workerId: Number((value >> SEQUENCE_BITS) & WORKER_MASK),
+            sequence: Number(value & SEQUENCE_MASK),
+            binary: value.toString(2).padStart(64, '0')
+        };
+    },
+    timestampOf(id) {
+        return Snowflake.deconstruct(id).timestamp;
+    },
+    generate({ timestamp = Date.now(), workerId = 0, sequence = 0 } = {}) {
+        const ms = BigInt(timestamp instanceof Date ? timestamp.getTime() : timestamp);
+        if (ms < EPOCH)
+            throw new RangeError('Timestamp is before the baff.gg epoch (2026-01-01T00:00:00Z).');
+        const id = ((ms - EPOCH) << (WORKER_BITS + SEQUENCE_BITS)) | ((BigInt(workerId) & WORKER_MASK) << SEQUENCE_BITS) | (BigInt(sequence) & SEQUENCE_MASK);
+        return id.toString();
+    },
+    compare(a, b) {
+        const x = BigInt(a);
+        const y = BigInt(b);
+        return x < y ? -1 : x > y ? 1 : 0;
+    },
+    isValid(value) {
+        return typeof value === 'string' && /^\d{1,19}$/.test(value) && BigInt(value) < 1n << 63n;
+    }
+};

package/dist/esm/util/TypedEmitter.d.ts

@@ -0,0 +1,17 @@
+export type EventMap = {
+    [event: string]: unknown[];
+};
+export interface TypedEmitterShape<E extends EventMap> {
+    on<K extends keyof E & string>(event: K, listener: (...args: E[K]) => void): this;
+    once<K extends keyof E & string>(event: K, listener: (...args: E[K]) => void): this;
+    off<K extends keyof E & string>(event: K, listener: (...args: E[K]) => void): this;
+    addListener<K extends keyof E & string>(event: K, listener: (...args: E[K]) => void): this;
+    removeListener<K extends keyof E & string>(event: K, listener: (...args: E[K]) => void): this;
+    removeAllListeners(event?: keyof E & string): this;
+    emit<K extends keyof E & string>(event: K, ...args: E[K]): boolean;
+    listenerCount(event: keyof E & string): number;
+    setMaxListeners(n: number): this;
+}
+export declare const TypedEmitter: new <E extends EventMap>(options?: {
+    captureRejections?: boolean;
+}) => TypedEmitterShape<E>;

package/dist/esm/util/TypedEmitter.js

@@ -0,0 +1,2 @@
+import { EventEmitter } from 'node:events';
+export const TypedEmitter = EventEmitter;

package/dist/esm/util/constants.d.ts

@@ -0,0 +1,78 @@
+export declare const Colors: {
+    readonly Default: 0;
+    readonly White: 16777215;
+    readonly Ink: 270365;
+    readonly Baff: 3065014;
+    readonly Green: 3066993;
+    readonly Red: 15158332;
+    readonly Orange: 15105570;
+    readonly Yellow: 15844367;
+    readonly Blue: 3447003;
+    readonly Pink: 15277667;
+    readonly Grey: 9807270;
+    readonly DarkGrey: 5533306;
+};
+export declare const MessageFlags: {
+    readonly Ephemeral: number;
+    readonly IsComponentsV2: number;
+};
+export declare const ComponentType: {
+    readonly ActionRow: 1;
+    readonly Button: 2;
+    readonly StringSelect: 3;
+    readonly TextInput: 4;
+    readonly UserSelect: 5;
+    readonly RoleSelect: 6;
+    readonly MentionableSelect: 7;
+    readonly ChannelSelect: 8;
+    readonly Section: 9;
+    readonly TextDisplay: 10;
+    readonly Thumbnail: 11;
+    readonly MediaGallery: 12;
+    readonly Separator: 14;
+    readonly Container: 17;
+};
+export declare const ButtonStyle: {
+    readonly Primary: 1;
+    readonly Secondary: 2;
+    readonly Success: 3;
+    readonly Danger: 4;
+    readonly Link: 5;
+};
+export declare const TextInputStyle: {
+    readonly Short: 1;
+    readonly Paragraph: 2;
+};
+export declare const SeparatorSpacing: {
+    readonly Small: 1;
+    readonly Large: 2;
+};
+export declare const ChannelType: {
+    readonly Text: "text";
+    readonly Announcement: "announcement";
+    readonly Forum: "forum";
+    readonly Voice: "voice";
+    readonly Stage: "stage";
+    readonly Category: "category";
+    readonly Thread: "thread";
+};
+export declare const ApplicationCommandOptionType: {
+    readonly Subcommand: "subcommand";
+    readonly SubcommandGroup: "subcommand_group";
+    readonly String: "string";
+    readonly Integer: "integer";
+    readonly Number: "number";
+    readonly Boolean: "boolean";
+    readonly User: "user";
+    readonly Channel: "channel";
+    readonly Role: "role";
+};
+export declare const PresenceStatus: {
+    readonly Online: "online";
+    readonly Idle: "idle";
+    readonly DoNotDisturb: "dnd";
+    readonly Invisible: "invisible";
+};
+export declare const DEFAULT_API_URL = "https://baff.gg/api";
+export declare const DEFAULT_GATEWAY_URL = "wss://baff.gg/api/gateway";
+export declare const VERSION = "0.1.0";

package/dist/esm/util/constants.js

@@ -0,0 +1,78 @@
+export const Colors = {
+    Default: 0x000000,
+    White: 0xffffff,
+    Ink: 0x04201d,
+    Baff: 0x2ec4b6,
+    Green: 0x2ecc71,
+    Red: 0xe74c3c,
+    Orange: 0xe67e22,
+    Yellow: 0xf1c40f,
+    Blue: 0x3498db,
+    Pink: 0xe91e63,
+    Grey: 0x95a5a6,
+    DarkGrey: 0x546e7a
+};
+export const MessageFlags = {
+    Ephemeral: 1 << 6,
+    IsComponentsV2: 1 << 15
+};
+export const ComponentType = {
+    ActionRow: 1,
+    Button: 2,
+    StringSelect: 3,
+    TextInput: 4,
+    UserSelect: 5,
+    RoleSelect: 6,
+    MentionableSelect: 7,
+    ChannelSelect: 8,
+    Section: 9,
+    TextDisplay: 10,
+    Thumbnail: 11,
+    MediaGallery: 12,
+    Separator: 14,
+    Container: 17
+};
+export const ButtonStyle = {
+    Primary: 1,
+    Secondary: 2,
+    Success: 3,
+    Danger: 4,
+    Link: 5
+};
+export const TextInputStyle = {
+    Short: 1,
+    Paragraph: 2
+};
+export const SeparatorSpacing = {
+    Small: 1,
+    Large: 2
+};
+export const ChannelType = {
+    Text: 'text',
+    Announcement: 'announcement',
+    Forum: 'forum',
+    Voice: 'voice',
+    Stage: 'stage',
+    Category: 'category',
+    Thread: 'thread'
+};
+export const ApplicationCommandOptionType = {
+    Subcommand: 'subcommand',
+    SubcommandGroup: 'subcommand_group',
+    String: 'string',
+    Integer: 'integer',
+    Number: 'number',
+    Boolean: 'boolean',
+    User: 'user',
+    Channel: 'channel',
+    Role: 'role'
+};
+export const PresenceStatus = {
+    Online: 'online',
+    Idle: 'idle',
+    DoNotDisturb: 'dnd',
+    Invisible: 'invisible'
+};
+export const DEFAULT_API_URL = 'https://baff.gg/api';
+export const DEFAULT_GATEWAY_URL = 'wss://baff.gg/api/gateway';
+export const VERSION = '0.1.0';

package/dist/esm/util/emoji.d.ts

@@ -0,0 +1,8 @@
+export type EmojiResolvable = string | {
+    id: string;
+    name: string;
+    animated?: boolean;
+} | {
+    identifier: string;
+};
+export declare function resolveEmoji(emoji: EmojiResolvable): string;

package/dist/esm/util/emoji.js

@@ -0,0 +1,7 @@
+const CUSTOM = /^<(a?):(\w{2,32}):(\d+)>$/;
+export function resolveEmoji(emoji) {
+    if (typeof emoji === 'object')
+        return 'identifier' in emoji ? emoji.identifier : `${emoji.animated ? 'a:' : ''}${emoji.name}:${emoji.id}`;
+    const match = CUSTOM.exec(emoji.trim());
+    return match ? `${match[1] ? 'a:' : ''}${match[2]}:${match[3]}` : emoji;
+}

package/dist/esm/util/formatters.d.ts

@@ -0,0 +1,29 @@
+export declare const userMention: (id: string) => `<@${string}>`;
+export declare const roleMention: (id: string) => `<@&${string}>`;
+export declare const channelMention: (id: string) => `<#${string}>`;
+export declare const everyoneMention = "@everyone";
+export declare const hereMention = "@here";
+export declare const formatEmoji: (id: string, name: string, animated?: boolean) => string;
+export declare const bold: (text: string) => string;
+export declare const italic: (text: string) => string;
+export declare const underline: (text: string) => string;
+export declare const strikethrough: (text: string) => string;
+export declare const spoiler: (text: string) => string;
+export declare const inlineCode: (text: string) => string;
+export declare const codeBlock: (content: string, language?: string) => string;
+export declare const quote: (text: string) => string;
+export declare const blockQuote: (text: string) => string;
+export declare const heading: (text: string, level?: 1 | 2 | 3) => string;
+export declare const subtext: (text: string) => string;
+export declare const hyperlink: (text: string, url: string) => string;
+export declare const hideLinkEmbed: (url: string) => string;
+export interface EscapeOptions {
+    codeBlock?: boolean;
+    inlineCode?: boolean;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strikethrough?: boolean;
+    spoiler?: boolean;
+}
+export declare function escapeMarkdown(text: string, options?: EscapeOptions): string;

package/dist/esm/util/formatters.js

@@ -0,0 +1,34 @@
+export const userMention = (id) => `<@${id}>`;
+export const roleMention = (id) => `<@&${id}>`;
+export const channelMention = (id) => `<#${id}>`;
+export const everyoneMention = '@everyone';
+export const hereMention = '@here';
+export const formatEmoji = (id, name, animated = false) => `<${animated ? 'a' : ''}:${name}:${id}>`;
+export const bold = (text) => `**${text}**`;
+export const italic = (text) => `*${text}*`;
+export const underline = (text) => `__${text}__`;
+export const strikethrough = (text) => `~~${text}~~`;
+export const spoiler = (text) => `||${text}||`;
+export const inlineCode = (text) => `\`${text}\``;
+export const codeBlock = (content, language = '') => `\`\`\`${language}\n${content}\n\`\`\``;
+export const quote = (text) => `> ${text}`;
+export const blockQuote = (text) => `>>> ${text}`;
+export const heading = (text, level = 1) => `${'#'.repeat(level)} ${text}`;
+export const subtext = (text) => `-# ${text}`;
+export const hyperlink = (text, url) => `[${text}](${url})`;
+export const hideLinkEmbed = (url) => `<${url}>`;
+export function escapeMarkdown(text, options = {}) {
+    const on = (key) => options[key] !== false;
+    let chars = '\\';
+    if (on('italic') || on('bold'))
+        chars += '*';
+    if (on('italic') || on('underline'))
+        chars += '_';
+    if (on('strikethrough'))
+        chars += '~';
+    if (on('inlineCode') || on('codeBlock'))
+        chars += '`';
+    if (on('spoiler'))
+        chars += '|';
+    return text.replace(new RegExp(`[${chars.replace(/[\]\\^-]/g, '\\$&')}]`, 'g'), '\\$&');
+}

package/package.json

@@ -1,6 +1,58 @@
-{
-  "name": "baff.js",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+	"name": "baff.js",
+	"version": "0.1.0",
+	"description": "The library for building bots on baff.gg: gateway client, REST, slash commands, components and embeds, with no runtime dependencies.",
+	"license": "SEE LICENSE IN LICENSE",
+	"type": "module",
+	"main": "./dist/cjs/index.js",
+	"module": "./dist/esm/index.js",
+	"types": "./dist/esm/index.d.ts",
+	"exports": {
+		".": {
+			"import": {
+				"types": "./dist/esm/index.d.ts",
+				"default": "./dist/esm/index.js"
+			},
+			"require": {
+				"types": "./dist/cjs/index.d.ts",
+				"default": "./dist/cjs/index.js"
+			}
+		},
+		"./package.json": "./package.json"
+	},
+	"sideEffects": false,
+	"files": [
+		"dist",
+		"README.md",
+		"LICENSE",
+		"CHANGELOG.md"
+	],
+	"engines": {
+		"node": ">=20"
+	},
+	"homepage": "https://docs.baff.gg",
+	"bugs": {
+		"url": "https://support.baff.gg/requests/new?topic=bug"
+	},
+	"keywords": [
+		"baff.gg",
+		"baff",
+		"bot",
+		"chat",
+		"gateway",
+		"slash-commands",
+		"api"
+	],
+	"scripts": {
+		"build": "node scripts/clean.mjs dist && tsc -p tsconfig.esm.json && tsc -p tsconfig.cjs.json && node scripts/package-markers.mjs",
+		"typecheck": "tsc --noEmit -p tsconfig.json",
+		"test": "node scripts/clean.mjs .build-test && tsc -p tsconfig.test.json && node scripts/run-tests.mjs",
+		"check": "npm run typecheck && npm test",
+		"smoke": "node scripts/smoke.mjs",
+		"prepublishOnly": "npm run build && npm test && npm run smoke"
+	},
+	"devDependencies": {
+		"@types/node": "^22.10.0",
+		"typescript": "^5.7.0"
+	}
+}