@jubbio/core 1.0.0

package/dist/utils/Collector.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Collectors for awaiting messages, reactions, and interactions
+ * API compatible with Discord.js Collectors
+ */
+import { EventEmitter } from 'events';
+import { Collection } from './Collection';
+export interface CollectorOptions<T> {
+    /** How long to run the collector for in milliseconds */
+    time?: number;
+    /** How long to wait for the next item in milliseconds */
+    idle?: number;
+    /** Maximum number of items to collect */
+    max?: number;
+    /** Maximum number of items to process */
+    maxProcessed?: number;
+    /** Filter function */
+    filter?: (item: T, collected: Collection<string, T>) => boolean | Promise<boolean>;
+    /** Whether to dispose of items when the collector ends */
+    dispose?: boolean;
+}
+export interface CollectorResetTimerOptions {
+    time?: number;
+    idle?: number;
+}
+/**
+ * Abstract base class for collectors
+ */
+export declare abstract class Collector<K extends string, V> extends EventEmitter {
+    /** The client that instantiated this collector */
+    readonly client: any;
+    /** The items collected */
+    readonly collected: Collection<K, V>;
+    /** Whether the collector has ended */
+    ended: boolean;
+    /** The reason the collector ended */
+    endReason: string | null;
+    /** Filter function */
+    filter: (item: V, collected: Collection<K, V>) => boolean | Promise<boolean>;
+    /** Collector options */
+    options: CollectorOptions<V>;
+    /** Number of items processed */
+    private _processedCount;
+    /** Timeout for time limit */
+    private _timeout;
+    /** Timeout for idle limit */
+    private _idleTimeout;
+    constructor(client: any, options?: CollectorOptions<V>);
+    /**
+     * Handle an item being collected
+     */
+    handleCollect(item: V): Promise<void>;
+    /**
+     * Handle an item being disposed
+     */
+    handleDispose(item: V): void;
+    /**
+     * Get the key for an item
+     */
+    abstract collect(item: V): K | null;
+    /**
+     * Get the key for disposing an item
+     */
+    abstract dispose(item: V): K | null;
+    /**
+     * Stop the collector
+     */
+    stop(reason?: string): void;
+    /**
+     * Reset the collector's timer
+     */
+    resetTimer(options?: CollectorResetTimerOptions): void;
+    /**
+     * Check the end conditions
+     */
+    checkEnd(): boolean;
+    /**
+     * Get the next item
+     */
+    get next(): Promise<V>;
+}
+/**
+ * Message collector options
+ */
+export interface MessageCollectorOptions extends CollectorOptions<any> {
+    /** Channel to collect messages from */
+    channelId?: string;
+}
+/**
+ * Collector for messages
+ */
+export declare class MessageCollector extends Collector<string, any> {
+    readonly channelId: string;
+    private readonly messageHandler;
+    constructor(client: any, channelId: string, options?: MessageCollectorOptions);
+    collect(message: any): string | null;
+    dispose(message: any): string | null;
+}
+/**
+ * Interaction collector options
+ */
+export interface InteractionCollectorOptions extends CollectorOptions<any> {
+    /** Channel to collect interactions from */
+    channelId?: string;
+    /** Guild to collect interactions from */
+    guildId?: string;
+    /** Message to collect interactions from */
+    messageId?: string;
+    /** Interaction types to collect */
+    interactionType?: number | number[];
+    /** Component types to collect */
+    componentType?: number | number[];
+}
+/**
+ * Collector for interactions (buttons, select menus, etc.)
+ */
+export declare class InteractionCollector extends Collector<string, any> {
+    readonly channelId?: string;
+    readonly guildId?: string;
+    readonly messageId?: string;
+    readonly interactionType?: number[];
+    readonly componentType?: number[];
+    private readonly interactionHandler;
+    constructor(client: any, options?: InteractionCollectorOptions);
+    collect(interaction: any): string | null;
+    dispose(interaction: any): string | null;
+}
+/**
+ * Reaction collector options
+ */
+export interface ReactionCollectorOptions extends CollectorOptions<any> {
+    /** Message to collect reactions from */
+    messageId: string;
+}
+/**
+ * Collector for reactions
+ */
+export declare class ReactionCollector extends Collector<string, any> {
+    readonly messageId: string;
+    private readonly reactionHandler;
+    constructor(client: any, messageId: string, options: ReactionCollectorOptions);
+    collect(reaction: any): string | null;
+    dispose(reaction: any): string | null;
+}
+/**
+ * Await messages helper
+ */
+export declare function awaitMessages(client: any, channelId: string, options?: MessageCollectorOptions): Promise<Collection<string, any>>;
+/**
+ * Await reactions helper
+ */
+export declare function awaitReactions(client: any, messageId: string, options: ReactionCollectorOptions): Promise<Collection<string, any>>;
+export default Collector;

package/dist/utils/Collector.js

@@ -0,0 +1,314 @@
+"use strict";
+/**
+ * Collectors for awaiting messages, reactions, and interactions
+ * API compatible with Discord.js Collectors
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReactionCollector = exports.InteractionCollector = exports.MessageCollector = exports.Collector = void 0;
+exports.awaitMessages = awaitMessages;
+exports.awaitReactions = awaitReactions;
+const events_1 = require("events");
+const Collection_1 = require("./Collection");
+/**
+ * Abstract base class for collectors
+ */
+class Collector extends events_1.EventEmitter {
+    /** The client that instantiated this collector */
+    client;
+    /** The items collected */
+    collected = new Collection_1.Collection();
+    /** Whether the collector has ended */
+    ended = false;
+    /** The reason the collector ended */
+    endReason = null;
+    /** Filter function */
+    filter;
+    /** Collector options */
+    options;
+    /** Number of items processed */
+    _processedCount = 0;
+    /** Timeout for time limit */
+    _timeout = null;
+    /** Timeout for idle limit */
+    _idleTimeout = null;
+    constructor(client, options = {}) {
+        super();
+        this.client = client;
+        this.options = options;
+        this.filter = options.filter ?? (() => true);
+        this.handleCollect = this.handleCollect.bind(this);
+        this.handleDispose = this.handleDispose.bind(this);
+        if (options.time) {
+            this._timeout = setTimeout(() => this.stop('time'), options.time);
+        }
+        if (options.idle) {
+            this._idleTimeout = setTimeout(() => this.stop('idle'), options.idle);
+        }
+    }
+    /**
+     * Handle an item being collected
+     */
+    async handleCollect(item) {
+        if (this.ended)
+            return;
+        this._processedCount++;
+        const filterResult = await this.filter(item, this.collected);
+        if (!filterResult)
+            return;
+        const key = this.collect(item);
+        if (key === null)
+            return;
+        this.collected.set(key, item);
+        this.emit('collect', item);
+        // Reset idle timer
+        if (this._idleTimeout) {
+            clearTimeout(this._idleTimeout);
+            this._idleTimeout = setTimeout(() => this.stop('idle'), this.options.idle);
+        }
+        // Check limits
+        if (this.options.max && this.collected.size >= this.options.max) {
+            this.stop('limit');
+        }
+        if (this.options.maxProcessed && this._processedCount >= this.options.maxProcessed) {
+            this.stop('processedLimit');
+        }
+    }
+    /**
+     * Handle an item being disposed
+     */
+    handleDispose(item) {
+        if (!this.options.dispose)
+            return;
+        const key = this.dispose(item);
+        if (key === null)
+            return;
+        if (this.collected.has(key)) {
+            this.collected.delete(key);
+            this.emit('dispose', item);
+        }
+    }
+    /**
+     * Stop the collector
+     */
+    stop(reason = 'user') {
+        if (this.ended)
+            return;
+        this.ended = true;
+        this.endReason = reason;
+        if (this._timeout) {
+            clearTimeout(this._timeout);
+            this._timeout = null;
+        }
+        if (this._idleTimeout) {
+            clearTimeout(this._idleTimeout);
+            this._idleTimeout = null;
+        }
+        this.emit('end', this.collected, reason);
+    }
+    /**
+     * Reset the collector's timer
+     */
+    resetTimer(options = {}) {
+        if (this._timeout) {
+            clearTimeout(this._timeout);
+            this._timeout = null;
+        }
+        if (this._idleTimeout) {
+            clearTimeout(this._idleTimeout);
+            this._idleTimeout = null;
+        }
+        if (options.time ?? this.options.time) {
+            this._timeout = setTimeout(() => this.stop('time'), options.time ?? this.options.time);
+        }
+        if (options.idle ?? this.options.idle) {
+            this._idleTimeout = setTimeout(() => this.stop('idle'), options.idle ?? this.options.idle);
+        }
+    }
+    /**
+     * Check the end conditions
+     */
+    checkEnd() {
+        const reason = this.endReason;
+        if (reason) {
+            this.stop(reason);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get the next item
+     */
+    get next() {
+        return new Promise((resolve, reject) => {
+            if (this.ended) {
+                reject(new Error('Collector has ended'));
+                return;
+            }
+            const cleanup = () => {
+                this.removeListener('collect', onCollect);
+                this.removeListener('end', onEnd);
+            };
+            const onCollect = (item) => {
+                cleanup();
+                resolve(item);
+            };
+            const onEnd = () => {
+                cleanup();
+                reject(new Error('Collector ended'));
+            };
+            this.on('collect', onCollect);
+            this.on('end', onEnd);
+        });
+    }
+}
+exports.Collector = Collector;
+/**
+ * Collector for messages
+ */
+class MessageCollector extends Collector {
+    channelId;
+    messageHandler;
+    constructor(client, channelId, options = {}) {
+        super(client, options);
+        this.channelId = channelId;
+        // Get bot's user ID to filter out bot's own messages
+        const botUserId = client.user?.id;
+        this.messageHandler = (message) => {
+            if (message.channel_id === this.channelId || message.channelId === this.channelId) {
+                // Automatically filter out bot's own messages
+                const authorId = message.author?.id || message.author_id;
+                if (botUserId && authorId === botUserId)
+                    return;
+                // Also filter by application_id (bot messages have this)
+                if (message.application_id || message.applicationId)
+                    return;
+                this.handleCollect(message);
+            }
+        };
+        client.on('messageCreate', this.messageHandler);
+        this.once('end', () => {
+            client.removeListener('messageCreate', this.messageHandler);
+        });
+    }
+    collect(message) {
+        return message.id ?? null;
+    }
+    dispose(message) {
+        return message.id ?? null;
+    }
+}
+exports.MessageCollector = MessageCollector;
+/**
+ * Collector for interactions (buttons, select menus, etc.)
+ */
+class InteractionCollector extends Collector {
+    channelId;
+    guildId;
+    messageId;
+    interactionType;
+    componentType;
+    interactionHandler;
+    constructor(client, options = {}) {
+        super(client, options);
+        this.channelId = options.channelId;
+        this.guildId = options.guildId;
+        this.messageId = options.messageId;
+        this.interactionType = options.interactionType
+            ? Array.isArray(options.interactionType) ? options.interactionType : [options.interactionType]
+            : undefined;
+        this.componentType = options.componentType
+            ? Array.isArray(options.componentType) ? options.componentType : [options.componentType]
+            : undefined;
+        this.interactionHandler = (interaction) => {
+            // Filter by channel
+            if (this.channelId && interaction.channelId !== this.channelId)
+                return;
+            // Filter by guild
+            if (this.guildId && interaction.guildId !== this.guildId)
+                return;
+            // Filter by message
+            if (this.messageId && interaction.message?.id !== this.messageId)
+                return;
+            // Filter by interaction type
+            if (this.interactionType && !this.interactionType.includes(interaction.type))
+                return;
+            // Filter by component type
+            if (this.componentType && interaction.componentType && !this.componentType.includes(interaction.componentType))
+                return;
+            this.handleCollect(interaction);
+        };
+        client.on('interactionCreate', this.interactionHandler);
+        this.once('end', () => {
+            client.removeListener('interactionCreate', this.interactionHandler);
+        });
+    }
+    collect(interaction) {
+        return interaction.id ?? null;
+    }
+    dispose(interaction) {
+        return interaction.id ?? null;
+    }
+}
+exports.InteractionCollector = InteractionCollector;
+/**
+ * Collector for reactions
+ */
+class ReactionCollector extends Collector {
+    messageId;
+    reactionHandler;
+    constructor(client, messageId, options) {
+        super(client, options);
+        this.messageId = messageId;
+        this.reactionHandler = (reaction) => {
+            if (reaction.message_id === this.messageId || reaction.messageId === this.messageId) {
+                this.handleCollect(reaction);
+            }
+        };
+        client.on('messageReactionAdd', this.reactionHandler);
+        this.once('end', () => {
+            client.removeListener('messageReactionAdd', this.reactionHandler);
+        });
+    }
+    collect(reaction) {
+        // Key is emoji identifier
+        return reaction.emoji?.id ?? reaction.emoji?.name ?? null;
+    }
+    dispose(reaction) {
+        return reaction.emoji?.id ?? reaction.emoji?.name ?? null;
+    }
+}
+exports.ReactionCollector = ReactionCollector;
+/**
+ * Await messages helper
+ */
+function awaitMessages(client, channelId, options = {}) {
+    return new Promise((resolve, reject) => {
+        const collector = new MessageCollector(client, channelId, options);
+        collector.once('end', (collected, reason) => {
+            if (options.max && collected.size < options.max) {
+                reject(new Error(`Collector ended with reason: ${reason}`));
+            }
+            else {
+                resolve(collected);
+            }
+        });
+    });
+}
+/**
+ * Await reactions helper
+ */
+function awaitReactions(client, messageId, options) {
+    return new Promise((resolve, reject) => {
+        const collector = new ReactionCollector(client, messageId, options);
+        collector.once('end', (collected, reason) => {
+            if (options.max && collected.size < options.max) {
+                reject(new Error(`Collector ended with reason: ${reason}`));
+            }
+            else {
+                resolve(collected);
+            }
+        });
+    });
+}
+exports.default = Collector;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Collector.js","sourceRoot":"","sources":["../../src/utils/Collector.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * Collectors for awaiting messages, reactions, and interactions\r\n * API compatible with Discord.js Collectors\r\n */\r\n\r\nimport { EventEmitter } from 'events';\r\nimport { Collection } from './Collection';\r\n\r\nexport interface CollectorOptions<T> {\r\n  /** How long to run the collector for in milliseconds */\r\n  time?: number;\r\n  /** How long to wait for the next item in milliseconds */\r\n  idle?: number;\r\n  /** Maximum number of items to collect */\r\n  max?: number;\r\n  /** Maximum number of items to process */\r\n  maxProcessed?: number;\r\n  /** Filter function */\r\n  filter?: (item: T, collected: Collection<string, T>) => boolean | Promise<boolean>;\r\n  /** Whether to dispose of items when the collector ends */\r\n  dispose?: boolean;\r\n}\r\n\r\nexport interface CollectorResetTimerOptions {\r\n  time?: number;\r\n  idle?: number;\r\n}\r\n\r\n/**\r\n * Abstract base class for collectors\r\n */\r\nexport abstract class Collector<K extends string, V> extends EventEmitter {\r\n  /** The client that instantiated this collector */\r\n  public readonly client: any;\r\n  \r\n  /** The items collected */\r\n  public readonly collected: Collection<K, V> = new Collection();\r\n  \r\n  /** Whether the collector has ended */\r\n  public ended = false;\r\n  \r\n  /** The reason the collector ended */\r\n  public endReason: string | null = null;\r\n  \r\n  /** Filter function */\r\n  public filter: (item: V, collected: Collection<K, V>) => boolean | Promise<boolean>;\r\n  \r\n  /** Collector options */\r\n  public options: CollectorOptions<V>;\r\n  \r\n  /** Number of items processed */\r\n  private _processedCount = 0;\r\n  \r\n  /** Timeout for time limit */\r\n  private _timeout: NodeJS.Timeout | null = null;\r\n  \r\n  /** Timeout for idle limit */\r\n  private _idleTimeout: NodeJS.Timeout | null = null;\r\n\r\n  constructor(client: any, options: CollectorOptions<V> = {}) {\r\n    super();\r\n    this.client = client;\r\n    this.options = options;\r\n    this.filter = (options.filter as any) ?? (() => true);\r\n    \r\n    this.handleCollect = this.handleCollect.bind(this);\r\n    this.handleDispose = this.handleDispose.bind(this);\r\n    \r\n    if (options.time) {\r\n      this._timeout = setTimeout(() => this.stop('time'), options.time);\r\n    }\r\n    if (options.idle) {\r\n      this._idleTimeout = setTimeout(() => this.stop('idle'), options.idle);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Handle an item being collected\r\n   */\r\n  async handleCollect(item: V): Promise<void> {\r\n    if (this.ended) return;\r\n    \r\n    this._processedCount++;\r\n    \r\n    const filterResult = await this.filter(item, this.collected);\r\n    if (!filterResult) return;\r\n    \r\n    const key = this.collect(item);\r\n    if (key === null) return;\r\n    \r\n    this.collected.set(key, item);\r\n    this.emit('collect', item);\r\n    \r\n    // Reset idle timer\r\n    if (this._idleTimeout) {\r\n      clearTimeout(this._idleTimeout);\r\n      this._idleTimeout = setTimeout(() => this.stop('idle'), this.options.idle!);\r\n    }\r\n    \r\n    // Check limits\r\n    if (this.options.max && this.collected.size >= this.options.max) {\r\n      this.stop('limit');\r\n    }\r\n    if (this.options.maxProcessed && this._processedCount >= this.options.maxProcessed) {\r\n      this.stop('processedLimit');\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Handle an item being disposed\r\n   */\r\n  handleDispose(item: V): void {\r\n    if (!this.options.dispose) return;\r\n    \r\n    const key = this.dispose(item);\r\n    if (key === null) return;\r\n    \r\n    if (this.collected.has(key)) {\r\n      this.collected.delete(key);\r\n      this.emit('dispose', item);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get the key for an item\r\n   */\r\n  abstract collect(item: V): K | null;\r\n\r\n  /**\r\n   * Get the key for disposing an item\r\n   */\r\n  abstract dispose(item: V): K | null;\r\n\r\n  /**\r\n   * Stop the collector\r\n   */\r\n  stop(reason = 'user'): void {\r\n    if (this.ended) return;\r\n    \r\n    this.ended = true;\r\n    this.endReason = reason;\r\n    \r\n    if (this._timeout) {\r\n      clearTimeout(this._timeout);\r\n      this._timeout = null;\r\n    }\r\n    if (this._idleTimeout) {\r\n      clearTimeout(this._idleTimeout);\r\n      this._idleTimeout = null;\r\n    }\r\n    \r\n    this.emit('end', this.collected, reason);\r\n  }\r\n\r\n  /**\r\n   * Reset the collector's timer\r\n   */\r\n  resetTimer(options: CollectorResetTimerOptions = {}): void {\r\n    if (this._timeout) {\r\n      clearTimeout(this._timeout);\r\n      this._timeout = null;\r\n    }\r\n    if (this._idleTimeout) {\r\n      clearTimeout(this._idleTimeout);\r\n      this._idleTimeout = null;\r\n    }\r\n    \r\n    if (options.time ?? this.options.time) {\r\n      this._timeout = setTimeout(() => this.stop('time'), options.time ?? this.options.time);\r\n    }\r\n    if (options.idle ?? this.options.idle) {\r\n      this._idleTimeout = setTimeout(() => this.stop('idle'), options.idle ?? this.options.idle);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Check the end conditions\r\n   */\r\n  checkEnd(): boolean {\r\n    const reason = this.endReason;\r\n    if (reason) {\r\n      this.stop(reason);\r\n      return true;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  /**\r\n   * Get the next item\r\n   */\r\n  get next(): Promise<V> {\r\n    return new Promise((resolve, reject) => {\r\n      if (this.ended) {\r\n        reject(new Error('Collector has ended'));\r\n        return;\r\n      }\r\n      \r\n      const cleanup = () => {\r\n        this.removeListener('collect', onCollect);\r\n        this.removeListener('end', onEnd);\r\n      };\r\n      \r\n      const onCollect = (item: V) => {\r\n        cleanup();\r\n        resolve(item);\r\n      };\r\n      \r\n      const onEnd = () => {\r\n        cleanup();\r\n        reject(new Error('Collector ended'));\r\n      };\r\n      \r\n      this.on('collect', onCollect);\r\n      this.on('end', onEnd);\r\n    });\r\n  }\r\n}\r\n\r\n/**\r\n * Message collector options\r\n */\r\nexport interface MessageCollectorOptions extends CollectorOptions<any> {\r\n  /** Channel to collect messages from */\r\n  channelId?: string;\r\n}\r\n\r\n/**\r\n * Collector for messages\r\n */\r\nexport class MessageCollector extends Collector<string, any> {\r\n  public readonly channelId: string;\r\n  private readonly messageHandler: (message: any) => void;\r\n\r\n  constructor(client: any, channelId: string, options: MessageCollectorOptions = {}) {\r\n    super(client, options);\r\n    this.channelId = channelId;\r\n    \r\n    // Get bot's user ID to filter out bot's own messages\r\n    const botUserId = client.user?.id;\r\n    \r\n    this.messageHandler = (message: any) => {\r\n      if (message.channel_id === this.channelId || message.channelId === this.channelId) {\r\n        // Automatically filter out bot's own messages\r\n        const authorId = message.author?.id || message.author_id;\r\n        if (botUserId && authorId === botUserId) return;\r\n        \r\n        // Also filter by application_id (bot messages have this)\r\n        if (message.application_id || message.applicationId) return;\r\n        \r\n        this.handleCollect(message);\r\n      }\r\n    };\r\n    \r\n    client.on('messageCreate', this.messageHandler);\r\n    \r\n    this.once('end', () => {\r\n      client.removeListener('messageCreate', this.messageHandler);\r\n    });\r\n  }\r\n\r\n  collect(message: any): string | null {\r\n    return message.id ?? null;\r\n  }\r\n\r\n  dispose(message: any): string | null {\r\n    return message.id ?? null;\r\n  }\r\n}\r\n\r\n/**\r\n * Interaction collector options\r\n */\r\nexport interface InteractionCollectorOptions extends CollectorOptions<any> {\r\n  /** Channel to collect interactions from */\r\n  channelId?: string;\r\n  /** Guild to collect interactions from */\r\n  guildId?: string;\r\n  /** Message to collect interactions from */\r\n  messageId?: string;\r\n  /** Interaction types to collect */\r\n  interactionType?: number | number[];\r\n  /** Component types to collect */\r\n  componentType?: number | number[];\r\n}\r\n\r\n/**\r\n * Collector for interactions (buttons, select menus, etc.)\r\n */\r\nexport class InteractionCollector extends Collector<string, any> {\r\n  public readonly channelId?: string;\r\n  public readonly guildId?: string;\r\n  public readonly messageId?: string;\r\n  public readonly interactionType?: number[];\r\n  public readonly componentType?: number[];\r\n  private readonly interactionHandler: (interaction: any) => void;\r\n\r\n  constructor(client: any, options: InteractionCollectorOptions = {}) {\r\n    super(client, options);\r\n    this.channelId = options.channelId;\r\n    this.guildId = options.guildId;\r\n    this.messageId = options.messageId;\r\n    this.interactionType = options.interactionType \r\n      ? Array.isArray(options.interactionType) ? options.interactionType : [options.interactionType]\r\n      : undefined;\r\n    this.componentType = options.componentType\r\n      ? Array.isArray(options.componentType) ? options.componentType : [options.componentType]\r\n      : undefined;\r\n    \r\n    this.interactionHandler = (interaction: any) => {\r\n      // Filter by channel\r\n      if (this.channelId && interaction.channelId !== this.channelId) return;\r\n      // Filter by guild\r\n      if (this.guildId && interaction.guildId !== this.guildId) return;\r\n      // Filter by message\r\n      if (this.messageId && interaction.message?.id !== this.messageId) return;\r\n      // Filter by interaction type\r\n      if (this.interactionType && !this.interactionType.includes(interaction.type)) return;\r\n      // Filter by component type\r\n      if (this.componentType && interaction.componentType && !this.componentType.includes(interaction.componentType)) return;\r\n      \r\n      this.handleCollect(interaction);\r\n    };\r\n    \r\n    client.on('interactionCreate', this.interactionHandler);\r\n    \r\n    this.once('end', () => {\r\n      client.removeListener('interactionCreate', this.interactionHandler);\r\n    });\r\n  }\r\n\r\n  collect(interaction: any): string | null {\r\n    return interaction.id ?? null;\r\n  }\r\n\r\n  dispose(interaction: any): string | null {\r\n    return interaction.id ?? null;\r\n  }\r\n}\r\n\r\n/**\r\n * Reaction collector options\r\n */\r\nexport interface ReactionCollectorOptions extends CollectorOptions<any> {\r\n  /** Message to collect reactions from */\r\n  messageId: string;\r\n}\r\n\r\n/**\r\n * Collector for reactions\r\n */\r\nexport class ReactionCollector extends Collector<string, any> {\r\n  public readonly messageId: string;\r\n  private readonly reactionHandler: (reaction: any) => void;\r\n\r\n  constructor(client: any, messageId: string, options: ReactionCollectorOptions) {\r\n    super(client, options);\r\n    this.messageId = messageId;\r\n    \r\n    this.reactionHandler = (reaction: any) => {\r\n      if (reaction.message_id === this.messageId || reaction.messageId === this.messageId) {\r\n        this.handleCollect(reaction);\r\n      }\r\n    };\r\n    \r\n    client.on('messageReactionAdd', this.reactionHandler);\r\n    \r\n    this.once('end', () => {\r\n      client.removeListener('messageReactionAdd', this.reactionHandler);\r\n    });\r\n  }\r\n\r\n  collect(reaction: any): string | null {\r\n    // Key is emoji identifier\r\n    return reaction.emoji?.id ?? reaction.emoji?.name ?? null;\r\n  }\r\n\r\n  dispose(reaction: any): string | null {\r\n    return reaction.emoji?.id ?? reaction.emoji?.name ?? null;\r\n  }\r\n}\r\n\r\n/**\r\n * Await messages helper\r\n */\r\nexport function awaitMessages(\r\n  client: any,\r\n  channelId: string,\r\n  options: MessageCollectorOptions = {}\r\n): Promise<Collection<string, any>> {\r\n  return new Promise((resolve, reject) => {\r\n    const collector = new MessageCollector(client, channelId, options);\r\n    \r\n    collector.once('end', (collected, reason) => {\r\n      if (options.max && collected.size < options.max) {\r\n        reject(new Error(`Collector ended with reason: ${reason}`));\r\n      } else {\r\n        resolve(collected);\r\n      }\r\n    });\r\n  });\r\n}\r\n\r\n/**\r\n * Await reactions helper\r\n */\r\nexport function awaitReactions(\r\n  client: any,\r\n  messageId: string,\r\n  options: ReactionCollectorOptions\r\n): Promise<Collection<string, any>> {\r\n  return new Promise((resolve, reject) => {\r\n    const collector = new ReactionCollector(client, messageId, options);\r\n    \r\n    collector.once('end', (collected, reason) => {\r\n      if (options.max && collected.size < options.max) {\r\n        reject(new Error(`Collector ended with reason: ${reason}`));\r\n      } else {\r\n        resolve(collected);\r\n      }\r\n    });\r\n  });\r\n}\r\n\r\nexport default Collector;\r\n"]}

package/dist/utils/DataResolver.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Data resolver utilities for handling various data types
+ */
+export type BufferResolvable = Buffer | string;
+export type Base64Resolvable = Buffer | string;
+/**
+ * Resolves various data types to usable formats
+ */
+export declare class DataResolver {
+    /**
+     * Resolves a BufferResolvable to a Buffer
+     * @param resource The resource to resolve
+     */
+    static resolveBuffer(resource: BufferResolvable): Promise<Buffer>;
+    /**
+     * Resolves a Base64Resolvable to a base64 string
+     * @param resource The resource to resolve
+     * @param mimeType The MIME type for the data URI
+     */
+    static resolveBase64(resource: Base64Resolvable, mimeType?: string): Promise<string>;
+    /**
+     * Resolves a file to a name and buffer
+     * @param resource The file resource
+     */
+    static resolveFile(resource: BufferResolvable | {
+        name?: string;
+        attachment: BufferResolvable;
+    }): Promise<{
+        name: string;
+        data: Buffer;
+    }>;
+    /**
+     * Resolves multiple files
+     * @param resources The file resources
+     */
+    static resolveFiles(resources: (BufferResolvable | {
+        name?: string;
+        attachment: BufferResolvable;
+    })[]): Promise<{
+        name: string;
+        data: Buffer;
+    }[]>;
+    /**
+     * Resolves a color to a number
+     * @param color The color to resolve
+     */
+    static resolveColor(color: number | string | [number, number, number] | null): number | null;
+    /**
+     * Resolves a string to a snowflake ID
+     * @param value The value to resolve
+     */
+    static resolveSnowflake(value: string | number | {
+        id: string | number;
+    }): string;
+    /**
+     * Resolves an image to a base64 data URI
+     * @param image The image to resolve
+     */
+    static resolveImage(image: BufferResolvable): Promise<string>;
+}
+export default DataResolver;