@jubbio/core 1.3.1 → 1.3.2

package/dist/esm/utils/DataResolver.js

@@ -0,0 +1,142 @@
+/**
+ * Data resolver utilities for handling various data types
+ */
+import { readFile } from 'fs/promises';
+import { basename } from 'path';
+/**
+ * Resolves various data types to usable formats
+ */
+export class DataResolver {
+    /**
+     * Resolves a BufferResolvable to a Buffer
+     * @param resource The resource to resolve
+     */
+    static async resolveBuffer(resource) {
+        if (Buffer.isBuffer(resource))
+            return resource;
+        if (typeof resource === 'string') {
+            // Check if it's a file path
+            if (resource.startsWith('/') || resource.startsWith('./') || resource.startsWith('../') || /^[a-zA-Z]:/.test(resource)) {
+                return readFile(resource);
+            }
+            // Check if it's a URL
+            if (resource.startsWith('http://') || resource.startsWith('https://')) {
+                const response = await fetch(resource);
+                const arrayBuffer = await response.arrayBuffer();
+                return Buffer.from(arrayBuffer);
+            }
+            // Check if it's base64
+            if (resource.startsWith('data:')) {
+                const base64Data = resource.split(',')[1];
+                return Buffer.from(base64Data, 'base64');
+            }
+            // Assume it's a file path
+            return readFile(resource);
+        }
+        throw new TypeError('Invalid resource type');
+    }
+    /**
+     * Resolves a Base64Resolvable to a base64 string
+     * @param resource The resource to resolve
+     * @param mimeType The MIME type for the data URI
+     */
+    static async resolveBase64(resource, mimeType = 'image/png') {
+        const buffer = await this.resolveBuffer(resource);
+        return `data:${mimeType};base64,${buffer.toString('base64')}`;
+    }
+    /**
+     * Resolves a file to a name and buffer
+     * @param resource The file resource
+     */
+    static async resolveFile(resource) {
+        if (typeof resource === 'object' && 'attachment' in resource) {
+            const buffer = await this.resolveBuffer(resource.attachment);
+            const name = resource.name ?? 'file';
+            return { name, data: buffer };
+        }
+        const buffer = await this.resolveBuffer(resource);
+        const name = typeof resource === 'string' ? basename(resource) : 'file';
+        return { name, data: buffer };
+    }
+    /**
+     * Resolves multiple files
+     * @param resources The file resources
+     */
+    static async resolveFiles(resources) {
+        return Promise.all(resources.map(r => this.resolveFile(r)));
+    }
+    /**
+     * Resolves a color to a number
+     * @param color The color to resolve
+     */
+    static resolveColor(color) {
+        if (color === null)
+            return null;
+        if (typeof color === 'number') {
+            if (color < 0 || color > 0xFFFFFF)
+                throw new RangeError('Color must be between 0 and 16777215');
+            return color;
+        }
+        if (typeof color === 'string') {
+            if (color.startsWith('#')) {
+                return parseInt(color.slice(1), 16);
+            }
+            // Named colors
+            const namedColors = {
+                default: 0x000000,
+                white: 0xFFFFFF,
+                aqua: 0x1ABC9C,
+                green: 0x57F287,
+                blue: 0x3498DB,
+                yellow: 0xFEE75C,
+                purple: 0x9B59B6,
+                fuchsia: 0xEB459E,
+                gold: 0xF1C40F,
+                orange: 0xE67E22,
+                red: 0xED4245,
+                grey: 0x95A5A6,
+                navy: 0x34495E,
+                blurple: 0x5865F2,
+            };
+            const lower = color.toLowerCase();
+            if (lower in namedColors)
+                return namedColors[lower];
+            return parseInt(color, 16);
+        }
+        if (Array.isArray(color)) {
+            return (color[0] << 16) + (color[1] << 8) + color[2];
+        }
+        throw new TypeError('Invalid color type');
+    }
+    /**
+     * Resolves a string to a snowflake ID
+     * @param value The value to resolve
+     */
+    static resolveSnowflake(value) {
+        if (typeof value === 'object' && 'id' in value) {
+            return String(value.id);
+        }
+        return String(value);
+    }
+    /**
+     * Resolves an image to a base64 data URI
+     * @param image The image to resolve
+     */
+    static async resolveImage(image) {
+        const buffer = await this.resolveBuffer(image);
+        // Detect MIME type from magic bytes
+        let mimeType = 'image/png';
+        if (buffer[0] === 0xFF && buffer[1] === 0xD8) {
+            mimeType = 'image/jpeg';
+        }
+        else if (buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46) {
+            mimeType = 'image/gif';
+        }
+        else if (buffer[0] === 0x52 && buffer[1] === 0x49 && buffer[2] === 0x46 && buffer[3] === 0x46) {
+            mimeType = 'image/webp';
+        }
+        return `data:${mimeType};base64,${buffer.toString('base64')}`;
+    }
+}
+export default DataResolver;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DataResolver.js","sourceRoot":"","sources":["../../../src/utils/DataResolver.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Data resolver utilities for handling various data types\n */\n\nimport { readFile } from 'fs/promises';\nimport { basename } from 'path';\n\nexport type BufferResolvable = Buffer | string;\nexport type Base64Resolvable = Buffer | string;\n\n/**\n * Resolves various data types to usable formats\n */\nexport class DataResolver {\n  /**\n   * Resolves a BufferResolvable to a Buffer\n   * @param resource The resource to resolve\n   */\n  static async resolveBuffer(resource: BufferResolvable): Promise<Buffer> {\n    if (Buffer.isBuffer(resource)) return resource;\n    \n    if (typeof resource === 'string') {\n      // Check if it's a file path\n      if (resource.startsWith('/') || resource.startsWith('./') || resource.startsWith('../') || /^[a-zA-Z]:/.test(resource)) {\n        return readFile(resource);\n      }\n      \n      // Check if it's a URL\n      if (resource.startsWith('http://') || resource.startsWith('https://')) {\n        const response = await fetch(resource);\n        const arrayBuffer = await response.arrayBuffer();\n        return Buffer.from(arrayBuffer);\n      }\n      \n      // Check if it's base64\n      if (resource.startsWith('data:')) {\n        const base64Data = resource.split(',')[1];\n        return Buffer.from(base64Data, 'base64');\n      }\n      \n      // Assume it's a file path\n      return readFile(resource);\n    }\n    \n    throw new TypeError('Invalid resource type');\n  }\n\n  /**\n   * Resolves a Base64Resolvable to a base64 string\n   * @param resource The resource to resolve\n   * @param mimeType The MIME type for the data URI\n   */\n  static async resolveBase64(resource: Base64Resolvable, mimeType = 'image/png'): Promise<string> {\n    const buffer = await this.resolveBuffer(resource);\n    return `data:${mimeType};base64,${buffer.toString('base64')}`;\n  }\n\n  /**\n   * Resolves a file to a name and buffer\n   * @param resource The file resource\n   */\n  static async resolveFile(resource: BufferResolvable | { name?: string; attachment: BufferResolvable }): Promise<{ name: string; data: Buffer }> {\n    if (typeof resource === 'object' && 'attachment' in resource) {\n      const buffer = await this.resolveBuffer(resource.attachment);\n      const name = resource.name ?? 'file';\n      return { name, data: buffer };\n    }\n    \n    const buffer = await this.resolveBuffer(resource);\n    const name = typeof resource === 'string' ? basename(resource) : 'file';\n    return { name, data: buffer };\n  }\n\n  /**\n   * Resolves multiple files\n   * @param resources The file resources\n   */\n  static async resolveFiles(resources: (BufferResolvable | { name?: string; attachment: BufferResolvable })[]): Promise<{ name: string; data: Buffer }[]> {\n    return Promise.all(resources.map(r => this.resolveFile(r)));\n  }\n\n  /**\n   * Resolves a color to a number\n   * @param color The color to resolve\n   */\n  static resolveColor(color: number | string | [number, number, number] | null): number | null {\n    if (color === null) return null;\n    \n    if (typeof color === 'number') {\n      if (color < 0 || color > 0xFFFFFF) throw new RangeError('Color must be between 0 and 16777215');\n      return color;\n    }\n    \n    if (typeof color === 'string') {\n      if (color.startsWith('#')) {\n        return parseInt(color.slice(1), 16);\n      }\n      // Named colors\n      const namedColors: Record<string, number> = {\n        default: 0x000000,\n        white: 0xFFFFFF,\n        aqua: 0x1ABC9C,\n        green: 0x57F287,\n        blue: 0x3498DB,\n        yellow: 0xFEE75C,\n        purple: 0x9B59B6,\n        fuchsia: 0xEB459E,\n        gold: 0xF1C40F,\n        orange: 0xE67E22,\n        red: 0xED4245,\n        grey: 0x95A5A6,\n        navy: 0x34495E,\n        blurple: 0x5865F2,\n      };\n      const lower = color.toLowerCase();\n      if (lower in namedColors) return namedColors[lower];\n      return parseInt(color, 16);\n    }\n    \n    if (Array.isArray(color)) {\n      return (color[0] << 16) + (color[1] << 8) + color[2];\n    }\n    \n    throw new TypeError('Invalid color type');\n  }\n\n  /**\n   * Resolves a string to a snowflake ID\n   * @param value The value to resolve\n   */\n  static resolveSnowflake(value: string | number | { id: string | number }): string {\n    if (typeof value === 'object' && 'id' in value) {\n      return String(value.id);\n    }\n    return String(value);\n  }\n\n  /**\n   * Resolves an image to a base64 data URI\n   * @param image The image to resolve\n   */\n  static async resolveImage(image: BufferResolvable): Promise<string> {\n    const buffer = await this.resolveBuffer(image);\n    \n    // Detect MIME type from magic bytes\n    let mimeType = 'image/png';\n    if (buffer[0] === 0xFF && buffer[1] === 0xD8) {\n      mimeType = 'image/jpeg';\n    } else if (buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46) {\n      mimeType = 'image/gif';\n    } else if (buffer[0] === 0x52 && buffer[1] === 0x49 && buffer[2] === 0x46 && buffer[3] === 0x46) {\n      mimeType = 'image/webp';\n    }\n    \n    return `data:${mimeType};base64,${buffer.toString('base64')}`;\n  }\n}\n\nexport default DataResolver;\n"]}

package/dist/esm/utils/Formatters.js

@@ -0,0 +1,191 @@
+/**
+ * Formatters for markdown and mentions
+ */
+/**
+ * Formats a user mention
+ * @param userId The user ID to mention
+ */
+export function userMention(userId) {
+    return `<@${userId}>`;
+}
+/**
+ * Formats a channel mention
+ * @param channelId The channel ID to mention
+ */
+export function channelMention(channelId) {
+    return `<#${channelId}>`;
+}
+/**
+ * Formats a role mention
+ * @param roleId The role ID to mention
+ */
+export function roleMention(roleId) {
+    return `<@&${roleId}>`;
+}
+/**
+ * Formats a custom emoji
+ * @param emojiId The emoji ID
+ * @param name The emoji name
+ * @param animated Whether the emoji is animated
+ */
+export function formatEmoji(emojiId, name, animated = false) {
+    return `<${animated ? 'a' : ''}:${name}:${emojiId}>`;
+}
+/**
+ * Formats text as bold
+ * @param text The text to format
+ */
+export function bold(text) {
+    return `**${text}**`;
+}
+/**
+ * Formats text as italic
+ * @param text The text to format
+ */
+export function italic(text) {
+    return `*${text}*`;
+}
+/**
+ * Formats text as underline
+ * @param text The text to format
+ */
+export function underline(text) {
+    return `__${text}__`;
+}
+/**
+ * Formats text as strikethrough
+ * @param text The text to format
+ */
+export function strikethrough(text) {
+    return `~~${text}~~`;
+}
+/**
+ * Formats text as spoiler
+ * @param text The text to format
+ */
+export function spoiler(text) {
+    return `||${text}||`;
+}
+/**
+ * Formats text as inline code
+ * @param text The text to format
+ */
+export function inlineCode(text) {
+    return `\`${text}\``;
+}
+/**
+ * Formats text as a code block
+ * @param text The text to format
+ * @param language The language for syntax highlighting
+ */
+export function codeBlock(text, language) {
+    return `\`\`\`${language ?? ''}\n${text}\n\`\`\``;
+}
+/**
+ * Formats text as a block quote
+ * @param text The text to format
+ */
+export function blockQuote(text) {
+    return `>>> ${text}`;
+}
+/**
+ * Formats text as a single-line quote
+ * @param text The text to format
+ */
+export function quote(text) {
+    return `> ${text}`;
+}
+/**
+ * Formats a URL as a hyperlink
+ * @param text The text to display
+ * @param url The URL to link to
+ * @param title Optional title for the link
+ */
+export function hyperlink(text, url, title) {
+    return title ? `[${text}](${url} "${title}")` : `[${text}](${url})`;
+}
+/**
+ * Formats a URL to hide the embed
+ * @param url The URL to format
+ */
+export function hideLinkEmbed(url) {
+    return `<${url}>`;
+}
+/**
+ * Time format styles
+ */
+export var TimestampStyles;
+(function (TimestampStyles) {
+    /** Short time format (e.g., 16:20) */
+    TimestampStyles["ShortTime"] = "t";
+    /** Long time format (e.g., 16:20:30) */
+    TimestampStyles["LongTime"] = "T";
+    /** Short date format (e.g., 20/04/2021) */
+    TimestampStyles["ShortDate"] = "d";
+    /** Long date format (e.g., 20 April 2021) */
+    TimestampStyles["LongDate"] = "D";
+    /** Short date/time format (e.g., 20 April 2021 16:20) */
+    TimestampStyles["ShortDateTime"] = "f";
+    /** Long date/time format (e.g., Tuesday, 20 April 2021 16:20) */
+    TimestampStyles["LongDateTime"] = "F";
+    /** Relative time format (e.g., 2 months ago) */
+    TimestampStyles["RelativeTime"] = "R";
+})(TimestampStyles || (TimestampStyles = {}));
+/**
+ * Formats a timestamp
+ * @param timestamp The timestamp (Date, number in ms, or seconds)
+ * @param style The style to use
+ */
+export function time(timestamp, style) {
+    const seconds = timestamp instanceof Date
+        ? Math.floor(timestamp.getTime() / 1000)
+        : typeof timestamp === 'number' && timestamp > 1e12
+            ? Math.floor(timestamp / 1000)
+            : timestamp;
+    return style ? `<t:${seconds}:${style}>` : `<t:${seconds}>`;
+}
+/**
+ * Formats a heading (H1)
+ * @param text The text to format
+ */
+export function heading(text, level = 1) {
+    return `${'#'.repeat(level)} ${text}`;
+}
+/**
+ * Formats an unordered list
+ * @param items The items to list
+ */
+export function unorderedList(items) {
+    return items.map(item => `- ${item}`).join('\n');
+}
+/**
+ * Formats an ordered list
+ * @param items The items to list
+ */
+export function orderedList(items) {
+    return items.map((item, i) => `${i + 1}. ${item}`).join('\n');
+}
+// Export all formatters as a namespace too (DJS compatibility)
+export const Formatters = {
+    userMention,
+    channelMention,
+    roleMention,
+    formatEmoji,
+    bold,
+    italic,
+    underline,
+    strikethrough,
+    spoiler,
+    inlineCode,
+    codeBlock,
+    blockQuote,
+    quote,
+    hyperlink,
+    hideLinkEmbed,
+    time,
+    heading,
+    unorderedList,
+    orderedList,
+    TimestampStyles,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Formatters.js","sourceRoot":"","sources":["../../../src/utils/Formatters.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Formatters for markdown and mentions\n */\n\n/**\n * Formats a user mention\n * @param userId The user ID to mention\n */\nexport function userMention(userId: string | number): string {\n  return `<@${userId}>`;\n}\n\n/**\n * Formats a channel mention\n * @param channelId The channel ID to mention\n */\nexport function channelMention(channelId: string | number): string {\n  return `<#${channelId}>`;\n}\n\n/**\n * Formats a role mention\n * @param roleId The role ID to mention\n */\nexport function roleMention(roleId: string | number): string {\n  return `<@&${roleId}>`;\n}\n\n/**\n * Formats a custom emoji\n * @param emojiId The emoji ID\n * @param name The emoji name\n * @param animated Whether the emoji is animated\n */\nexport function formatEmoji(emojiId: string | number, name: string, animated = false): string {\n  return `<${animated ? 'a' : ''}:${name}:${emojiId}>`;\n}\n\n/**\n * Formats text as bold\n * @param text The text to format\n */\nexport function bold(text: string): string {\n  return `**${text}**`;\n}\n\n/**\n * Formats text as italic\n * @param text The text to format\n */\nexport function italic(text: string): string {\n  return `*${text}*`;\n}\n\n/**\n * Formats text as underline\n * @param text The text to format\n */\nexport function underline(text: string): string {\n  return `__${text}__`;\n}\n\n/**\n * Formats text as strikethrough\n * @param text The text to format\n */\nexport function strikethrough(text: string): string {\n  return `~~${text}~~`;\n}\n\n/**\n * Formats text as spoiler\n * @param text The text to format\n */\nexport function spoiler(text: string): string {\n  return `||${text}||`;\n}\n\n/**\n * Formats text as inline code\n * @param text The text to format\n */\nexport function inlineCode(text: string): string {\n  return `\\`${text}\\``;\n}\n\n/**\n * Formats text as a code block\n * @param text The text to format\n * @param language The language for syntax highlighting\n */\nexport function codeBlock(text: string, language?: string): string {\n  return `\\`\\`\\`${language ?? ''}\\n${text}\\n\\`\\`\\``;\n}\n\n/**\n * Formats text as a block quote\n * @param text The text to format\n */\nexport function blockQuote(text: string): string {\n  return `>>> ${text}`;\n}\n\n/**\n * Formats text as a single-line quote\n * @param text The text to format\n */\nexport function quote(text: string): string {\n  return `> ${text}`;\n}\n\n/**\n * Formats a URL as a hyperlink\n * @param text The text to display\n * @param url The URL to link to\n * @param title Optional title for the link\n */\nexport function hyperlink(text: string, url: string, title?: string): string {\n  return title ? `[${text}](${url} \"${title}\")` : `[${text}](${url})`;\n}\n\n/**\n * Formats a URL to hide the embed\n * @param url The URL to format\n */\nexport function hideLinkEmbed(url: string): string {\n  return `<${url}>`;\n}\n\n/**\n * Time format styles\n */\nexport enum TimestampStyles {\n  /** Short time format (e.g., 16:20) */\n  ShortTime = 't',\n  /** Long time format (e.g., 16:20:30) */\n  LongTime = 'T',\n  /** Short date format (e.g., 20/04/2021) */\n  ShortDate = 'd',\n  /** Long date format (e.g., 20 April 2021) */\n  LongDate = 'D',\n  /** Short date/time format (e.g., 20 April 2021 16:20) */\n  ShortDateTime = 'f',\n  /** Long date/time format (e.g., Tuesday, 20 April 2021 16:20) */\n  LongDateTime = 'F',\n  /** Relative time format (e.g., 2 months ago) */\n  RelativeTime = 'R',\n}\n\n/**\n * Formats a timestamp\n * @param timestamp The timestamp (Date, number in ms, or seconds)\n * @param style The style to use\n */\nexport function time(timestamp: Date | number, style?: TimestampStyles): string {\n  const seconds = timestamp instanceof Date \n    ? Math.floor(timestamp.getTime() / 1000) \n    : typeof timestamp === 'number' && timestamp > 1e12 \n      ? Math.floor(timestamp / 1000) \n      : timestamp;\n  \n  return style ? `<t:${seconds}:${style}>` : `<t:${seconds}>`;\n}\n\n/**\n * Formats a heading (H1)\n * @param text The text to format\n */\nexport function heading(text: string, level: 1 | 2 | 3 = 1): string {\n  return `${'#'.repeat(level)} ${text}`;\n}\n\n/**\n * Formats an unordered list\n * @param items The items to list\n */\nexport function unorderedList(items: string[]): string {\n  return items.map(item => `- ${item}`).join('\\n');\n}\n\n/**\n * Formats an ordered list\n * @param items The items to list\n */\nexport function orderedList(items: string[]): string {\n  return items.map((item, i) => `${i + 1}. ${item}`).join('\\n');\n}\n\n// Export all formatters as a namespace too (DJS compatibility)\nexport const Formatters = {\n  userMention,\n  channelMention,\n  roleMention,\n  formatEmoji,\n  bold,\n  italic,\n  underline,\n  strikethrough,\n  spoiler,\n  inlineCode,\n  codeBlock,\n  blockQuote,\n  quote,\n  hyperlink,\n  hideLinkEmbed,\n  time,\n  heading,\n  unorderedList,\n  orderedList,\n  TimestampStyles,\n};\n"]}

package/dist/esm/utils/IntentsBitField.js

@@ -0,0 +1,93 @@
+/**
+ * Intents BitField for calculating gateway intents
+ */
+import { BitField } from './BitField';
+/**
+ * Gateway Intent Bits
+ */
+export const GatewayIntentBits = {
+    Guilds: 1 << 0,
+    GuildMembers: 1 << 1,
+    GuildModeration: 1 << 2,
+    GuildEmojisAndStickers: 1 << 3,
+    GuildIntegrations: 1 << 4,
+    GuildWebhooks: 1 << 5,
+    GuildInvites: 1 << 6,
+    GuildVoiceStates: 1 << 7,
+    GuildPresences: 1 << 8,
+    GuildMessages: 1 << 9,
+    GuildMessageReactions: 1 << 10,
+    GuildMessageTyping: 1 << 11,
+    DirectMessages: 1 << 12,
+    DirectMessageReactions: 1 << 13,
+    DirectMessageTyping: 1 << 14,
+    MessageContent: 1 << 15,
+    GuildScheduledEvents: 1 << 16,
+    AutoModerationConfiguration: 1 << 20,
+    AutoModerationExecution: 1 << 21,
+};
+/**
+ * All non-privileged intents
+ */
+export const IntentsAll = Object.values(GatewayIntentBits).reduce((all, i) => all | i, 0);
+/**
+ * Privileged intents that require approval
+ */
+export const PrivilegedIntents = GatewayIntentBits.GuildMembers |
+    GatewayIntentBits.GuildPresences |
+    GatewayIntentBits.MessageContent;
+/**
+ * Data structure for gateway intents
+ */
+export class IntentsBitField extends BitField {
+    static Flags = GatewayIntentBits;
+    static DefaultBit = 0;
+    constructor(bits = 0) {
+        super(bits);
+    }
+    /**
+     * Check if any privileged intents are enabled
+     */
+    hasPrivileged() {
+        return this.any(PrivilegedIntents);
+    }
+    /**
+     * Get all privileged intents that are enabled
+     */
+    getPrivileged() {
+        const privileged = [];
+        if (this.has(GatewayIntentBits.GuildMembers))
+            privileged.push('GuildMembers');
+        if (this.has(GatewayIntentBits.GuildPresences))
+            privileged.push('GuildPresences');
+        if (this.has(GatewayIntentBits.MessageContent))
+            privileged.push('MessageContent');
+        return privileged;
+    }
+}
+/**
+ * Calculate intents from an array of intent names or values
+ */
+export function calculateIntents(intents) {
+    return intents.reduce((acc, intent) => {
+        if (typeof intent === 'number')
+            return acc | intent;
+        if (intent in GatewayIntentBits)
+            return acc | GatewayIntentBits[intent];
+        return acc;
+    }, 0);
+}
+/**
+ * Get all intent names from a bitfield value
+ */
+export function resolveIntents(bits) {
+    const names = [];
+    for (const [name, value] of Object.entries(GatewayIntentBits)) {
+        if ((bits & value) === value) {
+            names.push(name);
+        }
+    }
+    return names;
+}
+export default IntentsBitField;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW50ZW50c0JpdEZpZWxkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3V0aWxzL0ludGVudHNCaXRGaWVsZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILE9BQU8sRUFBRSxRQUFRLEVBQXNCLE1BQU0sWUFBWSxDQUFDO0FBTzFEOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0saUJBQWlCLEdBQUc7SUFDL0IsTUFBTSxFQUFFLENBQUMsSUFBSSxDQUFDO0lBQ2QsWUFBWSxFQUFFLENBQUMsSUFBSSxDQUFDO0lBQ3BCLGVBQWUsRUFBRSxDQUFDLElBQUksQ0FBQztJQUN2QixzQkFBc0IsRUFBRSxDQUFDLElBQUksQ0FBQztJQUM5QixpQkFBaUIsRUFBRSxDQUFDLElBQUksQ0FBQztJQUN6QixhQUFhLEVBQUUsQ0FBQyxJQUFJLENBQUM7SUFDckIsWUFBWSxFQUFFLENBQUMsSUFBSSxDQUFDO0lBQ3BCLGdCQUFnQixFQUFFLENBQUMsSUFBSSxDQUFDO0lBQ3hCLGNBQWMsRUFBRSxDQUFDLElBQUksQ0FBQztJQUN0QixhQUFhLEVBQUUsQ0FBQyxJQUFJLENBQUM7SUFDckIscUJBQXFCLEVBQUUsQ0FBQyxJQUFJLEVBQUU7SUFDOUIsa0JBQWtCLEVBQUUsQ0FBQyxJQUFJLEVBQUU7SUFDM0IsY0FBYyxFQUFFLENBQUMsSUFBSSxFQUFFO0lBQ3ZCLHNCQUFzQixFQUFFLENBQUMsSUFBSSxFQUFFO0lBQy9CLG1CQUFtQixFQUFFLENBQUMsSUFBSSxFQUFFO0lBQzVCLGNBQWMsRUFBRSxDQUFDLElBQUksRUFBRTtJQUN2QixvQkFBb0IsRUFBRSxDQUFDLElBQUksRUFBRTtJQUM3QiwyQkFBMkIsRUFBRSxDQUFDLElBQUksRUFBRTtJQUNwQyx1QkFBdUIsRUFBRSxDQUFDLElBQUksRUFBRTtDQUN4QixDQUFDO0FBRVg7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxVQUFVLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLEdBQUcsRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUFDLEdBQUcsR0FBRyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUM7QUFFMUY7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FDNUIsaUJBQWlCLENBQUMsWUFBWTtJQUM5QixpQkFBaUIsQ0FBQyxjQUFjO0lBQ2hDLGlCQUFpQixDQUFDLGNBQWMsQ0FBQztBQUVuQzs7R0FFRztBQUNILE1BQU0sT0FBTyxlQUFnQixTQUFRLFFBQW1DO0lBQ3RFLE1BQU0sQ0FBQyxLQUFLLEdBQUcsaUJBQWlCLENBQUM7SUFDakMsTUFBTSxDQUFDLFVBQVUsR0FBRyxDQUFDLENBQUM7SUFFdEIsWUFBWSxPQUFzRCxDQUFDO1FBQ2pFLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUNkLENBQUM7SUFFRDs7T0FFRztJQUNILGFBQWE7UUFDWCxPQUFPLElBQUksQ0FBQyxHQUFHLENBQUMsaUJBQWlCLENBQUMsQ0FBQztJQUNyQyxDQUFDO0lBRUQ7O09BRUc7SUFDSCxhQUFhO1FBQ1gsTUFBTSxVQUFVLEdBQXdCLEVBQUUsQ0FBQztRQUMzQyxJQUFJLElBQUksQ0FBQyxHQUFHLENBQUMsaUJBQWlCLENBQUMsWUFBWSxDQUFDO1lBQUUsVUFBVSxDQUFDLElBQUksQ0FBQyxjQUFjLENBQUMsQ0FBQztRQUM5RSxJQUFJLElBQUksQ0FBQyxHQUFHLENBQUMsaUJBQWlCLENBQUMsY0FBYyxDQUFDO1lBQUUsVUFBVSxDQUFDLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO1FBQ2xGLElBQUksSUFBSSxDQUFDLEdBQUcsQ0FBQyxpQkFBaUIsQ0FBQyxjQUFjLENBQUM7WUFBRSxVQUFVLENBQUMsSUFBSSxDQUFDLGdCQUFnQixDQUFDLENBQUM7UUFDbEYsT0FBTyxVQUFVLENBQUM7SUFDcEIsQ0FBQzs7QUFHSDs7R0FFRztBQUNILE1BQU0sVUFBVSxnQkFBZ0IsQ0FBQyxPQUF1QztJQUN0RSxPQUFPLE9BQU8sQ0FBQyxNQUFNLENBQVMsQ0FBQyxHQUFHLEVBQUUsTUFBTSxFQUFFLEVBQUU7UUFDNUMsSUFBSSxPQUFPLE1BQU0sS0FBSyxRQUFRO1lBQUUsT0FBTyxHQUFHLEdBQUcsTUFBTSxDQUFDO1FBQ3BELElBQUksTUFBTSxJQUFJLGlCQUFpQjtZQUFFLE9BQU8sR0FBRyxHQUFHLGlCQUFpQixDQUFDLE1BQXdDLENBQUMsQ0FBQztRQUMxRyxPQUFPLEdBQUcsQ0FBQztJQUNiLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQztBQUNSLENBQUM7QUFFRDs7R0FFRztBQUNILE1BQU0sVUFBVSxjQUFjLENBQUMsSUFBWTtJQUN6QyxNQUFNLEtBQUssR0FBd0IsRUFBRSxDQUFDO0lBQ3RDLEtBQUssTUFBTSxDQUFDLElBQUksRUFBRSxLQUFLLENBQUMsSUFBSSxNQUFNLENBQUMsT0FBTyxDQUFDLGlCQUFpQixDQUFDLEVBQUUsQ0FBQztRQUM5RCxJQUFJLENBQUMsSUFBSSxHQUFHLEtBQUssQ0FBQyxLQUFLLEtBQUssRUFBRSxDQUFDO1lBQzdCLEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBeUIsQ0FBQyxDQUFDO1FBQ3hDLENBQUM7SUFDSCxDQUFDO0lBQ0QsT0FBTyxLQUFLLENBQUM7QUFDZixDQUFDO0FBRUQsZUFBZSxlQUFlLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEludGVudHMgQml0RmllbGQgZm9yIGNhbGN1bGF0aW5nIGdhdGV3YXkgaW50ZW50c1xuICovXG5cbmltcG9ydCB7IEJpdEZpZWxkLCBCaXRGaWVsZFJlc29sdmFibGUgfSBmcm9tICcuL0JpdEZpZWxkJztcblxuLyoqXG4gKiBJbnRlbnQgZmxhZyBuYW1lc1xuICovXG5leHBvcnQgdHlwZSBJbnRlbnRGbGFnc1N0cmluZyA9IGtleW9mIHR5cGVvZiBJbnRlbnRzQml0RmllbGQuRmxhZ3M7XG5cbi8qKlxuICogR2F0ZXdheSBJbnRlbnQgQml0c1xuICovXG5leHBvcnQgY29uc3QgR2F0ZXdheUludGVudEJpdHMgPSB7XG4gIEd1aWxkczogMSA8PCAwLFxuICBHdWlsZE1lbWJlcnM6IDEgPDwgMSxcbiAgR3VpbGRNb2RlcmF0aW9uOiAxIDw8IDIsXG4gIEd1aWxkRW1vamlzQW5kU3RpY2tlcnM6IDEgPDwgMyxcbiAgR3VpbGRJbnRlZ3JhdGlvbnM6IDEgPDwgNCxcbiAgR3VpbGRXZWJob29rczogMSA8PCA1LFxuICBHdWlsZEludml0ZXM6IDEgPDwgNixcbiAgR3VpbGRWb2ljZVN0YXRlczogMSA8PCA3LFxuICBHdWlsZFByZXNlbmNlczogMSA8PCA4LFxuICBHdWlsZE1lc3NhZ2VzOiAxIDw8IDksXG4gIEd1aWxkTWVzc2FnZVJlYWN0aW9uczogMSA8PCAxMCxcbiAgR3VpbGRNZXNzYWdlVHlwaW5nOiAxIDw8IDExLFxuICBEaXJlY3RNZXNzYWdlczogMSA8PCAxMixcbiAgRGlyZWN0TWVzc2FnZVJlYWN0aW9uczogMSA8PCAxMyxcbiAgRGlyZWN0TWVzc2FnZVR5cGluZzogMSA8PCAxNCxcbiAgTWVzc2FnZUNvbnRlbnQ6IDEgPDwgMTUsXG4gIEd1aWxkU2NoZWR1bGVkRXZlbnRzOiAxIDw8IDE2LFxuICBBdXRvTW9kZXJhdGlvbkNvbmZpZ3VyYXRpb246IDEgPDwgMjAsXG4gIEF1dG9Nb2RlcmF0aW9uRXhlY3V0aW9uOiAxIDw8IDIxLFxufSBhcyBjb25zdDtcblxuLyoqXG4gKiBBbGwgbm9uLXByaXZpbGVnZWQgaW50ZW50c1xuICovXG5leHBvcnQgY29uc3QgSW50ZW50c0FsbCA9IE9iamVjdC52YWx1ZXMoR2F0ZXdheUludGVudEJpdHMpLnJlZHVjZSgoYWxsLCBpKSA9PiBhbGwgfCBpLCAwKTtcblxuLyoqXG4gKiBQcml2aWxlZ2VkIGludGVudHMgdGhhdCByZXF1aXJlIGFwcHJvdmFsXG4gKi9cbmV4cG9ydCBjb25zdCBQcml2aWxlZ2VkSW50ZW50cyA9IFxuICBHYXRld2F5SW50ZW50Qml0cy5HdWlsZE1lbWJlcnMgfCBcbiAgR2F0ZXdheUludGVudEJpdHMuR3VpbGRQcmVzZW5jZXMgfCBcbiAgR2F0ZXdheUludGVudEJpdHMuTWVzc2FnZUNvbnRlbnQ7XG5cbi8qKlxuICogRGF0YSBzdHJ1Y3R1cmUgZm9yIGdhdGV3YXkgaW50ZW50c1xuICovXG5leHBvcnQgY2xhc3MgSW50ZW50c0JpdEZpZWxkIGV4dGVuZHMgQml0RmllbGQ8SW50ZW50RmxhZ3NTdHJpbmcsIG51bWJlcj4ge1xuICBzdGF0aWMgRmxhZ3MgPSBHYXRld2F5SW50ZW50Qml0cztcbiAgc3RhdGljIERlZmF1bHRCaXQgPSAwO1xuXG4gIGNvbnN0cnVjdG9yKGJpdHM6IEJpdEZpZWxkUmVzb2x2YWJsZTxJbnRlbnRGbGFnc1N0cmluZywgbnVtYmVyPiA9IDApIHtcbiAgICBzdXBlcihiaXRzKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBDaGVjayBpZiBhbnkgcHJpdmlsZWdlZCBpbnRlbnRzIGFyZSBlbmFibGVkXG4gICAqL1xuICBoYXNQcml2aWxlZ2VkKCk6IGJvb2xlYW4ge1xuICAgIHJldHVybiB0aGlzLmFueShQcml2aWxlZ2VkSW50ZW50cyk7XG4gIH1cblxuICAvKipcbiAgICogR2V0IGFsbCBwcml2aWxlZ2VkIGludGVudHMgdGhhdCBhcmUgZW5hYmxlZFxuICAgKi9cbiAgZ2V0UHJpdmlsZWdlZCgpOiBJbnRlbnRGbGFnc1N0cmluZ1tdIHtcbiAgICBjb25zdCBwcml2aWxlZ2VkOiBJbnRlbnRGbGFnc1N0cmluZ1tdID0gW107XG4gICAgaWYgKHRoaXMuaGFzKEdhdGV3YXlJbnRlbnRCaXRzLkd1aWxkTWVtYmVycykpIHByaXZpbGVnZWQucHVzaCgnR3VpbGRNZW1iZXJzJyk7XG4gICAgaWYgKHRoaXMuaGFzKEdhdGV3YXlJbnRlbnRCaXRzLkd1aWxkUHJlc2VuY2VzKSkgcHJpdmlsZWdlZC5wdXNoKCdHdWlsZFByZXNlbmNlcycpO1xuICAgIGlmICh0aGlzLmhhcyhHYXRld2F5SW50ZW50Qml0cy5NZXNzYWdlQ29udGVudCkpIHByaXZpbGVnZWQucHVzaCgnTWVzc2FnZUNvbnRlbnQnKTtcbiAgICByZXR1cm4gcHJpdmlsZWdlZDtcbiAgfVxufVxuXG4vKipcbiAqIENhbGN1bGF0ZSBpbnRlbnRzIGZyb20gYW4gYXJyYXkgb2YgaW50ZW50IG5hbWVzIG9yIHZhbHVlc1xuICovXG5leHBvcnQgZnVuY3Rpb24gY2FsY3VsYXRlSW50ZW50cyhpbnRlbnRzOiAoSW50ZW50RmxhZ3NTdHJpbmcgfCBudW1iZXIpW10pOiBudW1iZXIge1xuICByZXR1cm4gaW50ZW50cy5yZWR1Y2U8bnVtYmVyPigoYWNjLCBpbnRlbnQpID0+IHtcbiAgICBpZiAodHlwZW9mIGludGVudCA9PT0gJ251bWJlcicpIHJldHVybiBhY2MgfCBpbnRlbnQ7XG4gICAgaWYgKGludGVudCBpbiBHYXRld2F5SW50ZW50Qml0cykgcmV0dXJuIGFjYyB8IEdhdGV3YXlJbnRlbnRCaXRzW2ludGVudCBhcyBrZXlvZiB0eXBlb2YgR2F0ZXdheUludGVudEJpdHNdO1xuICAgIHJldHVybiBhY2M7XG4gIH0sIDApO1xufVxuXG4vKipcbiAqIEdldCBhbGwgaW50ZW50IG5hbWVzIGZyb20gYSBiaXRmaWVsZCB2YWx1ZVxuICovXG5leHBvcnQgZnVuY3Rpb24gcmVzb2x2ZUludGVudHMoYml0czogbnVtYmVyKTogSW50ZW50RmxhZ3NTdHJpbmdbXSB7XG4gIGNvbnN0IG5hbWVzOiBJbnRlbnRGbGFnc1N0cmluZ1tdID0gW107XG4gIGZvciAoY29uc3QgW25hbWUsIHZhbHVlXSBvZiBPYmplY3QuZW50cmllcyhHYXRld2F5SW50ZW50Qml0cykpIHtcbiAgICBpZiAoKGJpdHMgJiB2YWx1ZSkgPT09IHZhbHVlKSB7XG4gICAgICBuYW1lcy5wdXNoKG5hbWUgYXMgSW50ZW50RmxhZ3NTdHJpbmcpO1xuICAgIH1cbiAgfVxuICByZXR1cm4gbmFtZXM7XG59XG5cbmV4cG9ydCBkZWZhdWx0IEludGVudHNCaXRGaWVsZDtcbiJdfQ==

package/dist/esm/utils/Partials.js

@@ -0,0 +1,137 @@
+/**
+ * Partials - Handle uncached/partial data structures
+ */
+/**
+ * Partial types that can be enabled
+ */
+export var Partials;
+(function (Partials) {
+    Partials[Partials["User"] = 0] = "User";
+    Partials[Partials["Channel"] = 1] = "Channel";
+    Partials[Partials["GuildMember"] = 2] = "GuildMember";
+    Partials[Partials["Message"] = 3] = "Message";
+    Partials[Partials["Reaction"] = 4] = "Reaction";
+    Partials[Partials["GuildScheduledEvent"] = 5] = "GuildScheduledEvent";
+})(Partials || (Partials = {}));
+/**
+ * Check if a structure is partial (missing data)
+ */
+export function isPartial(obj) {
+    return obj?.partial === true;
+}
+/**
+ * Create a partial user structure
+ */
+export function createPartialUser(id) {
+    return {
+        id,
+        partial: true,
+        username: null,
+        discriminator: null,
+        avatar: null,
+        bot: null,
+        async fetch() {
+            throw new Error('Cannot fetch partial user without client context');
+        },
+        toString() {
+            return `<@${id}>`;
+        },
+    };
+}
+/**
+ * Create a partial channel structure
+ */
+export function createPartialChannel(id) {
+    return {
+        id,
+        partial: true,
+        type: null,
+        name: null,
+        async fetch() {
+            throw new Error('Cannot fetch partial channel without client context');
+        },
+        toString() {
+            return `<#${id}>`;
+        },
+    };
+}
+/**
+ * Create a partial message structure
+ */
+export function createPartialMessage(id, channelId) {
+    return {
+        id,
+        channelId,
+        partial: true,
+        content: null,
+        author: null,
+        embeds: null,
+        attachments: null,
+        async fetch() {
+            throw new Error('Cannot fetch partial message without client context');
+        },
+        toString() {
+            return `Message(${id})`;
+        },
+    };
+}
+/**
+ * Create a partial guild member structure
+ */
+export function createPartialGuildMember(userId, guildId) {
+    return {
+        id: userId,
+        guildId,
+        partial: true,
+        user: null,
+        nick: null,
+        roles: null,
+        joinedAt: null,
+        async fetch() {
+            throw new Error('Cannot fetch partial member without client context');
+        },
+        toString() {
+            return `<@${userId}>`;
+        },
+    };
+}
+/**
+ * Create a partial reaction structure
+ */
+export function createPartialReaction(messageId, emoji) {
+    return {
+        messageId,
+        emoji,
+        partial: true,
+        count: null,
+        me: null,
+        async fetch() {
+            throw new Error('Cannot fetch partial reaction without client context');
+        },
+        toString() {
+            return emoji;
+        },
+    };
+}
+/**
+ * Make a structure partial-aware with fetch capability
+ */
+export function makePartialAware(structure, client, fetchFn) {
+    return {
+        ...structure,
+        partial: false,
+        async fetch() {
+            const fetched = await fetchFn(structure.id);
+            Object.assign(this, fetched, { partial: false });
+            return this;
+        },
+    };
+}
+/**
+ * Check if partials are enabled for a type
+ */
+export function hasPartial(client, partial) {
+    return client.options?.partials?.includes(partial) ?? false;
+}
+export default Partials;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Partials.js","sourceRoot":"","sources":["../../../src/utils/Partials.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Partials - Handle uncached/partial data structures\n */\n\n/**\n * Partial types that can be enabled\n */\nexport enum Partials {\n  User = 0,\n  Channel = 1,\n  GuildMember = 2,\n  Message = 3,\n  Reaction = 4,\n  GuildScheduledEvent = 5,\n}\n\n/**\n * Check if a structure is partial (missing data)\n */\nexport function isPartial(obj: any): boolean {\n  return obj?.partial === true;\n}\n\n/**\n * Create a partial user structure\n */\nexport function createPartialUser(id: string): PartialUser {\n  return {\n    id,\n    partial: true,\n    username: null,\n    discriminator: null,\n    avatar: null,\n    bot: null,\n    \n    async fetch() {\n      throw new Error('Cannot fetch partial user without client context');\n    },\n    \n    toString() {\n      return `<@${id}>`;\n    },\n  };\n}\n\n/**\n * Create a partial channel structure\n */\nexport function createPartialChannel(id: string): PartialChannel {\n  return {\n    id,\n    partial: true,\n    type: null,\n    name: null,\n    \n    async fetch() {\n      throw new Error('Cannot fetch partial channel without client context');\n    },\n    \n    toString() {\n      return `<#${id}>`;\n    },\n  };\n}\n\n/**\n * Create a partial message structure\n */\nexport function createPartialMessage(id: string, channelId: string): PartialMessage {\n  return {\n    id,\n    channelId,\n    partial: true,\n    content: null,\n    author: null,\n    embeds: null,\n    attachments: null,\n    \n    async fetch() {\n      throw new Error('Cannot fetch partial message without client context');\n    },\n    \n    toString() {\n      return `Message(${id})`;\n    },\n  };\n}\n\n/**\n * Create a partial guild member structure\n */\nexport function createPartialGuildMember(userId: string, guildId: string): PartialGuildMember {\n  return {\n    id: userId,\n    guildId,\n    partial: true,\n    user: null,\n    nick: null,\n    roles: null,\n    joinedAt: null,\n    \n    async fetch() {\n      throw new Error('Cannot fetch partial member without client context');\n    },\n    \n    toString() {\n      return `<@${userId}>`;\n    },\n  };\n}\n\n/**\n * Create a partial reaction structure\n */\nexport function createPartialReaction(messageId: string, emoji: string): PartialReaction {\n  return {\n    messageId,\n    emoji,\n    partial: true,\n    count: null,\n    me: null,\n    \n    async fetch() {\n      throw new Error('Cannot fetch partial reaction without client context');\n    },\n    \n    toString() {\n      return emoji;\n    },\n  };\n}\n\n/**\n * Partial structure types\n */\nexport interface PartialUser {\n  id: string;\n  partial: true;\n  username: string | null;\n  discriminator: string | null;\n  avatar: string | null;\n  bot: boolean | null;\n  fetch(): Promise<any>;\n  toString(): string;\n}\n\nexport interface PartialChannel {\n  id: string;\n  partial: true;\n  type: number | null;\n  name: string | null;\n  fetch(): Promise<any>;\n  toString(): string;\n}\n\nexport interface PartialMessage {\n  id: string;\n  channelId: string;\n  partial: true;\n  content: string | null;\n  author: any | null;\n  embeds: any[] | null;\n  attachments: any[] | null;\n  fetch(): Promise<any>;\n  toString(): string;\n}\n\nexport interface PartialGuildMember {\n  id: string;\n  guildId: string;\n  partial: true;\n  user: any | null;\n  nick: string | null;\n  roles: string[] | null;\n  joinedAt: Date | null;\n  fetch(): Promise<any>;\n  toString(): string;\n}\n\nexport interface PartialReaction {\n  messageId: string;\n  emoji: string;\n  partial: true;\n  count: number | null;\n  me: boolean | null;\n  fetch(): Promise<any>;\n  toString(): string;\n}\n\n/**\n * Make a structure partial-aware with fetch capability\n */\nexport function makePartialAware<T extends { id: string }>(\n  structure: T,\n  client: any,\n  fetchFn: (id: string) => Promise<T>\n): T & { partial: boolean; fetch: () => Promise<T> } {\n  return {\n    ...structure,\n    partial: false,\n    async fetch() {\n      const fetched = await fetchFn(structure.id);\n      Object.assign(this, fetched, { partial: false });\n      return this as T;\n    },\n  };\n}\n\n/**\n * Check if partials are enabled for a type\n */\nexport function hasPartial(client: any, partial: Partials): boolean {\n  return client.options?.partials?.includes(partial) ?? false;\n}\n\nexport default Partials;\n"]}