@jubbio/core 1.0.0

package/dist/structures/Channel.d.ts

@@ -0,0 +1,120 @@
+import { APIChannel, APIEmbed } from '../types';
+import { ChannelType } from '../enums';
+import type { Client } from '../Client';
+import { Message } from './Message';
+import { Collection } from './Collection';
+import { MessageCollector, MessageCollectorOptions } from '../utils/Collector';
+/**
+ * Await messages options
+ */
+export interface AwaitMessagesOptions extends MessageCollectorOptions {
+    /** Errors to reject on */
+    errors?: string[];
+}
+/**
+ * Base channel class
+ */
+export declare class BaseChannel {
+    /** Reference to the client */
+    readonly client: Client;
+    /** Channel ID */
+    readonly id: string;
+    /** Channel type */
+    readonly type: ChannelType;
+    constructor(client: Client, data: APIChannel);
+    /**
+     * Check if this is a text-based channel
+     */
+    isTextBased(): this is TextChannel;
+    /**
+     * Check if this is a voice-based channel
+     */
+    isVoiceBased(): this is VoiceChannel;
+    /**
+     * Convert to string (mention format)
+     */
+    toString(): string;
+}
+/**
+ * Text channel
+ */
+export declare class TextChannel extends BaseChannel {
+    /** Guild ID */
+    guildId?: string;
+    /** Channel name */
+    name?: string;
+    /** Channel topic */
+    topic?: string;
+    /** Channel position */
+    position?: number;
+    /** Parent category ID */
+    parentId?: string;
+    constructor(client: Client, data: APIChannel);
+    /**
+     * Send a message to this channel
+     */
+    send(options: string | MessageCreateOptions): Promise<Message>;
+    /**
+     * Create a message collector
+     */
+    createMessageCollector(options?: MessageCollectorOptions): MessageCollector;
+    /**
+     * Await messages in this channel
+     */
+    awaitMessages(options?: AwaitMessagesOptions): Promise<Collection<string, Message>>;
+    /**
+     * Bulk delete messages
+     */
+    bulkDelete(messages: number | string[] | Collection<string, Message>, filterOld?: boolean): Promise<Collection<string, Message>>;
+}
+/**
+ * Voice channel
+ */
+export declare class VoiceChannel extends BaseChannel {
+    /** Guild ID */
+    guildId?: string;
+    /** Channel name */
+    name?: string;
+    /** Channel position */
+    position?: number;
+    /** Parent category ID */
+    parentId?: string;
+    /** User limit */
+    userLimit?: number;
+    /** Bitrate */
+    bitrate?: number;
+    constructor(client: Client, data: APIChannel & {
+        user_limit?: number;
+        bitrate?: number;
+    });
+    /**
+     * Check if the channel is joinable
+     */
+    get joinable(): boolean;
+}
+/**
+ * DM channel
+ */
+export declare class DMChannel extends BaseChannel {
+    /** Recipient user ID */
+    recipientId?: string;
+    constructor(client: Client, data: APIChannel & {
+        recipient_id?: string;
+    });
+    /**
+     * Send a message to this DM
+     */
+    send(options: string | MessageCreateOptions): Promise<Message>;
+}
+/**
+ * Message create options
+ */
+export interface MessageCreateOptions {
+    content?: string;
+    embeds?: APIEmbed[];
+    files?: any[];
+}
+/**
+ * Create appropriate channel class based on type
+ */
+export declare function createChannel(client: Client, data: APIChannel): BaseChannel;

package/dist/structures/Channel.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DMChannel = exports.VoiceChannel = exports.TextChannel = exports.BaseChannel = void 0;
+exports.createChannel = createChannel;
+const enums_1 = require("../enums");
+const Message_1 = require("./Message");
+const Collection_1 = require("./Collection");
+const Collector_1 = require("../utils/Collector");
+/**
+ * Base channel class
+ */
+class BaseChannel {
+    /** Reference to the client */
+    client;
+    /** Channel ID */
+    id;
+    /** Channel type */
+    type;
+    constructor(client, data) {
+        this.client = client;
+        this.id = data.id;
+        this.type = data.type;
+    }
+    /**
+     * Check if this is a text-based channel
+     */
+    isTextBased() {
+        return [
+            enums_1.ChannelType.GuildText,
+            enums_1.ChannelType.DM,
+            enums_1.ChannelType.GroupDM,
+            enums_1.ChannelType.GuildAnnouncement
+        ].includes(this.type);
+    }
+    /**
+     * Check if this is a voice-based channel
+     */
+    isVoiceBased() {
+        return [
+            enums_1.ChannelType.GuildVoice,
+            enums_1.ChannelType.GuildStageVoice
+        ].includes(this.type);
+    }
+    /**
+     * Convert to string (mention format)
+     */
+    toString() {
+        return `<#${this.id}>`;
+    }
+}
+exports.BaseChannel = BaseChannel;
+/**
+ * Text channel
+ */
+class TextChannel extends BaseChannel {
+    /** Guild ID */
+    guildId;
+    /** Channel name */
+    name;
+    /** Channel topic */
+    topic;
+    /** Channel position */
+    position;
+    /** Parent category ID */
+    parentId;
+    constructor(client, data) {
+        super(client, data);
+        this.guildId = data.guild_id;
+        this.name = data.name;
+        this.topic = data.topic;
+        this.position = data.position;
+        this.parentId = data.parent_id;
+    }
+    /**
+     * Send a message to this channel
+     */
+    async send(options) {
+        const content = typeof options === 'string' ? options : options.content;
+        const embeds = typeof options === 'string' ? undefined : options.embeds;
+        const data = await this.client.rest.createMessage(this.guildId || '', this.id, {
+            content,
+            embeds
+        });
+        return new Message_1.Message(this.client, data);
+    }
+    /**
+     * Create a message collector
+     */
+    createMessageCollector(options) {
+        return new Collector_1.MessageCollector(this.client, this.id, options);
+    }
+    /**
+     * Await messages in this channel
+     */
+    awaitMessages(options) {
+        return new Promise((resolve, reject) => {
+            const collector = this.createMessageCollector(options);
+            collector.once('end', (collected, reason) => {
+                if (options?.errors?.includes(reason)) {
+                    reject(collected);
+                }
+                else {
+                    resolve(collected);
+                }
+            });
+        });
+    }
+    /**
+     * Bulk delete messages
+     */
+    async bulkDelete(messages, filterOld = true) {
+        let messageIds;
+        if (typeof messages === 'number') {
+            // Fetch messages first
+            const fetched = await this.client.rest.getMessages(this.guildId || '', this.id, { limit: messages });
+            messageIds = fetched.map(m => m.id);
+        }
+        else if (messages instanceof Collection_1.Collection) {
+            messageIds = [...messages.keys()];
+        }
+        else {
+            messageIds = messages;
+        }
+        // Filter old messages (older than 14 days)
+        if (filterOld) {
+            const twoWeeksAgo = Date.now() - 14 * 24 * 60 * 60 * 1000;
+            messageIds = messageIds.filter(id => {
+                // Extract timestamp from snowflake
+                const timestamp = Number(BigInt(id) >> 22n) + 1420070400000;
+                return timestamp > twoWeeksAgo;
+            });
+        }
+        if (messageIds.length === 0) {
+            return new Collection_1.Collection();
+        }
+        if (messageIds.length === 1) {
+            await this.client.rest.deleteMessage(this.guildId || '', this.id, messageIds[0]);
+        }
+        else {
+            await this.client.rest.bulkDeleteMessages(this.guildId || '', this.id, messageIds);
+        }
+        // Return deleted messages as collection
+        const deleted = new Collection_1.Collection();
+        // Note: We don't have the actual message objects here
+        return deleted;
+    }
+}
+exports.TextChannel = TextChannel;
+/**
+ * Voice channel
+ */
+class VoiceChannel extends BaseChannel {
+    /** Guild ID */
+    guildId;
+    /** Channel name */
+    name;
+    /** Channel position */
+    position;
+    /** Parent category ID */
+    parentId;
+    /** User limit */
+    userLimit;
+    /** Bitrate */
+    bitrate;
+    constructor(client, data) {
+        super(client, data);
+        this.guildId = data.guild_id;
+        this.name = data.name;
+        this.position = data.position;
+        this.parentId = data.parent_id;
+        this.userLimit = data.user_limit;
+        this.bitrate = data.bitrate;
+    }
+    /**
+     * Check if the channel is joinable
+     */
+    get joinable() {
+        // TODO: Check permissions
+        return true;
+    }
+}
+exports.VoiceChannel = VoiceChannel;
+/**
+ * DM channel
+ */
+class DMChannel extends BaseChannel {
+    /** Recipient user ID */
+    recipientId;
+    constructor(client, data) {
+        super(client, data);
+        this.recipientId = data.recipient_id;
+    }
+    /**
+     * Send a message to this DM
+     */
+    async send(options) {
+        const content = typeof options === 'string' ? options : options.content;
+        const embeds = typeof options === 'string' ? undefined : options.embeds;
+        const data = await this.client.rest.createDMMessage(this.id, {
+            content,
+            embeds
+        });
+        return new Message_1.Message(this.client, data);
+    }
+}
+exports.DMChannel = DMChannel;
+/**
+ * Create appropriate channel class based on type
+ */
+function createChannel(client, data) {
+    switch (data.type) {
+        case enums_1.ChannelType.GuildText:
+        case enums_1.ChannelType.GuildAnnouncement:
+            return new TextChannel(client, data);
+        case enums_1.ChannelType.GuildVoice:
+        case enums_1.ChannelType.GuildStageVoice:
+            return new VoiceChannel(client, data);
+        case enums_1.ChannelType.DM:
+            return new DMChannel(client, data);
+        default:
+            return new BaseChannel(client, data);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Channel.js","sourceRoot":"","sources":["../../src/structures/Channel.ts"],"names":[],"mappings":"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","sourcesContent":["import { APIChannel, APIMessage, APIEmbed } from '../types';\r\nimport { ChannelType } from '../enums';\r\nimport type { Client } from '../Client';\r\nimport { Message } from './Message';\r\nimport { Collection } from './Collection';\r\nimport { MessageCollector, MessageCollectorOptions } from '../utils/Collector';\r\n\r\n/**\r\n * Await messages options\r\n */\r\nexport interface AwaitMessagesOptions extends MessageCollectorOptions {\r\n  /** Errors to reject on */\r\n  errors?: string[];\r\n}\r\n\r\n/**\r\n * Base channel class\r\n */\r\nexport class BaseChannel {\r\n  /** Reference to the client */\r\n  public readonly client: Client;\r\n  \r\n  /** Channel ID */\r\n  public readonly id: string;\r\n  \r\n  /** Channel type */\r\n  public readonly type: ChannelType;\r\n\r\n  constructor(client: Client, data: APIChannel) {\r\n    this.client = client;\r\n    this.id = data.id;\r\n    this.type = data.type;\r\n  }\r\n\r\n  /**\r\n   * Check if this is a text-based channel\r\n   */\r\n  isTextBased(): this is TextChannel {\r\n    return [\r\n      ChannelType.GuildText,\r\n      ChannelType.DM,\r\n      ChannelType.GroupDM,\r\n      ChannelType.GuildAnnouncement\r\n    ].includes(this.type);\r\n  }\r\n\r\n  /**\r\n   * Check if this is a voice-based channel\r\n   */\r\n  isVoiceBased(): this is VoiceChannel {\r\n    return [\r\n      ChannelType.GuildVoice,\r\n      ChannelType.GuildStageVoice\r\n    ].includes(this.type);\r\n  }\r\n\r\n  /**\r\n   * Convert to string (mention format)\r\n   */\r\n  toString(): string {\r\n    return `<#${this.id}>`;\r\n  }\r\n}\r\n\r\n/**\r\n * Text channel\r\n */\r\nexport class TextChannel extends BaseChannel {\r\n  /** Guild ID */\r\n  public guildId?: string;\r\n  \r\n  /** Channel name */\r\n  public name?: string;\r\n  \r\n  /** Channel topic */\r\n  public topic?: string;\r\n  \r\n  /** Channel position */\r\n  public position?: number;\r\n  \r\n  /** Parent category ID */\r\n  public parentId?: string;\r\n\r\n  constructor(client: Client, data: APIChannel) {\r\n    super(client, data);\r\n    this.guildId = data.guild_id;\r\n    this.name = data.name;\r\n    this.topic = data.topic;\r\n    this.position = data.position;\r\n    this.parentId = data.parent_id;\r\n  }\r\n\r\n  /**\r\n   * Send a message to this channel\r\n   */\r\n  async send(options: string | MessageCreateOptions): Promise<Message> {\r\n    const content = typeof options === 'string' ? options : options.content;\r\n    const embeds = typeof options === 'string' ? undefined : options.embeds;\r\n    \r\n    const data = await this.client.rest.createMessage(this.guildId || '', this.id, {\r\n      content,\r\n      embeds\r\n    });\r\n    \r\n    return new Message(this.client, data);\r\n  }\r\n\r\n  /**\r\n   * Create a message collector\r\n   */\r\n  createMessageCollector(options?: MessageCollectorOptions): MessageCollector {\r\n    return new MessageCollector(this.client, this.id, options);\r\n  }\r\n\r\n  /**\r\n   * Await messages in this channel\r\n   */\r\n  awaitMessages(options?: AwaitMessagesOptions): Promise<Collection<string, Message>> {\r\n    return new Promise((resolve, reject) => {\r\n      const collector = this.createMessageCollector(options);\r\n      \r\n      collector.once('end', (collected, reason) => {\r\n        if (options?.errors?.includes(reason)) {\r\n          reject(collected);\r\n        } else {\r\n          resolve(collected);\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Bulk delete messages\r\n   */\r\n  async bulkDelete(messages: number | string[] | Collection<string, Message>, filterOld = true): Promise<Collection<string, Message>> {\r\n    let messageIds: string[];\r\n    \r\n    if (typeof messages === 'number') {\r\n      // Fetch messages first\r\n      const fetched = await this.client.rest.getMessages(this.guildId || '', this.id, { limit: messages });\r\n      messageIds = fetched.map(m => m.id);\r\n    } else if (messages instanceof Collection) {\r\n      messageIds = [...messages.keys()];\r\n    } else {\r\n      messageIds = messages;\r\n    }\r\n\r\n    // Filter old messages (older than 14 days)\r\n    if (filterOld) {\r\n      const twoWeeksAgo = Date.now() - 14 * 24 * 60 * 60 * 1000;\r\n      messageIds = messageIds.filter(id => {\r\n        // Extract timestamp from snowflake\r\n        const timestamp = Number(BigInt(id) >> 22n) + 1420070400000;\r\n        return timestamp > twoWeeksAgo;\r\n      });\r\n    }\r\n\r\n    if (messageIds.length === 0) {\r\n      return new Collection();\r\n    }\r\n\r\n    if (messageIds.length === 1) {\r\n      await this.client.rest.deleteMessage(this.guildId || '', this.id, messageIds[0]);\r\n    } else {\r\n      await this.client.rest.bulkDeleteMessages(this.guildId || '', this.id, messageIds);\r\n    }\r\n\r\n    // Return deleted messages as collection\r\n    const deleted = new Collection<string, Message>();\r\n    // Note: We don't have the actual message objects here\r\n    return deleted;\r\n  }\r\n}\r\n\r\n/**\r\n * Voice channel\r\n */\r\nexport class VoiceChannel extends BaseChannel {\r\n  /** Guild ID */\r\n  public guildId?: string;\r\n  \r\n  /** Channel name */\r\n  public name?: string;\r\n  \r\n  /** Channel position */\r\n  public position?: number;\r\n  \r\n  /** Parent category ID */\r\n  public parentId?: string;\r\n  \r\n  /** User limit */\r\n  public userLimit?: number;\r\n  \r\n  /** Bitrate */\r\n  public bitrate?: number;\r\n\r\n  constructor(client: Client, data: APIChannel & { user_limit?: number; bitrate?: number }) {\r\n    super(client, data);\r\n    this.guildId = data.guild_id;\r\n    this.name = data.name;\r\n    this.position = data.position;\r\n    this.parentId = data.parent_id;\r\n    this.userLimit = data.user_limit;\r\n    this.bitrate = data.bitrate;\r\n  }\r\n\r\n  /**\r\n   * Check if the channel is joinable\r\n   */\r\n  get joinable(): boolean {\r\n    // TODO: Check permissions\r\n    return true;\r\n  }\r\n}\r\n\r\n/**\r\n * DM channel\r\n */\r\nexport class DMChannel extends BaseChannel {\r\n  /** Recipient user ID */\r\n  public recipientId?: string;\r\n\r\n  constructor(client: Client, data: APIChannel & { recipient_id?: string }) {\r\n    super(client, data);\r\n    this.recipientId = data.recipient_id;\r\n  }\r\n\r\n  /**\r\n   * Send a message to this DM\r\n   */\r\n  async send(options: string | MessageCreateOptions): Promise<Message> {\r\n    const content = typeof options === 'string' ? options : options.content;\r\n    const embeds = typeof options === 'string' ? undefined : options.embeds;\r\n    \r\n    const data = await this.client.rest.createDMMessage(this.id, {\r\n      content,\r\n      embeds\r\n    });\r\n    \r\n    return new Message(this.client, data);\r\n  }\r\n}\r\n\r\n/**\r\n * Message create options\r\n */\r\nexport interface MessageCreateOptions {\r\n  content?: string;\r\n  embeds?: APIEmbed[];\r\n  files?: any[];\r\n}\r\n\r\n/**\r\n * Create appropriate channel class based on type\r\n */\r\nexport function createChannel(client: Client, data: APIChannel): BaseChannel {\r\n  switch (data.type) {\r\n    case ChannelType.GuildText:\r\n    case ChannelType.GuildAnnouncement:\r\n      return new TextChannel(client, data);\r\n    case ChannelType.GuildVoice:\r\n    case ChannelType.GuildStageVoice:\r\n      return new VoiceChannel(client, data);\r\n    case ChannelType.DM:\r\n      return new DMChannel(client, data);\r\n    default:\r\n      return new BaseChannel(client, data);\r\n  }\r\n}\r\n"]}

package/dist/structures/Collection.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Extended Map with utility methods
+ */
+export declare class Collection<K, V> extends Map<K, V> {
+    /**
+     * Get the first value in the collection
+     */
+    first(): V | undefined;
+    /**
+     * Get the last value in the collection
+     */
+    last(): V | undefined;
+    /**
+     * Get a random value from the collection
+     */
+    random(): V | undefined;
+    /**
+     * Find a value matching a predicate
+     */
+    find(fn: (value: V, key: K, collection: this) => boolean): V | undefined;
+    /**
+     * Filter values matching a predicate
+     */
+    filter(fn: (value: V, key: K, collection: this) => boolean): Collection<K, V>;
+    /**
+     * Map values to a new array
+     */
+    map<T>(fn: (value: V, key: K, collection: this) => T): T[];
+    /**
+     * Check if some values match a predicate
+     */
+    some(fn: (value: V, key: K, collection: this) => boolean): boolean;
+    /**
+     * Check if every value matches a predicate
+     */
+    every(fn: (value: V, key: K, collection: this) => boolean): boolean;
+    /**
+     * Reduce the collection to a single value
+     */
+    reduce<T>(fn: (accumulator: T, value: V, key: K, collection: this) => T, initialValue: T): T;
+    /**
+     * Convert to array
+     */
+    toArray(): V[];
+    /**
+     * Clone the collection
+     */
+    clone(): Collection<K, V>;
+    /**
+     * Concat with another collection
+     */
+    concat(...collections: Collection<K, V>[]): Collection<K, V>;
+}

package/dist/structures/Collection.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Collection = void 0;
+/**
+ * Extended Map with utility methods
+ */
+class Collection extends Map {
+    /**
+     * Get the first value in the collection
+     */
+    first() {
+        return this.values().next().value;
+    }
+    /**
+     * Get the last value in the collection
+     */
+    last() {
+        const arr = [...this.values()];
+        return arr[arr.length - 1];
+    }
+    /**
+     * Get a random value from the collection
+     */
+    random() {
+        const arr = [...this.values()];
+        return arr[Math.floor(Math.random() * arr.length)];
+    }
+    /**
+     * Find a value matching a predicate
+     */
+    find(fn) {
+        for (const [key, val] of this) {
+            if (fn(val, key, this))
+                return val;
+        }
+        return undefined;
+    }
+    /**
+     * Filter values matching a predicate
+     */
+    filter(fn) {
+        const results = new Collection();
+        for (const [key, val] of this) {
+            if (fn(val, key, this))
+                results.set(key, val);
+        }
+        return results;
+    }
+    /**
+     * Map values to a new array
+     */
+    map(fn) {
+        const results = [];
+        for (const [key, val] of this) {
+            results.push(fn(val, key, this));
+        }
+        return results;
+    }
+    /**
+     * Check if some values match a predicate
+     */
+    some(fn) {
+        for (const [key, val] of this) {
+            if (fn(val, key, this))
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Check if every value matches a predicate
+     */
+    every(fn) {
+        for (const [key, val] of this) {
+            if (!fn(val, key, this))
+                return false;
+        }
+        return true;
+    }
+    /**
+     * Reduce the collection to a single value
+     */
+    reduce(fn, initialValue) {
+        let accumulator = initialValue;
+        for (const [key, val] of this) {
+            accumulator = fn(accumulator, val, key, this);
+        }
+        return accumulator;
+    }
+    /**
+     * Convert to array
+     */
+    toArray() {
+        return [...this.values()];
+    }
+    /**
+     * Clone the collection
+     */
+    clone() {
+        return new Collection(this);
+    }
+    /**
+     * Concat with another collection
+     */
+    concat(...collections) {
+        const newColl = this.clone();
+        for (const coll of collections) {
+            for (const [key, val] of coll) {
+                newColl.set(key, val);
+            }
+        }
+        return newColl;
+    }
+}
+exports.Collection = Collection;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/structures/Guild.d.ts

@@ -0,0 +1,59 @@
+import { APIGuild, APIChannel, APIGuildMember } from '../types';
+import { Collection } from './Collection';
+import { GuildMember } from './GuildMember';
+import type { Client } from '../Client';
+/**
+ * Represents a guild
+ */
+export declare class Guild {
+    /** Reference to the client */
+    readonly client: Client;
+    /** Guild ID */
+    readonly id: string;
+    /** Guild name */
+    name: string;
+    /** Guild icon URL */
+    icon?: string;
+    /** Owner ID */
+    ownerId: string;
+    /** Whether the guild is unavailable */
+    unavailable: boolean;
+    /** Cached members */
+    members: Collection<string, GuildMember>;
+    /** Cached channels */
+    channels: Collection<string, APIChannel>;
+    constructor(client: Client, data: APIGuild);
+    /**
+     * Get the guild icon URL
+     */
+    iconURL(options?: {
+        size?: number;
+    }): string | null;
+    /**
+     * Get the voice adapter creator for @jubbio/voice
+     */
+    get voiceAdapterCreator(): ((methods: {
+        onVoiceServerUpdate(data: any): void;
+        onVoiceStateUpdate(data: any): void;
+        destroy(): void;
+    }) => {
+        sendPayload(payload: any): boolean;
+        destroy(): void;
+    }) | undefined;
+    /**
+     * Fetch a member by ID
+     */
+    fetchMember(userId: string): Promise<GuildMember | null>;
+    /**
+     * Convert to string
+     */
+    toString(): string;
+    /**
+     * Update guild data
+     */
+    _patch(data: Partial<APIGuild>): void;
+    /**
+     * Add a member to cache
+     */
+    _addMember(data: APIGuildMember): GuildMember;
+}