baff.js 0.0.0-stage → 0.1.1

package/dist/esm/types.d.ts

@@ -0,0 +1,369 @@
+export type Id = string;
+export interface APIUser {
+    id: Id;
+    username: string;
+    displayName?: string | null;
+    avatarUrl?: string | null;
+    bannerUrl?: string | null;
+    tag?: 'bot' | 'verified_bot' | 'official' | 'system' | 'staff' | null;
+    clanTag?: APIClanTag | null;
+    status?: string;
+    customStatus?: string | null;
+    deleted?: boolean;
+    avatarDecoration?: {
+        id: string;
+        url: string;
+        animated: boolean;
+    } | null;
+}
+export interface APIClanTag {
+    serverId: Id;
+    name: string;
+    badge: string;
+    color: number;
+}
+export interface APIEmbedMedia {
+    url: string;
+    width?: number;
+    height?: number;
+}
+export interface APIEmbed {
+    type?: string;
+    title?: string;
+    description?: string;
+    url?: string;
+    timestamp?: string;
+    color?: number;
+    footer?: {
+        text: string;
+        icon_url?: string;
+    };
+    image?: APIEmbedMedia;
+    thumbnail?: APIEmbedMedia;
+    video?: APIEmbedMedia;
+    provider?: {
+        name?: string;
+        url?: string;
+    };
+    author?: {
+        name: string;
+        url?: string;
+        icon_url?: string;
+    };
+    fields?: {
+        name: string;
+        value: string;
+        inline?: boolean;
+    }[];
+}
+export interface APIComponent {
+    type: number;
+    id?: number;
+    [key: string]: unknown;
+}
+export interface APIAttachment {
+    id: Id;
+    filename: string;
+    contentType: string;
+    size: number;
+    width?: number | null;
+    height?: number | null;
+    url: string;
+}
+export interface APIReaction {
+    emoji: string;
+    count: number;
+    me: boolean;
+}
+export interface APISticker {
+    id: Id;
+    name: string;
+    url?: string;
+    animated: boolean;
+    serverId?: Id;
+    deleted?: boolean;
+    description?: string;
+    emoji?: string | null;
+}
+export interface APIMessage {
+    id: Id;
+    channelId: Id;
+    serverId?: Id | null;
+    author: APIUser;
+    content: string;
+    createdAt: string;
+    editedAt: string | null;
+    type?: number;
+    attachments: APIAttachment[];
+    embeds: APIEmbed[];
+    components: APIComponent[];
+    flags: number;
+    reactions: APIReaction[];
+    mentions: Id[];
+    mentionRoles: Id[];
+    mentionEveryone: boolean;
+    reply?: {
+        id: Id;
+        author: APIUser;
+        content: string;
+        hasAttachments?: boolean;
+        forwarded?: boolean;
+    };
+    replyDeleted?: boolean;
+    pinned?: boolean;
+    crossposted?: boolean;
+    stickers?: APISticker[];
+    poll?: unknown;
+    forward?: unknown;
+    interaction?: {
+        user: APIUser;
+        name: string;
+    };
+    nonce?: string;
+    interactionName?: string;
+}
+export interface APIRole {
+    id: Id;
+    name: string;
+    color: string | null;
+    hoist: boolean;
+    position: number;
+    permissions: number | string;
+    badge?: string | null;
+    icon?: string | null;
+    botId?: Id | null;
+    booster?: boolean;
+}
+export type ChannelKind = 'category' | 'text' | 'announcement' | 'forum' | 'voice' | 'stage' | 'thread' | 'dm' | 'group_dm';
+export interface APIChannel {
+    id: Id;
+    name?: string;
+    kind?: ChannelKind;
+    type?: ChannelKind;
+    serverId?: Id | null;
+    position?: number;
+    parentId?: Id | null;
+    topic?: string | null;
+    slowmodeSecs?: number;
+    contentMode?: 'default' | 'spoiler' | 'age_restricted';
+    autoArchiveMinutes?: number | null;
+    archived?: boolean;
+    threadOwnerId?: Id | null;
+    threadStarterId?: Id | null;
+    threadLocked?: boolean;
+    messageCount?: number;
+    lastMessageId?: Id | null;
+    voiceStatus?: string | null;
+    availableTags?: {
+        id: Id;
+        name: string;
+        emoji: string | null;
+    }[];
+    appliedTags?: Id[];
+    requireTag?: boolean;
+    pinned?: boolean;
+    recipient?: APIUser;
+    recipients?: APIUser[];
+    ownerId?: Id | null;
+    iconUrl?: string | null;
+}
+export interface APIServerSummary {
+    id: Id;
+    name: string;
+    iconUrl: string | null;
+    types?: string[];
+    community?: boolean;
+    listed?: boolean;
+    bannerUrl?: string | null;
+    boostCount?: number;
+    boostTier?: number;
+}
+export interface APIServer extends APIServerSummary {
+    ownerId: Id;
+    channels: APIChannel[];
+    roles: APIRole[];
+    myRoles: Id[];
+    invitesPaused?: boolean;
+    systemChannelId?: Id | null;
+    systemFlags?: number;
+    defaultNotifications?: 'all' | 'mentions';
+    pending?: boolean;
+}
+export interface APIMember {
+    user: APIUser;
+    status?: string;
+    customStatus?: string | null;
+    isOwner?: boolean;
+    roles: Id[];
+    nick: string | null;
+    avatarUrl?: string | null;
+    bannerUrl?: string | null;
+    joinedAt?: string;
+    pending?: boolean;
+    timeoutUntil?: string | null;
+}
+export interface APIEmoji {
+    id: Id;
+    serverId: Id;
+    name: string;
+    animated: boolean;
+    url: string;
+    uploader?: string | null;
+}
+export interface APIInvite {
+    code: string;
+    maxAgeSecs?: number;
+    expiresAt?: string | null;
+    maxUses?: number;
+    uses?: number;
+    temporary?: boolean;
+    inviter?: {
+        id: Id;
+        username: string;
+        displayName?: string;
+    } | null;
+    vanity?: boolean;
+    server?: {
+        id: Id;
+        name: string;
+        iconUrl: string | null;
+        memberCount?: number;
+        onlineCount?: number;
+    };
+}
+export interface APIWebhook {
+    id: Id;
+    userId: Id;
+    name: string;
+    path: string;
+    createdBy?: string | null;
+    createdAt: string;
+}
+export interface APIBan {
+    user: APIUser;
+    reason: string | null;
+    createdAt: string;
+}
+export interface APIServerEvent {
+    id: Id;
+    serverId: Id;
+    creatorId: Id | null;
+    creator?: APIUser;
+    name: string;
+    description: string;
+    locationKind: 'voice' | 'external';
+    channelId: Id | null;
+    location: string | null;
+    startAt: string;
+    endAt: string | null;
+    coverUrl: string | null;
+    status: 'scheduled' | 'active' | 'completed' | 'canceled';
+    createdAt: string;
+    interestedCount: number;
+    interested?: boolean;
+}
+export interface APIAuditEntry {
+    id: Id;
+    action: string;
+    actorId: Id | null;
+    targetType: string;
+    targetId: Id | null;
+    targetName: string | null;
+    reason: string | null;
+    changes: {
+        key: string;
+        old: unknown;
+        new: unknown;
+    }[];
+    extra: Record<string, unknown>;
+    createdAt: string;
+}
+export interface APICommandOption {
+    name: string;
+    description: string;
+    type: string;
+    required?: boolean;
+    options?: APICommandOption[];
+}
+export interface APICommand {
+    id?: Id;
+    applicationId?: Id;
+    serverId?: Id | null;
+    kind?: 'slash' | 'prefix';
+    name: string;
+    description: string;
+    options?: APICommandOption[];
+    prefix?: string | null;
+}
+export interface APIInteractionOption {
+    name: string;
+    type: string;
+    value?: string | number | boolean;
+    options?: APIInteractionOption[];
+}
+export interface APIInteraction {
+    type: 'command' | 'component' | 'modal_submit' | 'ping';
+    id: Id;
+    token: string;
+    applicationId: Id;
+    channelId: Id;
+    serverId: Id | null;
+    user: APIUser & {
+        roles?: Id[];
+        permissions?: string;
+    };
+    appPermissions?: string;
+    message?: APIMessage;
+    data: {
+        id?: Id;
+        name?: string;
+        options?: APIInteractionOption[];
+        customId?: string;
+        componentType?: number;
+        label?: string;
+        values?: string[];
+        resolved?: {
+            users?: Record<string, APIUser>;
+            roles?: Record<string, {
+                id: Id;
+                name: string;
+                color: string | null;
+            }>;
+            channels?: Record<string, {
+                id: Id;
+                name: string;
+                type: number;
+                parentId: Id | null;
+            }>;
+        };
+        fields?: {
+            customId: string;
+            value: string;
+        }[];
+    };
+}
+export interface APIVoiceJoin {
+    url: string;
+    token: string;
+    canSpeak: boolean;
+    canVideo: boolean;
+    deafened: boolean;
+    suppress: boolean;
+    audioBitrate: number;
+    room: string;
+    identity: string;
+    serverId: Id | null;
+    channelId: Id;
+}
+export interface APIVoiceState {
+    userId: Id;
+    serverId: Id | null;
+    channelId: Id | null;
+    muted: boolean;
+    deafened: boolean;
+    selfVideo: boolean;
+    selfStream: boolean;
+    suppress: boolean;
+    requestToSpeakAt: string | null;
+    invitedToSpeak: boolean;
+}

package/dist/esm/types.js

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

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

@@ -0,0 +1,32 @@
+export declare class Collection<K, V> extends Map<K, V> {
+    ensure(key: K, make: (key: K, collection: this) => V): V;
+    hasAll(...keys: K[]): boolean;
+    hasAny(...keys: K[]): boolean;
+    first(): V | undefined;
+    first(amount: number): V[];
+    firstKey(): K | undefined;
+    last(): V | undefined;
+    last(amount: number): V[];
+    lastKey(): K | undefined;
+    at(index: number): V | undefined;
+    random(): V | undefined;
+    find(fn: (value: V, key: K, collection: this) => boolean): V | undefined;
+    findKey(fn: (value: V, key: K, collection: this) => boolean): K | undefined;
+    filter(fn: (value: V, key: K, collection: this) => boolean): Collection<K, V>;
+    partition(fn: (value: V, key: K, collection: this) => boolean): [Collection<K, V>, Collection<K, V>];
+    map<T>(fn: (value: V, key: K, collection: this) => T): T[];
+    mapValues<T>(fn: (value: V, key: K, collection: this) => T): Collection<K, T>;
+    flatMap<T>(fn: (value: V, key: K, collection: this) => T[]): T[];
+    some(fn: (value: V, key: K, collection: this) => boolean): boolean;
+    every(fn: (value: V, key: K, collection: this) => boolean): boolean;
+    reduce<T>(fn: (acc: T, value: V, key: K, collection: this) => T, initial: T): T;
+    each(fn: (value: V, key: K, collection: this) => void): this;
+    tap(fn: (collection: this) => void): this;
+    sweep(fn: (value: V, key: K, collection: this) => boolean): number;
+    sort(compare?: (a: V, b: V, aKey: K, bKey: K) => number): this;
+    toSorted(compare?: (a: V, b: V, aKey: K, bKey: K) => number): Collection<K, V>;
+    clone(): Collection<K, V>;
+    concat(...others: Collection<K, V>[]): Collection<K, V>;
+    toJSON(): V[];
+    private static defaultCompare;
+}

package/dist/esm/util/Collection.js

@@ -0,0 +1,141 @@
+export class Collection extends Map {
+    ensure(key, make) {
+        if (this.has(key))
+            return this.get(key);
+        const value = make(key, this);
+        this.set(key, value);
+        return value;
+    }
+    hasAll(...keys) {
+        return keys.every((key) => this.has(key));
+    }
+    hasAny(...keys) {
+        return keys.some((key) => this.has(key));
+    }
+    first(amount) {
+        if (amount === undefined)
+            return this.values().next().value;
+        return [...this.values()].slice(0, Math.max(0, amount));
+    }
+    firstKey() {
+        return this.keys().next().value;
+    }
+    last(amount) {
+        const values = [...this.values()];
+        if (amount === undefined)
+            return values[values.length - 1];
+        return amount <= 0 ? [] : values.slice(-amount);
+    }
+    lastKey() {
+        const keys = [...this.keys()];
+        return keys[keys.length - 1];
+    }
+    at(index) {
+        return [...this.values()].at(index);
+    }
+    random() {
+        const values = [...this.values()];
+        return values[Math.floor(Math.random() * values.length)];
+    }
+    find(fn) {
+        for (const [key, value] of this)
+            if (fn(value, key, this))
+                return value;
+        return undefined;
+    }
+    findKey(fn) {
+        for (const [key, value] of this)
+            if (fn(value, key, this))
+                return key;
+        return undefined;
+    }
+    filter(fn) {
+        const out = new Collection();
+        for (const [key, value] of this)
+            if (fn(value, key, this))
+                out.set(key, value);
+        return out;
+    }
+    partition(fn) {
+        const yes = new Collection();
+        const no = new Collection();
+        for (const [key, value] of this)
+            (fn(value, key, this) ? yes : no).set(key, value);
+        return [yes, no];
+    }
+    map(fn) {
+        const out = [];
+        for (const [key, value] of this)
+            out.push(fn(value, key, this));
+        return out;
+    }
+    mapValues(fn) {
+        const out = new Collection();
+        for (const [key, value] of this)
+            out.set(key, fn(value, key, this));
+        return out;
+    }
+    flatMap(fn) {
+        return this.map(fn).flat();
+    }
+    some(fn) {
+        for (const [key, value] of this)
+            if (fn(value, key, this))
+                return true;
+        return false;
+    }
+    every(fn) {
+        for (const [key, value] of this)
+            if (!fn(value, key, this))
+                return false;
+        return true;
+    }
+    reduce(fn, initial) {
+        let acc = initial;
+        for (const [key, value] of this)
+            acc = fn(acc, value, key, this);
+        return acc;
+    }
+    each(fn) {
+        for (const [key, value] of this)
+            fn(value, key, this);
+        return this;
+    }
+    tap(fn) {
+        fn(this);
+        return this;
+    }
+    sweep(fn) {
+        const before = this.size;
+        for (const [key, value] of [...this])
+            if (fn(value, key, this))
+                this.delete(key);
+        return before - this.size;
+    }
+    sort(compare = Collection.defaultCompare) {
+        const sorted = [...this].sort((a, b) => compare(a[1], b[1], a[0], b[0]));
+        this.clear();
+        for (const [key, value] of sorted)
+            this.set(key, value);
+        return this;
+    }
+    toSorted(compare = Collection.defaultCompare) {
+        return this.clone().sort(compare);
+    }
+    clone() {
+        return new Collection(this);
+    }
+    concat(...others) {
+        const out = this.clone();
+        for (const other of others)
+            for (const [key, value] of other)
+                out.set(key, value);
+        return out;
+    }
+    toJSON() {
+        return [...this.values()];
+    }
+    static defaultCompare(a, b) {
+        return a < b ? -1 : a > b ? 1 : 0;
+    }
+}

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

@@ -0,0 +1,87 @@
+export declare const PermissionFlagsBits: {
+    readonly Administrator: bigint;
+    readonly ManageServer: bigint;
+    readonly ManageRoles: bigint;
+    readonly ManageChannels: bigint;
+    readonly KickMembers: bigint;
+    readonly BanMembers: bigint;
+    readonly CreateInvite: bigint;
+    readonly SendMessages: bigint;
+    readonly ManageMessages: bigint;
+    readonly AttachFiles: bigint;
+    readonly AddReactions: bigint;
+    readonly ManageExpressions: bigint;
+    readonly MentionEveryone: bigint;
+    readonly ViewChannel: bigint;
+    readonly ManageWebhooks: bigint;
+    readonly Connect: bigint;
+    readonly Speak: bigint;
+    readonly Video: bigint;
+    readonly BaffleUpload: bigint;
+    readonly BaffleWithdraw: bigint;
+    readonly ManageBaffles: bigint;
+    readonly ModerateMembers: bigint;
+    readonly ViewAuditLog: bigint;
+    readonly UseSoundboard: bigint;
+    readonly ManageThreads: bigint;
+    readonly ManageStage: bigint;
+    readonly ChangeNickname: bigint;
+    readonly ManageNicknames: bigint;
+    readonly ManageEvents: bigint;
+    readonly SetVoiceChannelStatus: bigint;
+    readonly RequestToSpeak: bigint;
+};
+export type PermissionString = keyof typeof PermissionFlagsBits;
+export type PermissionResolvable = PermissionString | `${bigint}` | bigint | number | PermissionsBitField | readonly PermissionResolvable[];
+export declare class PermissionsBitField {
+    static readonly Flags: {
+        readonly Administrator: bigint;
+        readonly ManageServer: bigint;
+        readonly ManageRoles: bigint;
+        readonly ManageChannels: bigint;
+        readonly KickMembers: bigint;
+        readonly BanMembers: bigint;
+        readonly CreateInvite: bigint;
+        readonly SendMessages: bigint;
+        readonly ManageMessages: bigint;
+        readonly AttachFiles: bigint;
+        readonly AddReactions: bigint;
+        readonly ManageExpressions: bigint;
+        readonly MentionEveryone: bigint;
+        readonly ViewChannel: bigint;
+        readonly ManageWebhooks: bigint;
+        readonly Connect: bigint;
+        readonly Speak: bigint;
+        readonly Video: bigint;
+        readonly BaffleUpload: bigint;
+        readonly BaffleWithdraw: bigint;
+        readonly ManageBaffles: bigint;
+        readonly ModerateMembers: bigint;
+        readonly ViewAuditLog: bigint;
+        readonly UseSoundboard: bigint;
+        readonly ManageThreads: bigint;
+        readonly ManageStage: bigint;
+        readonly ChangeNickname: bigint;
+        readonly ManageNicknames: bigint;
+        readonly ManageEvents: bigint;
+        readonly SetVoiceChannelStatus: bigint;
+        readonly RequestToSpeak: bigint;
+    };
+    static readonly All: PermissionsBitField;
+    readonly bitfield: bigint;
+    constructor(bits?: PermissionResolvable);
+    static fromBits(bits: string | number | bigint): PermissionsBitField;
+    static resolve(bits: PermissionResolvable): bigint;
+    has(permission: PermissionResolvable, checkAdmin?: boolean): boolean;
+    any(permission: PermissionResolvable, checkAdmin?: boolean): boolean;
+    missing(permission: PermissionResolvable, checkAdmin?: boolean): PermissionString[];
+    add(...permissions: PermissionResolvable[]): PermissionsBitField;
+    remove(...permissions: PermissionResolvable[]): PermissionsBitField;
+    equals(other: PermissionResolvable): boolean;
+    toArray(): PermissionString[];
+    serialize(checkAdmin?: boolean): Record<PermissionString, boolean>;
+    toJSON(): string;
+    toString(): string;
+    valueOf(): bigint;
+    private static names;
+}