@jubbio/core 1.1.20 → 1.3.2

package/dist/esm/utils/Collection.js

@@ -0,0 +1,261 @@
+/**
+ * A Map with additional utility methods
+ */
+export class Collection extends Map {
+    /**
+     * Identical to Map.get()
+     * Ensures the value exists
+     */
+    ensure(key, defaultValueGenerator) {
+        if (this.has(key))
+            return this.get(key);
+        const defaultValue = defaultValueGenerator(key, this);
+        this.set(key, defaultValue);
+        return defaultValue;
+    }
+    /**
+     * Checks if all items pass a test
+     */
+    every(fn) {
+        for (const [key, val] of this) {
+            if (!fn(val, key, this))
+                return false;
+        }
+        return true;
+    }
+    /**
+     * Checks if any item passes a test
+     */
+    some(fn) {
+        for (const [key, val] of this) {
+            if (fn(val, key, this))
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Identical to Array.filter(), but returns a Collection
+     */
+    filter(fn) {
+        const results = new Collection();
+        for (const [key, val] of this) {
+            if (fn(val, key, this))
+                results.set(key, val);
+        }
+        return results;
+    }
+    /**
+     * Partitions the collection into two collections
+     */
+    partition(fn) {
+        const results = [new Collection(), new Collection()];
+        for (const [key, val] of this) {
+            if (fn(val, key, this)) {
+                results[0].set(key, val);
+            }
+            else {
+                results[1].set(key, val);
+            }
+        }
+        return results;
+    }
+    /**
+     * Maps each item to another value
+     */
+    map(fn) {
+        const results = [];
+        for (const [key, val] of this) {
+            results.push(fn(val, key, this));
+        }
+        return results;
+    }
+    /**
+     * Maps each item to another value into a Collection
+     */
+    mapValues(fn) {
+        const results = new Collection();
+        for (const [key, val] of this) {
+            results.set(key, fn(val, key, this));
+        }
+        return results;
+    }
+    /**
+     * Searches for a single item
+     */
+    find(fn) {
+        for (const [key, val] of this) {
+            if (fn(val, key, this))
+                return val;
+        }
+        return undefined;
+    }
+    /**
+     * Searches for the key of a single item
+     */
+    findKey(fn) {
+        for (const [key, val] of this) {
+            if (fn(val, key, this))
+                return key;
+        }
+        return undefined;
+    }
+    /**
+     * Removes items that satisfy the provided filter function
+     */
+    sweep(fn) {
+        const previousSize = this.size;
+        for (const [key, val] of this) {
+            if (fn(val, key, this))
+                this.delete(key);
+        }
+        return previousSize - this.size;
+    }
+    /**
+     * Reduces 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;
+    }
+    /**
+     * Identical to Array.forEach()
+     */
+    each(fn) {
+        for (const [key, val] of this) {
+            fn(val, key, this);
+        }
+        return this;
+    }
+    first(amount) {
+        if (amount === undefined)
+            return this.values().next().value;
+        if (amount < 0)
+            return this.last(amount * -1);
+        amount = Math.min(this.size, amount);
+        const iter = this.values();
+        return Array.from({ length: amount }, () => iter.next().value);
+    }
+    firstKey(amount) {
+        if (amount === undefined)
+            return this.keys().next().value;
+        if (amount < 0)
+            return this.lastKey(amount * -1);
+        amount = Math.min(this.size, amount);
+        const iter = this.keys();
+        return Array.from({ length: amount }, () => iter.next().value);
+    }
+    last(amount) {
+        const arr = [...this.values()];
+        if (amount === undefined)
+            return arr[arr.length - 1];
+        if (amount < 0)
+            return this.first(amount * -1);
+        if (!amount)
+            return [];
+        return arr.slice(-amount);
+    }
+    lastKey(amount) {
+        const arr = [...this.keys()];
+        if (amount === undefined)
+            return arr[arr.length - 1];
+        if (amount < 0)
+            return this.firstKey(amount * -1);
+        if (!amount)
+            return [];
+        return arr.slice(-amount);
+    }
+    random(amount) {
+        const arr = [...this.values()];
+        if (amount === undefined)
+            return arr[Math.floor(Math.random() * arr.length)];
+        if (!arr.length || !amount)
+            return [];
+        return Array.from({ length: Math.min(amount, arr.length) }, () => arr.splice(Math.floor(Math.random() * arr.length), 1)[0]);
+    }
+    randomKey(amount) {
+        const arr = [...this.keys()];
+        if (amount === undefined)
+            return arr[Math.floor(Math.random() * arr.length)];
+        if (!arr.length || !amount)
+            return [];
+        return Array.from({ length: Math.min(amount, arr.length) }, () => arr.splice(Math.floor(Math.random() * arr.length), 1)[0]);
+    }
+    /**
+     * Combines this collection with others
+     */
+    concat(...collections) {
+        const newColl = this.clone();
+        for (const coll of collections) {
+            for (const [key, val] of coll)
+                newColl.set(key, val);
+        }
+        return newColl;
+    }
+    /**
+     * Checks if this collection shares identical items with another
+     */
+    equals(collection) {
+        if (this === collection)
+            return true;
+        if (this.size !== collection.size)
+            return false;
+        for (const [key, value] of this) {
+            if (!collection.has(key) || value !== collection.get(key)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Creates an identical shallow copy of this collection
+     */
+    clone() {
+        return new Collection(this);
+    }
+    /**
+     * Sorts the collection and returns it
+     */
+    sort(compareFunction = Collection.defaultSort) {
+        const entries = [...this.entries()];
+        entries.sort((a, b) => compareFunction(a[1], b[1], a[0], b[0]));
+        this.clear();
+        for (const [k, v] of entries) {
+            this.set(k, v);
+        }
+        return this;
+    }
+    /**
+     * Sorts the collection by keys and returns it
+     */
+    sortByKey(compareFunction = Collection.defaultSort) {
+        const entries = [...this.entries()];
+        entries.sort((a, b) => compareFunction(a[0], b[0], a[1], b[1]));
+        this.clear();
+        for (const [k, v] of entries) {
+            this.set(k, v);
+        }
+        return this;
+    }
+    /**
+     * Returns an array of items
+     */
+    toJSON() {
+        return [...this.values()];
+    }
+    /**
+     * Default sort function
+     */
+    static defaultSort(firstValue, secondValue) {
+        return Number(firstValue > secondValue) || Number(firstValue === secondValue) - 1;
+    }
+    /**
+     * Creates a Collection from an array
+     */
+    static from(entries) {
+        return new Collection(entries);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Collection.js","sourceRoot":"","sources":["../../../src/utils/Collection.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * A Map with additional utility methods\n */\nexport class Collection<K, V> extends Map<K, V> {\n  /**\n   * Identical to Map.get()\n   * Ensures the value exists\n   */\n  ensure(key: K, defaultValueGenerator: (key: K, collection: this) => V): V {\n    if (this.has(key)) return this.get(key)!;\n    const defaultValue = defaultValueGenerator(key, this);\n    this.set(key, defaultValue);\n    return defaultValue;\n  }\n\n  /**\n   * Checks if all items pass a test\n   */\n  every(fn: (value: V, key: K, collection: this) => boolean): boolean {\n    for (const [key, val] of this) {\n      if (!fn(val, key, this)) return false;\n    }\n    return true;\n  }\n\n  /**\n   * Checks if any item passes a test\n   */\n  some(fn: (value: V, key: K, collection: this) => boolean): boolean {\n    for (const [key, val] of this) {\n      if (fn(val, key, this)) return true;\n    }\n    return false;\n  }\n\n  /**\n   * Identical to Array.filter(), but returns a Collection\n   */\n  filter(fn: (value: V, key: K, collection: this) => boolean): Collection<K, V> {\n    const results = new Collection<K, V>();\n    for (const [key, val] of this) {\n      if (fn(val, key, this)) results.set(key, val);\n    }\n    return results;\n  }\n\n  /**\n   * Partitions the collection into two collections\n   */\n  partition(fn: (value: V, key: K, collection: this) => boolean): [Collection<K, V>, Collection<K, V>] {\n    const results: [Collection<K, V>, Collection<K, V>] = [new Collection<K, V>(), new Collection<K, V>()];\n    for (const [key, val] of this) {\n      if (fn(val, key, this)) {\n        results[0].set(key, val);\n      } else {\n        results[1].set(key, val);\n      }\n    }\n    return results;\n  }\n\n  /**\n   * Maps each item to another value\n   */\n  map<T>(fn: (value: V, key: K, collection: this) => T): T[] {\n    const results: T[] = [];\n    for (const [key, val] of this) {\n      results.push(fn(val, key, this));\n    }\n    return results;\n  }\n\n  /**\n   * Maps each item to another value into a Collection\n   */\n  mapValues<T>(fn: (value: V, key: K, collection: this) => T): Collection<K, T> {\n    const results = new Collection<K, T>();\n    for (const [key, val] of this) {\n      results.set(key, fn(val, key, this));\n    }\n    return results;\n  }\n\n  /**\n   * Searches for a single item\n   */\n  find(fn: (value: V, key: K, collection: this) => boolean): V | undefined {\n    for (const [key, val] of this) {\n      if (fn(val, key, this)) return val;\n    }\n    return undefined;\n  }\n\n  /**\n   * Searches for the key of a single item\n   */\n  findKey(fn: (value: V, key: K, collection: this) => boolean): K | undefined {\n    for (const [key, val] of this) {\n      if (fn(val, key, this)) return key;\n    }\n    return undefined;\n  }\n\n  /**\n   * Removes items that satisfy the provided filter function\n   */\n  sweep(fn: (value: V, key: K, collection: this) => boolean): number {\n    const previousSize = this.size;\n    for (const [key, val] of this) {\n      if (fn(val, key, this)) this.delete(key);\n    }\n    return previousSize - this.size;\n  }\n\n  /**\n   * Reduces the collection to a single value\n   */\n  reduce<T>(fn: (accumulator: T, value: V, key: K, collection: this) => T, initialValue: T): T {\n    let accumulator = initialValue;\n    for (const [key, val] of this) {\n      accumulator = fn(accumulator, val, key, this);\n    }\n    return accumulator;\n  }\n\n  /**\n   * Identical to Array.forEach()\n   */\n  each(fn: (value: V, key: K, collection: this) => void): this {\n    for (const [key, val] of this) {\n      fn(val, key, this);\n    }\n    return this;\n  }\n\n  /**\n   * Returns the first item(s) in the collection\n   */\n  first(): V | undefined;\n  first(amount: number): V[];\n  first(amount?: number): V | V[] | undefined {\n    if (amount === undefined) return this.values().next().value;\n    if (amount < 0) return this.last(amount * -1);\n    amount = Math.min(this.size, amount);\n    const iter = this.values();\n    return Array.from({ length: amount }, () => iter.next().value);\n  }\n\n  /**\n   * Returns the first key(s) in the collection\n   */\n  firstKey(): K | undefined;\n  firstKey(amount: number): K[];\n  firstKey(amount?: number): K | K[] | undefined {\n    if (amount === undefined) return this.keys().next().value;\n    if (amount < 0) return this.lastKey(amount * -1);\n    amount = Math.min(this.size, amount);\n    const iter = this.keys();\n    return Array.from({ length: amount }, () => iter.next().value);\n  }\n\n  /**\n   * Returns the last item(s) in the collection\n   */\n  last(): V | undefined;\n  last(amount: number): V[];\n  last(amount?: number): V | V[] | undefined {\n    const arr = [...this.values()];\n    if (amount === undefined) return arr[arr.length - 1];\n    if (amount < 0) return this.first(amount * -1);\n    if (!amount) return [];\n    return arr.slice(-amount);\n  }\n\n  /**\n   * Returns the last key(s) in the collection\n   */\n  lastKey(): K | undefined;\n  lastKey(amount: number): K[];\n  lastKey(amount?: number): K | K[] | undefined {\n    const arr = [...this.keys()];\n    if (amount === undefined) return arr[arr.length - 1];\n    if (amount < 0) return this.firstKey(amount * -1);\n    if (!amount) return [];\n    return arr.slice(-amount);\n  }\n\n  /**\n   * Returns a random item from the collection\n   */\n  random(): V | undefined;\n  random(amount: number): V[];\n  random(amount?: number): V | V[] | undefined {\n    const arr = [...this.values()];\n    if (amount === undefined) return arr[Math.floor(Math.random() * arr.length)];\n    if (!arr.length || !amount) return [];\n    return Array.from({ length: Math.min(amount, arr.length) }, () => arr.splice(Math.floor(Math.random() * arr.length), 1)[0]);\n  }\n\n  /**\n   * Returns a random key from the collection\n   */\n  randomKey(): K | undefined;\n  randomKey(amount: number): K[];\n  randomKey(amount?: number): K | K[] | undefined {\n    const arr = [...this.keys()];\n    if (amount === undefined) return arr[Math.floor(Math.random() * arr.length)];\n    if (!arr.length || !amount) return [];\n    return Array.from({ length: Math.min(amount, arr.length) }, () => arr.splice(Math.floor(Math.random() * arr.length), 1)[0]);\n  }\n\n  /**\n   * Combines this collection with others\n   */\n  concat(...collections: Collection<K, V>[]): Collection<K, V> {\n    const newColl = this.clone();\n    for (const coll of collections) {\n      for (const [key, val] of coll) newColl.set(key, val);\n    }\n    return newColl;\n  }\n\n  /**\n   * Checks if this collection shares identical items with another\n   */\n  equals(collection: Collection<K, V>): boolean {\n    if (this === collection) return true;\n    if (this.size !== collection.size) return false;\n    for (const [key, value] of this) {\n      if (!collection.has(key) || value !== collection.get(key)) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  /**\n   * Creates an identical shallow copy of this collection\n   */\n  clone(): Collection<K, V> {\n    return new Collection(this);\n  }\n\n  /**\n   * Sorts the collection and returns it\n   */\n  sort(compareFunction: (firstValue: V, secondValue: V, firstKey: K, secondKey: K) => number = Collection.defaultSort): this {\n    const entries = [...this.entries()];\n    entries.sort((a, b) => compareFunction(a[1], b[1], a[0], b[0]));\n    this.clear();\n    for (const [k, v] of entries) {\n      this.set(k, v);\n    }\n    return this;\n  }\n\n  /**\n   * Sorts the collection by keys and returns it\n   */\n  sortByKey(compareFunction: (firstKey: K, secondKey: K, firstValue: V, secondValue: V) => number = Collection.defaultSort): this {\n    const entries = [...this.entries()];\n    entries.sort((a, b) => compareFunction(a[0], b[0], a[1], b[1]));\n    this.clear();\n    for (const [k, v] of entries) {\n      this.set(k, v);\n    }\n    return this;\n  }\n\n  /**\n   * Returns an array of items\n   */\n  toJSON(): V[] {\n    return [...this.values()];\n  }\n\n  /**\n   * Default sort function\n   */\n  private static defaultSort<V>(firstValue: V, secondValue: V): number {\n    return Number(firstValue > secondValue) || Number(firstValue === secondValue) - 1;\n  }\n\n  /**\n   * Creates a Collection from an array\n   */\n  static from<K, V>(entries: Iterable<readonly [K, V]>): Collection<K, V> {\n    return new Collection(entries);\n  }\n}\n"]}

package/dist/esm/utils/Collector.js

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