baff.js 0.0.0-stage → 0.1.0

package/dist/cjs/client/Client.d.ts

@@ -0,0 +1,63 @@
+import { type WebSocketConstructor } from '../gateway/Gateway.js';
+import { ApplicationCommandManager } from '../managers/CommandManager.js';
+import { ChannelManager } from '../managers/ChannelManager.js';
+import { ServerManager } from '../managers/ServerManager.js';
+import { UserManager } from '../managers/UserManager.js';
+import { VoiceManager } from '../managers/VoiceManager.js';
+import { REST, type RESTOptions } from '../rest/REST.js';
+import { Invite } from '../structures/ServerAssets.js';
+import { ClientUser } from '../structures/User.js';
+import { type PermissionResolvable } from '../util/Permissions.js';
+import { TypedEmitter } from '../util/TypedEmitter.js';
+import type { ClientEvents } from './events.js';
+export interface ClientOptions {
+    token?: string;
+    applicationId?: string;
+    api?: string;
+    gateway?: string;
+    appUrl?: string;
+    WebSocket?: WebSocketConstructor;
+    fetch?: typeof fetch;
+    rest?: Omit<RESTOptions, 'token' | 'api' | 'fetch'>;
+    reconnect?: boolean;
+    initialBackoff?: number;
+    maxBackoff?: number;
+    messageCacheLimit?: number;
+    fetchServersOnReady?: boolean;
+    fetchMembersOnReady?: boolean;
+}
+export declare class ClientApplication {
+    readonly id: string;
+    readonly commands: ApplicationCommandManager;
+    constructor(client: Client, id: string);
+}
+export declare class Client extends TypedEmitter<ClientEvents> {
+    readonly options: Required<Omit<ClientOptions, 'token' | 'applicationId' | 'WebSocket' | 'fetch' | 'rest' | 'appUrl'>> & Pick<ClientOptions, 'WebSocket'>;
+    readonly rest: REST;
+    readonly appUrl: string;
+    readonly users: UserManager;
+    readonly servers: ServerManager;
+    readonly channels: ChannelManager;
+    readonly voice: VoiceManager;
+    user: ClientUser | null;
+    application: ClientApplication | null;
+    readyAt: Date | null;
+    private gateway;
+    constructor(options?: ClientOptions);
+    get token(): string | null;
+    get applicationId(): string | null;
+    get uptime(): number | null;
+    isReady(): boolean;
+    setApplicationId(id: string): void;
+    requireApplication(): ClientApplication;
+    requireApplicationId(): string;
+    fetchSelf(): Promise<ClientUser>;
+    login(token?: string): Promise<string>;
+    destroy(): Promise<void>;
+    generateInvite(options?: {
+        permissions?: PermissionResolvable;
+        applicationId?: string;
+    }): string;
+    fetchInvite(code: string): Promise<Invite>;
+    private sync;
+}

package/dist/cjs/client/Client.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = exports.ClientApplication = void 0;
+const BaffError_js_1 = require("../errors/BaffError.js");
+const Gateway_js_1 = require("../gateway/Gateway.js");
+const CommandManager_js_1 = require("../managers/CommandManager.js");
+const ChannelManager_js_1 = require("../managers/ChannelManager.js");
+const ServerManager_js_1 = require("../managers/ServerManager.js");
+const UserManager_js_1 = require("../managers/UserManager.js");
+const VoiceManager_js_1 = require("../managers/VoiceManager.js");
+const REST_js_1 = require("../rest/REST.js");
+const Routes_js_1 = require("../rest/Routes.js");
+const ServerAssets_js_1 = require("../structures/ServerAssets.js");
+const User_js_1 = require("../structures/User.js");
+const constants_js_1 = require("../util/constants.js");
+const Permissions_js_1 = require("../util/Permissions.js");
+const TypedEmitter_js_1 = require("../util/TypedEmitter.js");
+const dispatch_js_1 = require("./dispatch.js");
+class ClientApplication {
+    id;
+    commands;
+    constructor(client, id) {
+        this.id = id;
+        this.commands = new CommandManager_js_1.ApplicationCommandManager(client, () => id);
+    }
+}
+exports.ClientApplication = ClientApplication;
+class Client extends TypedEmitter_js_1.TypedEmitter {
+    options;
+    rest;
+    appUrl;
+    users = new UserManager_js_1.UserManager(this);
+    servers = new ServerManager_js_1.ServerManager(this);
+    channels = new ChannelManager_js_1.ChannelManager(this);
+    voice = new VoiceManager_js_1.VoiceManager(this);
+    user = null;
+    application = null;
+    readyAt = null;
+    gateway = null;
+    constructor(options = {}) {
+        super({ captureRejections: true });
+        const api = (options.api ?? constants_js_1.DEFAULT_API_URL).replace(/\/+$/, '');
+        this.options = {
+            api,
+            gateway: options.gateway ?? constants_js_1.DEFAULT_GATEWAY_URL,
+            WebSocket: options.WebSocket,
+            reconnect: options.reconnect ?? true,
+            initialBackoff: options.initialBackoff ?? 1000,
+            maxBackoff: options.maxBackoff ?? 30_000,
+            messageCacheLimit: options.messageCacheLimit ?? 200,
+            fetchServersOnReady: options.fetchServersOnReady ?? true,
+            fetchMembersOnReady: options.fetchMembersOnReady ?? false
+        };
+        this.appUrl = (options.appUrl ?? api.replace(/\/api$/, '')).replace(/\/+$/, '');
+        this.rest = new REST_js_1.REST({ ...options.rest, api, token: options.token, fetch: options.fetch });
+        this.rest.on('rateLimited', (info) => this.emit('debug', `Rate limited on ${info.method} ${info.path}; waiting ${info.retryAfter}s.`));
+        if (options.applicationId)
+            this.setApplicationId(options.applicationId);
+    }
+    get token() {
+        return this.rest.token;
+    }
+    get applicationId() {
+        return this.application?.id ?? null;
+    }
+    get uptime() {
+        return this.readyAt ? Date.now() - this.readyAt.getTime() : null;
+    }
+    isReady() {
+        return this.readyAt !== null;
+    }
+    setApplicationId(id) {
+        if (this.application?.id !== id)
+            this.application = new ClientApplication(this, id);
+    }
+    requireApplication() {
+        if (!this.application) {
+            throw new BaffError_js_1.BaffError('NO_APPLICATION_ID', 'The application id is unknown. Pass applicationId to Client: baff.gg does not tell bots their application id.');
+        }
+        return this.application;
+    }
+    requireApplicationId() {
+        return this.requireApplication().id;
+    }
+    async fetchSelf() {
+        const data = await this.rest.get(Routes_js_1.Routes.me());
+        if (this.user)
+            this.user._patch(data);
+        else
+            this.user = new User_js_1.ClientUser(this, data);
+        this.users.cache.set(this.user.id, this.user);
+        return this.user;
+    }
+    async login(token) {
+        if (token)
+            this.rest.setToken(token);
+        if (!this.rest.token)
+            throw new BaffError_js_1.BaffError('NO_TOKEN', 'No token provided. Pass it to Client or login().');
+        await this.fetchSelf();
+        const gateway = new Gateway_js_1.Gateway({
+            token: this.rest.token,
+            url: this.options.gateway,
+            WebSocket: this.options.WebSocket,
+            reconnect: this.options.reconnect,
+            initialBackoff: this.options.initialBackoff,
+            maxBackoff: this.options.maxBackoff
+        });
+        this.gateway = gateway;
+        gateway.on('dispatch', (event, data) => (0, dispatch_js_1.dispatch)(this, event, data));
+        gateway.on('debug', (message) => this.emit('debug', message));
+        gateway.on('disconnect', (code, reason) => this.emit('disconnect', code, reason));
+        gateway.on('reconnecting', (attempt, delay) => this.emit('reconnecting', attempt, delay));
+        gateway.on('reconnected', () => {
+            this.sync().then(() => this.emit('reconnected', this), (error) => this.emit('debug', `Resync after reconnect failed: ${error.message}`));
+        });
+        try {
+            await gateway.connect();
+            await this.sync();
+        }
+        catch (error) {
+            gateway.destroy();
+            this.gateway = null;
+            throw error;
+        }
+        this.readyAt = new Date();
+        this.emit('ready', this);
+        return this.rest.token;
+    }
+    async destroy() {
+        this.gateway?.destroy();
+        this.gateway = null;
+        this.readyAt = null;
+    }
+    generateInvite(options = {}) {
+        const id = options.applicationId ?? this.requireApplicationId();
+        const permissions = new Permissions_js_1.PermissionsBitField(options.permissions ?? 0n);
+        return `${this.appUrl}/oauth2/authorize?client_id=${id}&permissions=${permissions}`;
+    }
+    async fetchInvite(code) {
+        return new ServerAssets_js_1.Invite(this, await this.rest.get(Routes_js_1.Routes.invite(code), { auth: false }));
+    }
+    async sync() {
+        if (!this.options.fetchServersOnReady)
+            return;
+        await this.users.fetchTags().catch((error) => this.emit('debug', `Could not load user tags: ${error.message}`));
+        const servers = await this.servers.fetch();
+        if (this.options.fetchMembersOnReady) {
+            await Promise.all(servers.map((server) => server.members.fetch().catch((error) => this.emit('debug', `Members of ${server.id}: ${error.message}`))));
+        }
+    }
+}
+exports.Client = Client;

package/dist/cjs/client/dispatch.d.ts

@@ -0,0 +1,2 @@
+import type { Client } from './Client.js';
+export declare function dispatch(client: Client, event: string, data: unknown): void;

package/dist/cjs/client/dispatch.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatch = dispatch;
+const Message_js_1 = require("../structures/Message.js");
+const ServerChannels_js_1 = require("../structures/channels/ServerChannels.js");
+const createInteraction_js_1 = require("../structures/interactions/createInteraction.js");
+const ScheduledEvent_js_1 = require("../structures/ScheduledEvent.js");
+const handlers = {
+    SERVER_CREATE(client, d) {
+        client.emit('serverCreate', client.servers._add(d));
+    },
+    SERVER_UPDATE(client, d) {
+        const server = client.servers.cache.get(d.id);
+        if (!server)
+            return void client.servers._add(d);
+        const before = server._clone();
+        client.emit('serverUpdate', before, server._patch(d));
+    },
+    SERVER_REMOVE(client, d) {
+        const server = client.servers._remove(d.serverId);
+        client.emit('serverRemove', { id: d.serverId, reason: d.reason ?? null, server });
+    },
+    SERVER_CHANNELS_UPDATE(client, d) {
+        const { created, updated, deleted } = client.channels._replaceServer(d.serverId, d.channels);
+        created.forEach((c) => client.emit('channelCreate', c));
+        updated.forEach(([before, after]) => client.emit('channelUpdate', before, after));
+        deleted.forEach((c) => client.emit('channelDelete', c));
+    },
+    SERVER_ROLES_UPDATE(client, d) {
+        const server = client.servers.cache.get(d.serverId);
+        if (!server)
+            return;
+        const { created, updated, deleted } = server.roles._setAll(d.roles);
+        created.forEach((r) => client.emit('roleCreate', r));
+        updated.forEach(([before, after]) => client.emit('roleUpdate', before, after));
+        deleted.forEach((r) => client.emit('roleDelete', r));
+    },
+    THREAD_UPDATE(client, d) {
+        const data = { ...d.channel, serverId: d.serverId };
+        const existing = client.channels.cache.get(data.id);
+        if (!(existing instanceof ServerChannels_js_1.ThreadChannel))
+            return void client.emit('threadCreate', client.channels._addThread(data));
+        const before = existing._clone();
+        client.emit('threadUpdate', before, client.channels._addThread(data));
+    },
+    MESSAGE_CREATE(client, d) {
+        const channel = client.channels._textChannel(d.channelId, d.serverId ?? null);
+        channel.lastMessageId = d.id;
+        client.emit('messageCreate', channel.messages._add(d));
+    },
+    MESSAGE_UPDATE(client, d) {
+        const channel = client.channels._textChannel(d.channelId, d.serverId ?? null);
+        const cached = channel.messages.cache.get(d.id);
+        const before = cached ? cached._clone() : null;
+        client.emit('messageUpdate', before, channel.messages._add(d));
+    },
+    MESSAGE_DELETE(client, d) {
+        const channel = client.channels._textChannel(d.channelId, null);
+        client.emit('messageDelete', { id: d.id, channelId: d.channelId, channel, message: channel.messages._remove(d.id) });
+    },
+    MESSAGE_REACTION_ADD(client, d) {
+        const event = reactionEvent(client, d);
+        const message = event.message;
+        if (message) {
+            const own = d.userId === client.user?.id;
+            const existing = message.reactions.get(d.emoji);
+            if (existing) {
+                existing.count++;
+                existing.me ||= own;
+            }
+            else {
+                message.reactions.set(d.emoji, new Message_js_1.MessageReaction(message, d.emoji, 1, own));
+            }
+        }
+        client.emit('messageReactionAdd', event);
+    },
+    MESSAGE_REACTION_REMOVE(client, d) {
+        const event = reactionEvent(client, d);
+        const reaction = event.message?.reactions.get(d.emoji);
+        if (reaction) {
+            reaction.count = Math.max(0, reaction.count - 1);
+            if (d.userId === client.user?.id)
+                reaction.me = false;
+            if (reaction.count === 0)
+                event.message?.reactions.delete(d.emoji);
+        }
+        client.emit('messageReactionRemove', event);
+    },
+    MESSAGE_PIN(client, d) {
+        const channel = client.channels._textChannel(d.channelId, null);
+        const message = channel.messages.cache.get(d.messageId);
+        if (message)
+            message.pinned = d.pinned;
+        client.emit('messagePin', { channelId: d.channelId, messageId: d.messageId, pinned: d.pinned, channel });
+    },
+    TYPING_START(client, d) {
+        client.emit('typingStart', {
+            channelId: d.channelId,
+            userId: d.userId,
+            channel: client.channels._textChannel(d.channelId, null),
+            user: client.users.cache.get(d.userId) ?? null
+        });
+    },
+    MENTION(client, d) {
+        client.emit('mention', { channelId: d.channelId, messageId: d.messageId, serverId: d.serverId ?? null });
+    },
+    POLL_VOTE(client, d) {
+        client.emit('pollVote', d);
+    },
+    MEMBER_ADD(client, d) {
+        const server = client.servers.cache.get(d.serverId);
+        if (server)
+            client.emit('memberAdd', server.members._add(d.member));
+    },
+    MEMBER_REMOVE(client, d) {
+        const server = client.servers.cache.get(d.serverId);
+        const member = server?.members.cache.get(d.userId) ?? null;
+        server?.members.cache.delete(d.userId);
+        client.emit('memberRemove', { serverId: d.serverId, userId: d.userId, member, user: member?.user ?? client.users.cache.get(d.userId) ?? null });
+    },
+    MEMBER_UPDATE(client, d) {
+        const server = client.servers.cache.get(d.serverId);
+        if (!server)
+            return;
+        const cached = server.members.cache.get(d.userId);
+        const user = client.users.cache.get(d.userId) ?? { id: d.userId, username: '' };
+        const before = cached ? cached._clone() : null;
+        const after = cached ?? server.members._add({ user, roles: [], nick: null });
+        after._patch(d);
+        client.emit('memberUpdate', before, after);
+    },
+    PRESENCE_UPDATE(client, d) {
+        const user = client.users.cache.get(d.userId) ?? null;
+        user?._patch({ status: d.status, customStatus: d.customStatus ?? null });
+        client.emit('presenceUpdate', { userId: d.userId, status: d.status, customStatus: d.customStatus ?? null, user });
+    },
+    USER_UPDATE(client, d) {
+        const cached = client.users.cache.get(d.id);
+        const before = cached ? cached._clone() : null;
+        client.emit('userUpdate', before, client.users._add(d));
+    },
+    CLAN_TAG_UPDATE(client, d) {
+        client.emit('clanTagUpdate', d);
+    },
+    DM_OPEN(client, d) {
+        client.emit('dmOpen', client.channels._addDM(d));
+    },
+    VOICE_STATE_UPDATE(client, d) {
+        const state = d;
+        const states = state.serverId ? client.servers.cache.get(state.serverId)?.voiceStates : undefined;
+        const before = states?.get(state.userId) ?? null;
+        if (state.channelId)
+            states?.set(state.userId, state);
+        else
+            states?.delete(state.userId);
+        client.emit('voiceStateUpdate', before, state);
+    },
+    SOUNDBOARD_PLAY: (client, d) => void client.emit('soundboardPlay', d),
+    CALL_ALONE: (client, d) => void client.emit('callAlone', d),
+    STAGE_INSTANCE_CREATE: (client, d) => void client.emit('stageInstanceCreate', d),
+    STAGE_INSTANCE_UPDATE: (client, d) => void client.emit('stageInstanceUpdate', d),
+    STAGE_INSTANCE_DELETE: (client, d) => void client.emit('stageInstanceDelete', d),
+    VOICE_CHANNEL_STATUS_UPDATE: (client, d) => void client.emit('voiceChannelStatusUpdate', d),
+    SERVER_SOUNDBOARD_UPDATE: (client, d) => void client.emit('serverSoundboardUpdate', d),
+    SERVER_STICKERS_UPDATE(client, d) {
+        client.servers.cache.get(d.serverId)?.stickers._setAll(d.stickers);
+        client.emit('serverStickersUpdate', d);
+    },
+    SERVER_EVENT_CREATE(client, d) {
+        const server = client.servers.cache.get(d.serverId);
+        client.emit('serverEventCreate', server ? server.events._add(d) : new ScheduledEvent_js_1.ScheduledEvent(client, d));
+    },
+    SERVER_EVENT_UPDATE(client, d) {
+        const server = client.servers.cache.get(d.serverId);
+        client.emit('serverEventUpdate', server ? server.events._add(d) : new ScheduledEvent_js_1.ScheduledEvent(client, d));
+    },
+    SERVER_EVENT_DELETE(client, d) {
+        client.servers.cache.get(d.serverId)?.events.cache.delete(d.id);
+        client.emit('serverEventDelete', { serverId: d.serverId, id: d.id });
+    },
+    SERVER_EVENT_USER_ADD(client, d) {
+        const event = client.servers.cache.get(d.serverId)?.events.cache.get(d.eventId);
+        if (event)
+            event.interestedCount = d.interestedCount;
+        client.emit('serverEventUserAdd', { serverId: d.serverId, eventId: d.eventId, userId: d.userId, interestedCount: d.interestedCount });
+    },
+    SERVER_EVENT_USER_REMOVE(client, d) {
+        const event = client.servers.cache.get(d.serverId)?.events.cache.get(d.eventId);
+        if (event)
+            event.interestedCount = d.interestedCount;
+        client.emit('serverEventUserRemove', { serverId: d.serverId, eventId: d.eventId, userId: d.userId, interestedCount: d.interestedCount });
+    },
+    INTERACTION_CREATE(client, d) {
+        const raw = d;
+        if (raw.type === 'ping')
+            return;
+        client.setApplicationId(raw.applicationId);
+        client.emit('interactionCreate', (0, createInteraction_js_1.createInteraction)(client, raw));
+    }
+};
+function reactionEvent(client, d) {
+    const channel = client.channels._textChannel(d.channelId, null);
+    return {
+        channelId: d.channelId,
+        messageId: d.messageId,
+        userId: d.userId,
+        emoji: d.emoji,
+        channel,
+        message: channel.messages.cache.get(d.messageId) ?? null,
+        user: client.users.cache.get(d.userId) ?? null
+    };
+}
+function dispatch(client, event, data) {
+    client.emit('raw', { t: event, d: data });
+    try {
+        handlers[event]?.(client, data);
+    }
+    catch (error) {
+        if (client.listenerCount('error') > 0)
+            client.emit('error', error);
+        else
+            queueMicrotask(() => { throw error; });
+    }
+}

package/dist/cjs/client/events.d.ts

@@ -0,0 +1,129 @@
+import type { Channel } from '../structures/channels/ServerChannels.js';
+import type { ThreadChannel } from '../structures/channels/ServerChannels.js';
+import type { DMChannel } from '../structures/channels/DMChannel.js';
+import type { TextBasedChannel } from '../structures/channels/TextBasedChannel.js';
+import type { BaseInteraction } from '../structures/interactions/BaseInteraction.js';
+import type { Message } from '../structures/Message.js';
+import type { Role } from '../structures/Role.js';
+import type { ScheduledEvent } from '../structures/ScheduledEvent.js';
+import type { Server } from '../structures/Server.js';
+import type { ServerMember } from '../structures/ServerMember.js';
+import type { User } from '../structures/User.js';
+import type { APIVoiceState } from '../types.js';
+import type { Client } from './Client.js';
+export interface ServerRemoval {
+    id: string;
+    reason: string | null;
+    server: Server | null;
+}
+export interface MessageDeleteEvent {
+    id: string;
+    channelId: string;
+    channel: TextBasedChannel;
+    message: Message | null;
+}
+export interface ReactionEvent {
+    channelId: string;
+    messageId: string;
+    userId: string;
+    emoji: string;
+    channel: TextBasedChannel;
+    message: Message | null;
+    user: User | null;
+}
+export interface MessagePinEvent {
+    channelId: string;
+    messageId: string;
+    pinned: boolean;
+    channel: TextBasedChannel;
+}
+export interface TypingEvent {
+    channelId: string;
+    userId: string;
+    channel: TextBasedChannel;
+    user: User | null;
+}
+export interface MentionEvent {
+    channelId: string;
+    messageId: string;
+    serverId: string | null;
+}
+export interface MemberRemoval {
+    serverId: string;
+    userId: string;
+    member: ServerMember | null;
+    user: User | null;
+}
+export interface PresenceEvent {
+    userId: string;
+    status: string;
+    customStatus: string | null;
+    user: User | null;
+}
+export type ClientEvents = {
+    ready: [client: Client];
+    reconnected: [client: Client];
+    reconnecting: [attempt: number, delayMs: number];
+    disconnect: [code: number, reason: string];
+    raw: [packet: {
+        t: string;
+        d: unknown;
+    }];
+    debug: [message: string];
+    error: [error: Error];
+    serverCreate: [server: Server];
+    serverUpdate: [before: Server, after: Server];
+    serverRemove: [removal: ServerRemoval];
+    channelCreate: [channel: Channel];
+    channelUpdate: [before: Channel, after: Channel];
+    channelDelete: [channel: Channel];
+    roleCreate: [role: Role];
+    roleUpdate: [before: Role, after: Role];
+    roleDelete: [role: Role];
+    threadCreate: [thread: ThreadChannel];
+    threadUpdate: [before: ThreadChannel, after: ThreadChannel];
+    messageCreate: [message: Message];
+    messageUpdate: [before: Message | null, after: Message];
+    messageDelete: [event: MessageDeleteEvent];
+    messageReactionAdd: [event: ReactionEvent];
+    messageReactionRemove: [event: ReactionEvent];
+    messagePin: [event: MessagePinEvent];
+    typingStart: [event: TypingEvent];
+    mention: [event: MentionEvent];
+    pollVote: [data: Record<string, unknown>];
+    memberAdd: [member: ServerMember];
+    memberRemove: [removal: MemberRemoval];
+    memberUpdate: [before: ServerMember | null, after: ServerMember];
+    presenceUpdate: [event: PresenceEvent];
+    userUpdate: [before: User | null, after: User];
+    clanTagUpdate: [data: Record<string, unknown>];
+    dmOpen: [channel: DMChannel];
+    voiceStateUpdate: [before: APIVoiceState | null, after: APIVoiceState];
+    soundboardPlay: [data: Record<string, unknown>];
+    callAlone: [data: Record<string, unknown>];
+    stageInstanceCreate: [data: Record<string, unknown>];
+    stageInstanceUpdate: [data: Record<string, unknown>];
+    stageInstanceDelete: [data: Record<string, unknown>];
+    voiceChannelStatusUpdate: [data: Record<string, unknown>];
+    serverStickersUpdate: [data: Record<string, unknown>];
+    serverSoundboardUpdate: [data: Record<string, unknown>];
+    serverEventCreate: [event: ScheduledEvent];
+    serverEventUpdate: [event: ScheduledEvent];
+    serverEventDelete: [data: {
+        serverId: string;
+        id: string;
+    }];
+    serverEventUserAdd: [data: {
+        serverId: string;
+        eventId: string;
+        userId: string;
+        interestedCount: number;
+    }];
+    serverEventUserRemove: [data: {
+        serverId: string;
+        eventId: string;
+        userId: string;
+        interestedCount: number;
+    }];
+    interactionCreate: [interaction: BaseInteraction];
+};

package/dist/cjs/client/events.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/collectors/Collector.d.ts

@@ -0,0 +1,37 @@
+import { BaffError } from '../errors/BaffError.js';
+import { Collection } from '../util/Collection.js';
+import { TypedEmitter } from '../util/TypedEmitter.js';
+export interface CollectorOptions<V> {
+    filter?: (item: V, collected: Collection<string, V>) => boolean | Promise<boolean>;
+    time?: number;
+    idle?: number;
+    max?: number;
+    maxProcessed?: number;
+}
+type CollectorEvents<V> = {
+    collect: [item: V];
+    ignore: [item: V];
+    end: [collected: Collection<string, V>, reason: string];
+};
+export declare class CollectorError extends BaffError {
+    readonly collected: Collection<string, unknown>;
+    readonly reason: string;
+    constructor(collected: Collection<string, unknown>, reason: string);
+}
+export declare abstract class Collector<V> extends TypedEmitter<CollectorEvents<V>> {
+    protected readonly options: CollectorOptions<V>;
+    readonly collected: Collection<string, V>;
+    ended: boolean;
+    endReason: string | null;
+    private processed;
+    private timer;
+    private idleTimer;
+    constructor(options?: CollectorOptions<V>);
+    protected abstract keyOf(item: V): string;
+    protected handle(item: V): Promise<void>;
+    stop(reason?: string): void;
+    protected abstract cleanup(): void;
+    private resetIdle;
+}
+export declare function awaitCollector<V>(collector: Collector<V>, errors?: string[]): Promise<Collection<string, V>>;
+export {};