baff.js 0.0.0-stage → 0.1.0

package/dist/esm/structures/ScheduledEvent.js

@@ -0,0 +1,68 @@
+import { Routes } from '../rest/Routes.js';
+import { Identified } from './Base.js';
+export function eventBody(data) {
+    const iso = (value) => (value instanceof Date ? value.toISOString() : value);
+    return { ...data, startAt: iso(data.startAt), endAt: iso(data.endAt) };
+}
+export class ScheduledEvent extends Identified {
+    id;
+    serverId;
+    creatorId = null;
+    name = '';
+    description = '';
+    locationKind = 'voice';
+    channelId = null;
+    location = null;
+    startAt = new Date(0);
+    endAt = null;
+    coverUrl = null;
+    status = 'scheduled';
+    interestedCount = 0;
+    constructor(client, data) {
+        super(client);
+        this.id = data.id;
+        this.serverId = data.serverId;
+        this._patch(data);
+    }
+    _patch(data) {
+        if (data.creatorId !== undefined)
+            this.creatorId = data.creatorId;
+        if (data.name !== undefined)
+            this.name = data.name;
+        if (data.description !== undefined)
+            this.description = data.description;
+        if (data.locationKind !== undefined)
+            this.locationKind = data.locationKind;
+        if (data.channelId !== undefined)
+            this.channelId = data.channelId;
+        if (data.location !== undefined)
+            this.location = data.location;
+        if (data.startAt !== undefined)
+            this.startAt = new Date(data.startAt);
+        if (data.endAt !== undefined)
+            this.endAt = data.endAt ? new Date(data.endAt) : null;
+        if (data.coverUrl !== undefined)
+            this.coverUrl = data.coverUrl;
+        if (data.status !== undefined)
+            this.status = data.status;
+        if (data.interestedCount !== undefined)
+            this.interestedCount = data.interestedCount;
+        return this;
+    }
+    async edit(data) {
+        const updated = await this.client.rest.patch(Routes.serverEvent(this.serverId, this.id), { body: eventBody(data) });
+        return this._patch(updated);
+    }
+    start() {
+        return this.edit({ status: 'active' });
+    }
+    end() {
+        return this.edit({ status: 'completed' });
+    }
+    cancel() {
+        return this.edit({ status: 'canceled' });
+    }
+    async delete() {
+        await this.client.rest.delete(Routes.serverEvent(this.serverId, this.id));
+    }
+}

package/dist/esm/structures/Server.d.ts

@@ -0,0 +1,68 @@
+import type { Client } from '../client/Client.js';
+import { ApplicationCommandManager } from '../managers/CommandManager.js';
+import { EventManager } from '../managers/EventManager.js';
+import { EmojiManager, StickerManager } from '../managers/ExpressionManagers.js';
+import { InviteManager } from '../managers/InviteManager.js';
+import { MemberManager } from '../managers/MemberManager.js';
+import { RoleManager } from '../managers/RoleManager.js';
+import { ServerChannelManager } from '../managers/ServerChannelManager.js';
+import type { APIAuditEntry, APIServer, APIServerSummary, APIVoiceState } from '../types.js';
+import { Collection } from '../util/Collection.js';
+import { Identified } from './Base.js';
+import type { ServerMember } from './ServerMember.js';
+import type { User } from './User.js';
+export interface ServerEditData {
+    name?: string;
+    systemChannelId?: string | null;
+    systemFlags?: number;
+    defaultNotifications?: 'all' | 'mentions';
+}
+export interface AuditLogEntry extends Omit<APIAuditEntry, 'actorId' | 'createdAt'> {
+    actorId: string | null;
+    actor: User | null;
+    createdAt: Date;
+}
+export interface AuditLogQuery {
+    limit?: number;
+    before?: string;
+    userId?: string;
+    action?: string;
+}
+export declare class Server extends Identified {
+    readonly id: string;
+    name: string;
+    iconUrl: string | null;
+    bannerUrl: string | null;
+    ownerId: string;
+    types: string[];
+    community: boolean;
+    listed: boolean;
+    invitesPaused: boolean;
+    systemChannelId: string | null;
+    boostCount: number;
+    boostTier: number;
+    myRoleIds: string[];
+    detailed: boolean;
+    readonly channels: ServerChannelManager;
+    readonly roles: RoleManager;
+    readonly members: MemberManager;
+    readonly emojis: EmojiManager;
+    readonly stickers: StickerManager;
+    readonly invites: InviteManager;
+    readonly events: EventManager;
+    readonly commands: ApplicationCommandManager;
+    readonly voiceStates: Collection<string, APIVoiceState>;
+    constructor(client: Client, data: APIServerSummary | APIServer);
+    _patch(data: Partial<APIServer>): this;
+    _applyDetail(data: APIServer): void;
+    get me(): ServerMember | null;
+    get url(): string;
+    get systemChannel(): import("./channels/ServerChannels.js").ServerChannel | null;
+    fetch(): Promise<Server>;
+    edit(data: ServerEditData): Promise<Server>;
+    setName(name: string): Promise<Server>;
+    leave(): Promise<void>;
+    fetchAuditLog(query?: AuditLogQuery): Promise<Collection<string, AuditLogEntry>>;
+    fetchVoiceStates(): Promise<Collection<string, APIVoiceState>>;
+    toString(): string;
+}

package/dist/esm/structures/Server.js

@@ -0,0 +1,120 @@
+import { ApplicationCommandManager } from '../managers/CommandManager.js';
+import { EventManager } from '../managers/EventManager.js';
+import { EmojiManager, StickerManager } from '../managers/ExpressionManagers.js';
+import { InviteManager } from '../managers/InviteManager.js';
+import { MemberManager } from '../managers/MemberManager.js';
+import { RoleManager } from '../managers/RoleManager.js';
+import { ServerChannelManager } from '../managers/ServerChannelManager.js';
+import { Routes } from '../rest/Routes.js';
+import { Collection } from '../util/Collection.js';
+import { Identified } from './Base.js';
+export class Server extends Identified {
+    id;
+    name;
+    iconUrl = null;
+    bannerUrl = null;
+    ownerId = '';
+    types = [];
+    community = false;
+    listed = false;
+    invitesPaused = false;
+    systemChannelId = null;
+    boostCount = 0;
+    boostTier = 0;
+    myRoleIds = [];
+    detailed = false;
+    channels;
+    roles;
+    members;
+    emojis;
+    stickers;
+    invites;
+    events;
+    commands;
+    voiceStates = new Collection();
+    constructor(client, data) {
+        super(client);
+        this.id = data.id;
+        this.name = data.name;
+        this.channels = new ServerChannelManager(client, data.id);
+        this.roles = new RoleManager(client, data.id);
+        this.members = new MemberManager(client, data.id);
+        this.emojis = new EmojiManager(client, data.id);
+        this.stickers = new StickerManager(client, data.id);
+        this.invites = new InviteManager(client, data.id);
+        this.events = new EventManager(client, data.id);
+        this.commands = new ApplicationCommandManager(client, () => client.requireApplicationId(), data.id);
+        this._patch(data);
+    }
+    _patch(data) {
+        if (data.name !== undefined)
+            this.name = data.name;
+        if (data.iconUrl !== undefined)
+            this.iconUrl = data.iconUrl;
+        if (data.bannerUrl !== undefined)
+            this.bannerUrl = data.bannerUrl;
+        if (data.ownerId !== undefined)
+            this.ownerId = data.ownerId;
+        if (data.types !== undefined)
+            this.types = data.types;
+        if (data.community !== undefined)
+            this.community = data.community;
+        if (data.listed !== undefined)
+            this.listed = data.listed;
+        if (data.invitesPaused !== undefined)
+            this.invitesPaused = data.invitesPaused;
+        if (data.systemChannelId !== undefined)
+            this.systemChannelId = data.systemChannelId;
+        if (data.boostCount !== undefined)
+            this.boostCount = data.boostCount;
+        if (data.boostTier !== undefined)
+            this.boostTier = data.boostTier;
+        if (data.myRoles !== undefined)
+            this.myRoleIds = data.myRoles;
+        return this;
+    }
+    _applyDetail(data) {
+        this.detailed = true;
+        this.roles._setAll(data.roles);
+        this.client.channels._replaceServer(this.id, data.channels);
+    }
+    get me() {
+        return this.members.me;
+    }
+    get url() {
+        return `${this.client.appUrl}/channels/${this.id}`;
+    }
+    get systemChannel() {
+        return this.systemChannelId ? (this.channels.cache.get(this.systemChannelId) ?? null) : null;
+    }
+    fetch() {
+        return this.client.servers.fetch(this.id, { force: true });
+    }
+    async edit(data) {
+        await this.client.rest.patch(Routes.serverSettings(this.id), { body: data });
+        return this._patch(data);
+    }
+    setName(name) {
+        return this.edit({ name });
+    }
+    leave() {
+        return this.client.servers.leave(this.id);
+    }
+    async fetchAuditLog(query = {}) {
+        const res = await this.client.rest.get(Routes.auditLog(this.id), { query: { ...query } });
+        for (const u of res.users)
+            this.client.users._add(u);
+        return new Collection(res.entries.map((e) => [e.id, { ...e, actor: e.actorId ? (this.client.users.cache.get(e.actorId) ?? null) : null, createdAt: new Date(e.createdAt) }]));
+    }
+    async fetchVoiceStates() {
+        const list = await this.client.rest.get(Routes.voiceStates(this.id));
+        this.voiceStates.clear();
+        for (const state of list)
+            if (state.channelId)
+                this.voiceStates.set(state.userId, state);
+        return this.voiceStates;
+    }
+    toString() {
+        return this.name;
+    }
+}

package/dist/esm/structures/ServerAssets.d.ts

@@ -0,0 +1,48 @@
+import type { Client } from '../client/Client.js';
+import type { APIEmoji, APIInvite, APISticker } from '../types.js';
+import { Base, Identified } from './Base.js';
+export declare class Emoji extends Identified {
+    readonly id: string;
+    readonly serverId: string;
+    name: string;
+    animated: boolean;
+    url: string;
+    uploader: string | null;
+    constructor(client: Client, data: APIEmoji);
+    get identifier(): string;
+    setName(name: string): Promise<Emoji>;
+    delete(): Promise<void>;
+    toString(): string;
+}
+export declare class Sticker extends Identified {
+    readonly id: string;
+    readonly serverId: string | null;
+    name: string;
+    description: string;
+    emoji: string | null;
+    animated: boolean;
+    url: string | null;
+    constructor(client: Client, data: APISticker, serverId?: string);
+    edit(data: {
+        name?: string;
+        description?: string;
+        emoji?: string;
+    }): Promise<Sticker>;
+    delete(): Promise<void>;
+}
+export declare class Invite extends Base {
+    readonly serverId: string | null;
+    readonly code: string;
+    maxAgeSecs: number | null;
+    maxUses: number | null;
+    uses: number;
+    temporary: boolean;
+    expiresAt: Date | null;
+    inviterId: string | null;
+    vanity: boolean;
+    server: APIInvite['server'];
+    constructor(client: Client, data: APIInvite, serverId?: string | null);
+    get url(): string;
+    delete(): Promise<void>;
+    toString(): string;
+}

package/dist/esm/structures/ServerAssets.js

@@ -0,0 +1,98 @@
+import { BaffError } from '../errors/BaffError.js';
+import { Routes } from '../rest/Routes.js';
+import { formatEmoji } from '../util/formatters.js';
+import { Base, Identified } from './Base.js';
+export class Emoji extends Identified {
+    id;
+    serverId;
+    name;
+    animated;
+    url;
+    uploader;
+    constructor(client, data) {
+        super(client);
+        this.id = data.id;
+        this.serverId = data.serverId;
+        this.name = data.name;
+        this.animated = data.animated;
+        this.url = data.url;
+        this.uploader = data.uploader ?? null;
+    }
+    get identifier() {
+        return `${this.animated ? 'a:' : ''}${this.name}:${this.id}`;
+    }
+    async setName(name) {
+        const data = await this.client.rest.patch(Routes.serverEmoji(this.serverId, this.id), { body: { name } });
+        this.name = data.name;
+        return this;
+    }
+    delete() {
+        return this.client.rest.delete(Routes.serverEmoji(this.serverId, this.id));
+    }
+    toString() {
+        return formatEmoji(this.id, this.name, this.animated);
+    }
+}
+export class Sticker extends Identified {
+    id;
+    serverId;
+    name;
+    description;
+    emoji;
+    animated;
+    url;
+    constructor(client, data, serverId) {
+        super(client);
+        this.id = data.id;
+        this.serverId = data.serverId ?? serverId ?? null;
+        this.name = data.name;
+        this.description = data.description ?? '';
+        this.emoji = data.emoji ?? null;
+        this.animated = data.animated;
+        this.url = data.url ?? null;
+    }
+    async edit(data) {
+        const updated = await this.client.rest.patch(Routes.serverSticker(this.serverId, this.id), { body: data });
+        Object.assign(this, { name: updated.name, description: updated.description ?? this.description, emoji: updated.emoji ?? null });
+        return this;
+    }
+    delete() {
+        return this.client.rest.delete(Routes.serverSticker(this.serverId, this.id));
+    }
+}
+export class Invite extends Base {
+    serverId;
+    code;
+    maxAgeSecs;
+    maxUses;
+    uses;
+    temporary;
+    expiresAt;
+    inviterId;
+    vanity;
+    server;
+    constructor(client, data, serverId = data.server?.id ?? null) {
+        super(client);
+        this.serverId = serverId;
+        this.code = data.code;
+        this.maxAgeSecs = data.maxAgeSecs ?? null;
+        this.maxUses = data.maxUses ?? null;
+        this.uses = data.uses ?? 0;
+        this.temporary = data.temporary ?? false;
+        this.expiresAt = data.expiresAt ? new Date(data.expiresAt) : null;
+        this.inviterId = data.inviter?.id ?? null;
+        this.vanity = data.vanity ?? false;
+        this.server = data.server;
+    }
+    get url() {
+        return `${this.client.appUrl}/invite/${this.code}`;
+    }
+    async delete() {
+        if (!this.serverId)
+            throw new BaffError('INVITE_HAS_NO_SERVER', 'This invite has no server to delete it from.');
+        await this.client.rest.delete(Routes.serverInvite(this.serverId, this.code));
+    }
+    toString() {
+        return this.url;
+    }
+}

package/dist/esm/structures/ServerMember.d.ts

@@ -0,0 +1,47 @@
+import type { Client } from '../client/Client.js';
+import type { MessageOptions } from '../builders/messagePayload.js';
+import type { APIMember } from '../types.js';
+import { Collection } from '../util/Collection.js';
+import { PermissionsBitField } from '../util/Permissions.js';
+import { Base } from './Base.js';
+import type { Message } from './Message.js';
+import type { Role } from './Role.js';
+import type { Server } from './Server.js';
+import type { User } from './User.js';
+export declare class MemberRoleManager {
+    private readonly member;
+    constructor(member: ServerMember);
+    get cache(): Collection<string, Role>;
+    get highest(): Role | undefined;
+    add(role: string | Role): Promise<ServerMember>;
+    remove(role: string | Role): Promise<ServerMember>;
+}
+export declare class ServerMember extends Base {
+    readonly serverId: string;
+    readonly user: User;
+    roleIds: string[];
+    nick: string | null;
+    avatarUrl: string | null;
+    bannerUrl: string | null;
+    joinedAt: Date | null;
+    pending: boolean;
+    timeoutUntil: Date | null;
+    readonly roles: MemberRoleManager;
+    constructor(client: Client, serverId: string, user: User, data: Partial<APIMember>);
+    _clone(): this;
+    _patch(data: Partial<APIMember>): this;
+    get id(): string;
+    get server(): Server | null;
+    get displayName(): string;
+    get isOwner(): boolean;
+    get timedOut(): boolean;
+    get permissions(): PermissionsBitField;
+    kick(reason?: string): Promise<void>;
+    ban(options?: {
+        reason?: string;
+    }): Promise<void>;
+    timeout(durationMs: number | null, reason?: string): Promise<ServerMember>;
+    setNickname(nick: string | null): Promise<ServerMember>;
+    send(options: string | MessageOptions): Promise<Message>;
+    toString(): string;
+}

package/dist/esm/structures/ServerMember.js

@@ -0,0 +1,133 @@
+import { Routes } from '../rest/Routes.js';
+import { Collection } from '../util/Collection.js';
+import { PermissionFlagsBits, PermissionsBitField } from '../util/Permissions.js';
+import { userMention } from '../util/formatters.js';
+import { Base } from './Base.js';
+export class MemberRoleManager {
+    member;
+    constructor(member) {
+        this.member = member;
+    }
+    get cache() {
+        const roles = this.member.server?.roles.cache;
+        const out = new Collection();
+        if (!roles)
+            return out;
+        for (const id of [this.member.server.id, ...this.member.roleIds]) {
+            const role = roles.get(id);
+            if (role)
+                out.set(id, role);
+        }
+        return out;
+    }
+    get highest() {
+        return this.cache.sort((a, b) => b.position - a.position).first();
+    }
+    async add(role) {
+        const id = typeof role === 'string' ? role : role.id;
+        await this.member.client.rest.put(Routes.memberRole(this.member.serverId, this.member.id, id));
+        if (!this.member.roleIds.includes(id))
+            this.member.roleIds.push(id);
+        return this.member;
+    }
+    async remove(role) {
+        const id = typeof role === 'string' ? role : role.id;
+        await this.member.client.rest.delete(Routes.memberRole(this.member.serverId, this.member.id, id));
+        this.member.roleIds = this.member.roleIds.filter((r) => r !== id);
+        return this.member;
+    }
+}
+export class ServerMember extends Base {
+    serverId;
+    user;
+    roleIds = [];
+    nick = null;
+    avatarUrl = null;
+    bannerUrl = null;
+    joinedAt = null;
+    pending = false;
+    timeoutUntil = null;
+    roles = new MemberRoleManager(this);
+    constructor(client, serverId, user, data) {
+        super(client);
+        this.serverId = serverId;
+        this.user = user;
+        this._patch(data);
+    }
+    _clone() {
+        const copy = super._clone();
+        copy.roles = new MemberRoleManager(copy);
+        copy.roleIds = [...this.roleIds];
+        return copy;
+    }
+    _patch(data) {
+        if (data.roles !== undefined)
+            this.roleIds = [...data.roles];
+        if (data.nick !== undefined)
+            this.nick = data.nick;
+        if (data.avatarUrl !== undefined)
+            this.avatarUrl = data.avatarUrl ?? null;
+        if (data.bannerUrl !== undefined)
+            this.bannerUrl = data.bannerUrl ?? null;
+        if (data.joinedAt !== undefined)
+            this.joinedAt = new Date(data.joinedAt);
+        if (data.pending !== undefined)
+            this.pending = data.pending;
+        if (data.timeoutUntil !== undefined)
+            this.timeoutUntil = data.timeoutUntil ? new Date(data.timeoutUntil) : null;
+        return this;
+    }
+    get id() {
+        return this.user.id;
+    }
+    get server() {
+        return this.client.servers.cache.get(this.serverId) ?? null;
+    }
+    get displayName() {
+        return this.nick ?? this.user.displayName;
+    }
+    get isOwner() {
+        return this.server?.ownerId === this.id;
+    }
+    get timedOut() {
+        return this.timeoutUntil !== null && this.timeoutUntil.getTime() > Date.now();
+    }
+    get permissions() {
+        if (this.isOwner)
+            return PermissionsBitField.All;
+        const bits = this.roles.cache.reduce((acc, role) => acc | role.permissions.bitfield, 0n);
+        const all = new PermissionsBitField(bits);
+        if (all.has(PermissionFlagsBits.Administrator, false))
+            return PermissionsBitField.All;
+        return this.timedOut ? new PermissionsBitField(PermissionFlagsBits.ViewChannel) : all;
+    }
+    kick(reason) {
+        return this.client.rest.delete(Routes.serverMember(this.serverId, this.id), { body: reason ? { reason } : undefined });
+    }
+    ban(options = {}) {
+        return this.client.rest.put(Routes.serverBan(this.serverId, this.id), { body: options });
+    }
+    async timeout(durationMs, reason) {
+        if (durationMs === null) {
+            await this.client.rest.delete(Routes.memberTimeout(this.serverId, this.id));
+            this.timeoutUntil = null;
+            return this;
+        }
+        const res = await this.client.rest.put(Routes.memberTimeout(this.serverId, this.id), {
+            body: { durationSecs: Math.round(durationMs / 1000), reason }
+        });
+        this.timeoutUntil = new Date(res.timeoutUntil);
+        return this;
+    }
+    async setNickname(nick) {
+        await this.client.rest.patch(Routes.serverMember(this.serverId, this.id), { body: { nick } });
+        this.nick = nick || null;
+        return this;
+    }
+    send(options) {
+        return this.user.send(options);
+    }
+    toString() {
+        return userMention(this.id);
+    }
+}

package/dist/esm/structures/User.d.ts

@@ -0,0 +1,35 @@
+import type { Client } from '../client/Client.js';
+import type { MessageOptions } from '../builders/messagePayload.js';
+import type { APIUser } from '../types.js';
+import { Identified } from './Base.js';
+import type { DMChannel } from './channels/DMChannel.js';
+import type { Message } from './Message.js';
+export declare class User extends Identified {
+    readonly id: string;
+    username: string;
+    displayName: string;
+    avatarUrl: string | null;
+    bannerUrl: string | null;
+    tag: APIUser['tag'];
+    clanTag: APIUser['clanTag'];
+    status: string | null;
+    customStatus: string | null;
+    deleted: boolean;
+    constructor(client: Client, data: APIUser);
+    _patch(data: Partial<APIUser>): this;
+    get bot(): boolean;
+    get system(): boolean;
+    createDM(): Promise<DMChannel>;
+    send(options: string | MessageOptions): Promise<Message>;
+    fetchProfile(serverId?: string): Promise<Record<string, unknown>>;
+    toString(): string;
+}
+export declare class ClientUser extends User {
+    get bot(): boolean;
+    setPresence(presence: {
+        status?: 'online' | 'idle' | 'dnd' | 'invisible';
+        customStatus?: string | null;
+    }): Promise<void>;
+    setStatus(status: 'online' | 'idle' | 'dnd' | 'invisible'): Promise<void>;
+    setCustomStatus(customStatus: string | null): Promise<void>;
+}