@jubbio/core 1.3.1 → 1.3.2

package/dist/esm/structures/Channel.js

@@ -0,0 +1,232 @@
+import { ChannelType } from '../enums';
+import { Message } from './Message';
+import { Collection } from './Collection';
+import { MessageCollector } from '../utils/Collector';
+import { EmbedBuilder } from '../builders/EmbedBuilder';
+/** Resolve EmbedBuilder instances to plain API objects */
+function resolveEmbeds(embeds) {
+    if (!embeds)
+        return undefined;
+    return embeds.map(e => e instanceof EmbedBuilder ? e.toJSON() : e);
+}
+/**
+ * Base channel class
+ */
+export 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 [
+            ChannelType.GuildText,
+            ChannelType.DM,
+            ChannelType.GroupDM,
+            ChannelType.GuildAnnouncement
+        ].includes(this.type);
+    }
+    /**
+     * Check if this is a voice-based channel
+     */
+    isVoiceBased() {
+        return [
+            ChannelType.GuildVoice,
+            ChannelType.GuildStageVoice
+        ].includes(this.type);
+    }
+    /**
+     * Convert to string (mention format)
+     */
+    toString() {
+        return `<#${this.id}>`;
+    }
+}
+/**
+ * Text channel
+ */
+export 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 : resolveEmbeds(options.embeds);
+        const components = typeof options === 'string' ? undefined : options.components;
+        const data = await this.client.rest.createMessage(this.guildId || '', this.id, {
+            content,
+            embeds,
+            components,
+        });
+        return new Message(this.client, data);
+    }
+    /**
+     * Create a message collector
+     */
+    createMessageCollector(options) {
+        return new 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) {
+            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();
+        }
+        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();
+        // Note: We don't have the actual message objects here
+        return deleted;
+    }
+}
+/**
+ * Voice channel
+ */
+export 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 bot can join this voice channel
+     */
+    get joinable() {
+        if (!this.guildId || !this.client.user)
+            return false;
+        const guild = this.client.guilds.get(this.guildId);
+        if (!guild)
+            return false;
+        const me = guild.members.get(String(this.client.user.id));
+        if (!me)
+            return true; // No cached member — optimistic, server will reject if not allowed
+        return me.permissions.has('Connect');
+    }
+}
+/**
+ * DM channel
+ */
+export 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 : resolveEmbeds(options.embeds);
+        const data = await this.client.rest.createDMMessage(this.id, {
+            content,
+            embeds
+        });
+        return new Message(this.client, data);
+    }
+}
+/**
+ * Create appropriate channel class based on type
+ */
+export function createChannel(client, data) {
+    switch (data.type) {
+        case ChannelType.GuildText:
+        case ChannelType.GuildAnnouncement:
+            return new TextChannel(client, data);
+        case ChannelType.GuildVoice:
+        case ChannelType.GuildStageVoice:
+            return new VoiceChannel(client, data);
+        case 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\nimport { EmbedBuilder, APIEmbed as BuilderAPIEmbed } from '../builders/EmbedBuilder';\r\n\r\n/** Resolve EmbedBuilder instances to plain API objects */\r\nfunction resolveEmbeds(embeds?: (BuilderAPIEmbed | EmbedBuilder)[]): BuilderAPIEmbed[] | undefined {\r\n  if (!embeds) return undefined;\r\n  return embeds.map(e => e instanceof EmbedBuilder ? e.toJSON() : e);\r\n}\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 : resolveEmbeds(options.embeds);\r\n    const components = typeof options === 'string' ? undefined : options.components;\r\n    \r\n    const data = await this.client.rest.createMessage(this.guildId || '', this.id, {\r\n      content,\r\n      embeds,\r\n      components,\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 bot can join this voice channel\r\n   */\r\n  get joinable(): boolean {\r\n    if (!this.guildId || !this.client.user) return false;\r\n    const guild = this.client.guilds.get(this.guildId);\r\n    if (!guild) return false;\r\n    const me = guild.members.get(String(this.client.user.id));\r\n    if (!me) return true; // No cached member — optimistic, server will reject if not allowed\r\n    return me.permissions.has('Connect');\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 : resolveEmbeds(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 | EmbedBuilder)[];\r\n  components?: any[];\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/esm/structures/Collection.js

@@ -0,0 +1,111 @@
+/**
+ * Extended Map with utility methods
+ */
+export 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;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/structures/Guild.js

@@ -0,0 +1,90 @@
+import { Collection } from './Collection';
+import { GuildMember } from './GuildMember';
+/**
+ * Represents a guild
+ */
+export class Guild {
+    /** Reference to the client */
+    client;
+    /** Guild ID */
+    id;
+    /** Guild name */
+    name;
+    /** Guild icon URL */
+    icon;
+    /** Owner ID */
+    ownerId;
+    /** Whether the guild is unavailable */
+    unavailable;
+    /** Cached members */
+    members;
+    /** Cached channels */
+    channels;
+    constructor(client, data) {
+        this.client = client;
+        this.id = data.id;
+        this.name = data.name;
+        this.icon = data.icon;
+        this.ownerId = data.owner_id;
+        this.unavailable = data.unavailable ?? false;
+        this.members = new Collection();
+        this.channels = new Collection();
+    }
+    /**
+     * Get the guild icon URL
+     */
+    iconURL(options) {
+        if (!this.icon)
+            return null;
+        return this.icon;
+    }
+    /**
+     * Get the voice adapter creator for @jubbio/voice
+     */
+    get voiceAdapterCreator() {
+        return this.client.voice.adapters.get(this.id);
+    }
+    /**
+     * Fetch a member by ID
+     */
+    async fetchMember(userId) {
+        // Check cache first
+        const cached = this.members.get(userId);
+        if (cached)
+            return cached;
+        // Fetch from API
+        const data = await this.client.rest.getMember(this.id, userId);
+        if (!data)
+            throw new Error(`Member ${userId} not found in guild ${this.id}`);
+        const member = this._addMember(data);
+        return member;
+    }
+    /**
+     * Convert to string
+     */
+    toString() {
+        return this.name;
+    }
+    /**
+     * Update guild data
+     */
+    _patch(data) {
+        if (data.name !== undefined)
+            this.name = data.name;
+        if (data.icon !== undefined)
+            this.icon = data.icon;
+        if (data.owner_id !== undefined)
+            this.ownerId = data.owner_id;
+        if (data.unavailable !== undefined)
+            this.unavailable = data.unavailable;
+    }
+    /**
+     * Add a member to cache
+     */
+    _addMember(data) {
+        const member = new GuildMember(this.client, this, data);
+        this.members.set(member.id, member);
+        return member;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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