@jubbio/core 1.0.0

package/dist/utils/SnowflakeUtil.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Snowflake utilities
+ * API compatible with Discord.js SnowflakeUtil
+ */
+/**
+ * A container for useful snowflake-related methods
+ */
+export declare class SnowflakeUtil {
+    /**
+     * Jubbio's epoch value
+     */
+    static readonly EPOCH = 1420070400000n;
+    /**
+     * Generates a snowflake ID
+     * @param timestamp Timestamp or date to generate from
+     */
+    static generate(timestamp?: number | Date): string;
+    /**
+     * Deconstructs a snowflake ID
+     * @param snowflake Snowflake to deconstruct
+     */
+    static deconstruct(snowflake: string): DeconstructedSnowflake;
+    /**
+     * Retrieves the timestamp from a snowflake
+     * @param snowflake Snowflake to get the timestamp from
+     */
+    static timestampFrom(snowflake: string): number;
+    /**
+     * Retrieves the date from a snowflake
+     * @param snowflake Snowflake to get the date from
+     */
+    static dateFrom(snowflake: string): Date;
+    /**
+     * Compares two snowflakes
+     * @param a First snowflake
+     * @param b Second snowflake
+     * @returns -1 if a < b, 0 if a === b, 1 if a > b
+     */
+    static compare(a: string, b: string): -1 | 0 | 1;
+    /**
+     * Checks if a value is a valid snowflake
+     * @param value Value to check
+     */
+    static isValid(value: unknown): value is string;
+}
+/**
+ * Deconstructed snowflake data
+ */
+export interface DeconstructedSnowflake {
+    /** Timestamp the snowflake was created */
+    timestamp: number;
+    /** Date the snowflake was created */
+    date: Date;
+    /** Worker ID in the snowflake */
+    workerId: number;
+    /** Process ID in the snowflake */
+    processId: number;
+    /** Increment in the snowflake */
+    increment: number;
+    /** Binary representation of the snowflake */
+    binary: string;
+}
+export default SnowflakeUtil;

package/dist/utils/SnowflakeUtil.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * Snowflake utilities
+ * API compatible with Discord.js SnowflakeUtil
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnowflakeUtil = void 0;
+// Jubbio epoch (same as Discord: 2015-01-01T00:00:00.000Z)
+const EPOCH = 1420070400000n;
+/**
+ * A container for useful snowflake-related methods
+ */
+class SnowflakeUtil {
+    /**
+     * Jubbio's epoch value
+     */
+    static EPOCH = EPOCH;
+    /**
+     * Generates a snowflake ID
+     * @param timestamp Timestamp or date to generate from
+     */
+    static generate(timestamp = Date.now()) {
+        const time = timestamp instanceof Date ? timestamp.getTime() : timestamp;
+        return ((BigInt(time) - EPOCH) << 22n).toString();
+    }
+    /**
+     * Deconstructs a snowflake ID
+     * @param snowflake Snowflake to deconstruct
+     */
+    static deconstruct(snowflake) {
+        const bigIntSnowflake = BigInt(snowflake);
+        return {
+            timestamp: Number((bigIntSnowflake >> 22n) + EPOCH),
+            get date() {
+                return new Date(this.timestamp);
+            },
+            workerId: Number((bigIntSnowflake & 0x3e0000n) >> 17n),
+            processId: Number((bigIntSnowflake & 0x1f000n) >> 12n),
+            increment: Number(bigIntSnowflake & 0xfffn),
+            binary: bigIntSnowflake.toString(2).padStart(64, '0'),
+        };
+    }
+    /**
+     * Retrieves the timestamp from a snowflake
+     * @param snowflake Snowflake to get the timestamp from
+     */
+    static timestampFrom(snowflake) {
+        return Number((BigInt(snowflake) >> 22n) + EPOCH);
+    }
+    /**
+     * Retrieves the date from a snowflake
+     * @param snowflake Snowflake to get the date from
+     */
+    static dateFrom(snowflake) {
+        return new Date(SnowflakeUtil.timestampFrom(snowflake));
+    }
+    /**
+     * Compares two snowflakes
+     * @param a First snowflake
+     * @param b Second snowflake
+     * @returns -1 if a < b, 0 if a === b, 1 if a > b
+     */
+    static compare(a, b) {
+        const bigA = BigInt(a);
+        const bigB = BigInt(b);
+        if (bigA < bigB)
+            return -1;
+        if (bigA > bigB)
+            return 1;
+        return 0;
+    }
+    /**
+     * Checks if a value is a valid snowflake
+     * @param value Value to check
+     */
+    static isValid(value) {
+        if (typeof value !== 'string')
+            return false;
+        if (!/^\d{17,20}$/.test(value))
+            return false;
+        try {
+            const timestamp = SnowflakeUtil.timestampFrom(value);
+            return timestamp > Number(EPOCH) && timestamp < Date.now() + 1000 * 60 * 60 * 24 * 365; // Within reasonable range
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.SnowflakeUtil = SnowflakeUtil;
+// Export as default too for convenience
+exports.default = SnowflakeUtil;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU25vd2ZsYWtlVXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9Tbm93Zmxha2VVdGlsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7O0dBR0c7OztBQUVILDJEQUEyRDtBQUMzRCxNQUFNLEtBQUssR0FBRyxjQUFjLENBQUM7QUFFN0I7O0dBRUc7QUFDSCxNQUFhLGFBQWE7SUFDeEI7O09BRUc7SUFDSCxNQUFNLENBQVUsS0FBSyxHQUFHLEtBQUssQ0FBQztJQUU5Qjs7O09BR0c7SUFDSCxNQUFNLENBQUMsUUFBUSxDQUFDLFlBQTJCLElBQUksQ0FBQyxHQUFHLEVBQUU7UUFDbkQsTUFBTSxJQUFJLEdBQUcsU0FBUyxZQUFZLElBQUksQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQUM7UUFDekUsT0FBTyxDQUFDLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLEtBQUssQ0FBQyxJQUFJLEdBQUcsQ0FBQyxDQUFDLFFBQVEsRUFBRSxDQUFDO0lBQ3BELENBQUM7SUFFRDs7O09BR0c7SUFDSCxNQUFNLENBQUMsV0FBVyxDQUFDLFNBQWlCO1FBQ2xDLE1BQU0sZUFBZSxHQUFHLE1BQU0sQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUMxQyxPQUFPO1lBQ0wsU0FBUyxFQUFFLE1BQU0sQ0FBQyxDQUFDLGVBQWUsSUFBSSxHQUFHLENBQUMsR0FBRyxLQUFLLENBQUM7WUFDbkQsSUFBSSxJQUFJO2dCQUNOLE9BQU8sSUFBSSxJQUFJLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDO1lBQ2xDLENBQUM7WUFDRCxRQUFRLEVBQUUsTUFBTSxDQUFDLENBQUMsZUFBZSxHQUFHLFNBQVMsQ0FBQyxJQUFJLEdBQUcsQ0FBQztZQUN0RCxTQUFTLEVBQUUsTUFBTSxDQUFDLENBQUMsZUFBZSxHQUFHLFFBQVEsQ0FBQyxJQUFJLEdBQUcsQ0FBQztZQUN0RCxTQUFTLEVBQUUsTUFBTSxDQUFDLGVBQWUsR0FBRyxNQUFNLENBQUM7WUFDM0MsTUFBTSxFQUFFLGVBQWUsQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUFDLEVBQUUsRUFBRSxHQUFHLENBQUM7U0FDdEQsQ0FBQztJQUNKLENBQUM7SUFFRDs7O09BR0c7SUFDSCxNQUFNLENBQUMsYUFBYSxDQUFDLFNBQWlCO1FBQ3BDLE9BQU8sTUFBTSxDQUFDLENBQUMsTUFBTSxDQUFDLFNBQVMsQ0FBQyxJQUFJLEdBQUcsQ0FBQyxHQUFHLEtBQUssQ0FBQyxDQUFDO0lBQ3BELENBQUM7SUFFRDs7O09BR0c7SUFDSCxNQUFNLENBQUMsUUFBUSxDQUFDLFNBQWlCO1FBQy9CLE9BQU8sSUFBSSxJQUFJLENBQUMsYUFBYSxDQUFDLGFBQWEsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDO0lBQzFELENBQUM7SUFFRDs7Ozs7T0FLRztJQUNILE1BQU0sQ0FBQyxPQUFPLENBQUMsQ0FBUyxFQUFFLENBQVM7UUFDakMsTUFBTSxJQUFJLEdBQUcsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQ3ZCLE1BQU0sSUFBSSxHQUFHLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUN2QixJQUFJLElBQUksR0FBRyxJQUFJO1lBQUUsT0FBTyxDQUFDLENBQUMsQ0FBQztRQUMzQixJQUFJLElBQUksR0FBRyxJQUFJO1lBQUUsT0FBTyxDQUFDLENBQUM7UUFDMUIsT0FBTyxDQUFDLENBQUM7SUFDWCxDQUFDO0lBRUQ7OztPQUdHO0lBQ0gsTUFBTSxDQUFDLE9BQU8sQ0FBQyxLQUFjO1FBQzNCLElBQUksT0FBTyxLQUFLLEtBQUssUUFBUTtZQUFFLE9BQU8sS0FBSyxDQUFDO1FBQzVDLElBQUksQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQztZQUFFLE9BQU8sS0FBSyxDQUFDO1FBQzdDLElBQUksQ0FBQztZQUNILE1BQU0sU0FBUyxHQUFHLGFBQWEsQ0FBQyxhQUFhLENBQUMsS0FBSyxDQUFDLENBQUM7WUFDckQsT0FBTyxTQUFTLEdBQUcsTUFBTSxDQUFDLEtBQUssQ0FBQyxJQUFJLFNBQVMsR0FBRyxJQUFJLENBQUMsR0FBRyxFQUFFLEdBQUcsSUFBSSxHQUFHLEVBQUUsR0FBRyxFQUFFLEdBQUcsRUFBRSxHQUFHLEdBQUcsQ0FBQyxDQUFDLDBCQUEwQjtRQUNwSCxDQUFDO1FBQUMsTUFBTSxDQUFDO1lBQ1AsT0FBTyxLQUFLLENBQUM7UUFDZixDQUFDO0lBQ0gsQ0FBQzs7QUE1RUgsc0NBNkVDO0FBb0JELHdDQUF3QztBQUN4QyxrQkFBZSxhQUFhLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogU25vd2ZsYWtlIHV0aWxpdGllc1xyXG4gKiBBUEkgY29tcGF0aWJsZSB3aXRoIERpc2NvcmQuanMgU25vd2ZsYWtlVXRpbFxyXG4gKi9cclxuXHJcbi8vIEp1YmJpbyBlcG9jaCAoc2FtZSBhcyBEaXNjb3JkOiAyMDE1LTAxLTAxVDAwOjAwOjAwLjAwMFopXHJcbmNvbnN0IEVQT0NIID0gMTQyMDA3MDQwMDAwMG47XHJcblxyXG4vKipcclxuICogQSBjb250YWluZXIgZm9yIHVzZWZ1bCBzbm93Zmxha2UtcmVsYXRlZCBtZXRob2RzXHJcbiAqL1xyXG5leHBvcnQgY2xhc3MgU25vd2ZsYWtlVXRpbCB7XHJcbiAgLyoqXHJcbiAgICogSnViYmlvJ3MgZXBvY2ggdmFsdWVcclxuICAgKi9cclxuICBzdGF0aWMgcmVhZG9ubHkgRVBPQ0ggPSBFUE9DSDtcclxuXHJcbiAgLyoqXHJcbiAgICogR2VuZXJhdGVzIGEgc25vd2ZsYWtlIElEXHJcbiAgICogQHBhcmFtIHRpbWVzdGFtcCBUaW1lc3RhbXAgb3IgZGF0ZSB0byBnZW5lcmF0ZSBmcm9tXHJcbiAgICovXHJcbiAgc3RhdGljIGdlbmVyYXRlKHRpbWVzdGFtcDogbnVtYmVyIHwgRGF0ZSA9IERhdGUubm93KCkpOiBzdHJpbmcge1xyXG4gICAgY29uc3QgdGltZSA9IHRpbWVzdGFtcCBpbnN0YW5jZW9mIERhdGUgPyB0aW1lc3RhbXAuZ2V0VGltZSgpIDogdGltZXN0YW1wO1xyXG4gICAgcmV0dXJuICgoQmlnSW50KHRpbWUpIC0gRVBPQ0gpIDw8IDIybikudG9TdHJpbmcoKTtcclxuICB9XHJcblxyXG4gIC8qKlxyXG4gICAqIERlY29uc3RydWN0cyBhIHNub3dmbGFrZSBJRFxyXG4gICAqIEBwYXJhbSBzbm93Zmxha2UgU25vd2ZsYWtlIHRvIGRlY29uc3RydWN0XHJcbiAgICovXHJcbiAgc3RhdGljIGRlY29uc3RydWN0KHNub3dmbGFrZTogc3RyaW5nKTogRGVjb25zdHJ1Y3RlZFNub3dmbGFrZSB7XHJcbiAgICBjb25zdCBiaWdJbnRTbm93Zmxha2UgPSBCaWdJbnQoc25vd2ZsYWtlKTtcclxuICAgIHJldHVybiB7XHJcbiAgICAgIHRpbWVzdGFtcDogTnVtYmVyKChiaWdJbnRTbm93Zmxha2UgPj4gMjJuKSArIEVQT0NIKSxcclxuICAgICAgZ2V0IGRhdGUoKSB7XHJcbiAgICAgICAgcmV0dXJuIG5ldyBEYXRlKHRoaXMudGltZXN0YW1wKTtcclxuICAgICAgfSxcclxuICAgICAgd29ya2VySWQ6IE51bWJlcigoYmlnSW50U25vd2ZsYWtlICYgMHgzRTAwMDBuKSA+PiAxN24pLFxyXG4gICAgICBwcm9jZXNzSWQ6IE51bWJlcigoYmlnSW50U25vd2ZsYWtlICYgMHgxRjAwMG4pID4+IDEybiksXHJcbiAgICAgIGluY3JlbWVudDogTnVtYmVyKGJpZ0ludFNub3dmbGFrZSAmIDB4RkZGbiksXHJcbiAgICAgIGJpbmFyeTogYmlnSW50U25vd2ZsYWtlLnRvU3RyaW5nKDIpLnBhZFN0YXJ0KDY0LCAnMCcpLFxyXG4gICAgfTtcclxuICB9XHJcblxyXG4gIC8qKlxyXG4gICAqIFJldHJpZXZlcyB0aGUgdGltZXN0YW1wIGZyb20gYSBzbm93Zmxha2VcclxuICAgKiBAcGFyYW0gc25vd2ZsYWtlIFNub3dmbGFrZSB0byBnZXQgdGhlIHRpbWVzdGFtcCBmcm9tXHJcbiAgICovXHJcbiAgc3RhdGljIHRpbWVzdGFtcEZyb20oc25vd2ZsYWtlOiBzdHJpbmcpOiBudW1iZXIge1xyXG4gICAgcmV0dXJuIE51bWJlcigoQmlnSW50KHNub3dmbGFrZSkgPj4gMjJuKSArIEVQT0NIKTtcclxuICB9XHJcblxyXG4gIC8qKlxyXG4gICAqIFJldHJpZXZlcyB0aGUgZGF0ZSBmcm9tIGEgc25vd2ZsYWtlXHJcbiAgICogQHBhcmFtIHNub3dmbGFrZSBTbm93Zmxha2UgdG8gZ2V0IHRoZSBkYXRlIGZyb21cclxuICAgKi9cclxuICBzdGF0aWMgZGF0ZUZyb20oc25vd2ZsYWtlOiBzdHJpbmcpOiBEYXRlIHtcclxuICAgIHJldHVybiBuZXcgRGF0ZShTbm93Zmxha2VVdGlsLnRpbWVzdGFtcEZyb20oc25vd2ZsYWtlKSk7XHJcbiAgfVxyXG5cclxuICAvKipcclxuICAgKiBDb21wYXJlcyB0d28gc25vd2ZsYWtlc1xyXG4gICAqIEBwYXJhbSBhIEZpcnN0IHNub3dmbGFrZVxyXG4gICAqIEBwYXJhbSBiIFNlY29uZCBzbm93Zmxha2VcclxuICAgKiBAcmV0dXJucyAtMSBpZiBhIDwgYiwgMCBpZiBhID09PSBiLCAxIGlmIGEgPiBiXHJcbiAgICovXHJcbiAgc3RhdGljIGNvbXBhcmUoYTogc3RyaW5nLCBiOiBzdHJpbmcpOiAtMSB8IDAgfCAxIHtcclxuICAgIGNvbnN0IGJpZ0EgPSBCaWdJbnQoYSk7XHJcbiAgICBjb25zdCBiaWdCID0gQmlnSW50KGIpO1xyXG4gICAgaWYgKGJpZ0EgPCBiaWdCKSByZXR1cm4gLTE7XHJcbiAgICBpZiAoYmlnQSA+IGJpZ0IpIHJldHVybiAxO1xyXG4gICAgcmV0dXJuIDA7XHJcbiAgfVxyXG5cclxuICAvKipcclxuICAgKiBDaGVja3MgaWYgYSB2YWx1ZSBpcyBhIHZhbGlkIHNub3dmbGFrZVxyXG4gICAqIEBwYXJhbSB2YWx1ZSBWYWx1ZSB0byBjaGVja1xyXG4gICAqL1xyXG4gIHN0YXRpYyBpc1ZhbGlkKHZhbHVlOiB1bmtub3duKTogdmFsdWUgaXMgc3RyaW5nIHtcclxuICAgIGlmICh0eXBlb2YgdmFsdWUgIT09ICdzdHJpbmcnKSByZXR1cm4gZmFsc2U7XHJcbiAgICBpZiAoIS9eXFxkezE3LDIwfSQvLnRlc3QodmFsdWUpKSByZXR1cm4gZmFsc2U7XHJcbiAgICB0cnkge1xyXG4gICAgICBjb25zdCB0aW1lc3RhbXAgPSBTbm93Zmxha2VVdGlsLnRpbWVzdGFtcEZyb20odmFsdWUpO1xyXG4gICAgICByZXR1cm4gdGltZXN0YW1wID4gTnVtYmVyKEVQT0NIKSAmJiB0aW1lc3RhbXAgPCBEYXRlLm5vdygpICsgMTAwMCAqIDYwICogNjAgKiAyNCAqIDM2NTsgLy8gV2l0aGluIHJlYXNvbmFibGUgcmFuZ2VcclxuICAgIH0gY2F0Y2gge1xyXG4gICAgICByZXR1cm4gZmFsc2U7XHJcbiAgICB9XHJcbiAgfVxyXG59XHJcblxyXG4vKipcclxuICogRGVjb25zdHJ1Y3RlZCBzbm93Zmxha2UgZGF0YVxyXG4gKi9cclxuZXhwb3J0IGludGVyZmFjZSBEZWNvbnN0cnVjdGVkU25vd2ZsYWtlIHtcclxuICAvKiogVGltZXN0YW1wIHRoZSBzbm93Zmxha2Ugd2FzIGNyZWF0ZWQgKi9cclxuICB0aW1lc3RhbXA6IG51bWJlcjtcclxuICAvKiogRGF0ZSB0aGUgc25vd2ZsYWtlIHdhcyBjcmVhdGVkICovXHJcbiAgZGF0ZTogRGF0ZTtcclxuICAvKiogV29ya2VyIElEIGluIHRoZSBzbm93Zmxha2UgKi9cclxuICB3b3JrZXJJZDogbnVtYmVyO1xyXG4gIC8qKiBQcm9jZXNzIElEIGluIHRoZSBzbm93Zmxha2UgKi9cclxuICBwcm9jZXNzSWQ6IG51bWJlcjtcclxuICAvKiogSW5jcmVtZW50IGluIHRoZSBzbm93Zmxha2UgKi9cclxuICBpbmNyZW1lbnQ6IG51bWJlcjtcclxuICAvKiogQmluYXJ5IHJlcHJlc2VudGF0aW9uIG9mIHRoZSBzbm93Zmxha2UgKi9cclxuICBiaW5hcnk6IHN0cmluZztcclxufVxyXG5cclxuLy8gRXhwb3J0IGFzIGRlZmF1bHQgdG9vIGZvciBjb252ZW5pZW5jZVxyXG5leHBvcnQgZGVmYXVsdCBTbm93Zmxha2VVdGlsO1xyXG4iXX0=

package/dist/utils/Sweepers.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Sweepers - Automatic cache cleanup utilities
+ */
+import { Collection } from './Collection';
+/**
+ * Sweeper options for a specific cache
+ */
+export interface SweeperOptions {
+    /** Interval in seconds between sweeps */
+    interval: number;
+    /** Filter function to determine what to sweep */
+    filter: () => (value: any, key: string, collection: Collection<string, any>) => boolean;
+}
+/**
+ * Global sweeper configuration
+ */
+export interface SweeperDefinitions {
+    /** Sweep application commands */
+    applicationCommands?: SweeperOptions;
+    /** Sweep bans */
+    bans?: SweeperOptions;
+    /** Sweep emojis */
+    emojis?: SweeperOptions;
+    /** Sweep invites */
+    invites?: SweeperOptions;
+    /** Sweep guild members */
+    guildMembers?: SweeperOptions;
+    /** Sweep messages */
+    messages?: SweeperOptions;
+    /** Sweep presences */
+    presences?: SweeperOptions;
+    /** Sweep reactions */
+    reactions?: SweeperOptions;
+    /** Sweep stage instances */
+    stageInstances?: SweeperOptions;
+    /** Sweep stickers */
+    stickers?: SweeperOptions;
+    /** Sweep thread members */
+    threadMembers?: SweeperOptions;
+    /** Sweep threads */
+    threads?: SweeperOptions;
+    /** Sweep users */
+    users?: SweeperOptions;
+    /** Sweep voice states */
+    voiceStates?: SweeperOptions;
+}
+/**
+ * Sweeper filters - predefined filter functions
+ */
+export declare const Sweepers: {
+    /**
+     * Filter that sweeps items older than a certain lifetime
+     */
+    filterByLifetime<T extends {
+        createdTimestamp?: number;
+        createdAt?: Date;
+    }>(options?: {
+        lifetime?: number;
+        getComparisonTimestamp?: (value: T) => number;
+        excludeFromSweep?: (value: T) => boolean;
+    }): () => (value: T) => boolean;
+    /**
+     * Filter that sweeps archived threads
+     */
+    archivedThreadSweepFilter(lifetime?: number): () => (thread: any) => boolean;
+    /**
+     * Filter that sweeps expired invites
+     */
+    expiredInviteSweepFilter(): () => (invite: any) => boolean;
+    /**
+     * Filter that sweeps outdated presences
+     */
+    outdatedPresenceSweepFilter(lifetime?: number): () => (presence: any) => boolean;
+    /**
+     * Filter that sweeps all items (use with caution)
+     */
+    sweepAll(): () => () => boolean;
+    /**
+     * Filter that sweeps nothing
+     */
+    sweepNone(): () => () => boolean;
+};
+/**
+ * Sweeper manager class
+ */
+export declare class SweeperManager {
+    private client;
+    private intervals;
+    private options;
+    constructor(client: any, options?: SweeperDefinitions);
+    /**
+     * Start all configured sweepers
+     */
+    start(): void;
+    /**
+     * Start a specific sweeper
+     */
+    private startSweeper;
+    /**
+     * Stop a specific sweeper
+     */
+    stopSweeper(name: keyof SweeperDefinitions): void;
+    /**
+     * Stop all sweepers
+     */
+    stop(): void;
+    /**
+     * Manually trigger a sweep
+     */
+    sweep(name: keyof SweeperDefinitions, filter?: () => (value: any, key: string, collection: Collection<string, any>) => boolean): number;
+    /**
+     * Get the cache for a sweeper type
+     */
+    private getCache;
+    /**
+     * Get sweeper statistics
+     */
+    getStats(): Record<string, {
+        interval: number;
+        running: boolean;
+    }>;
+}
+/**
+ * Default sweeper options for common use cases
+ */
+export declare const DefaultSweeperOptions: SweeperDefinitions;
+export default SweeperManager;

package/dist/utils/Sweepers.js

@@ -0,0 +1,270 @@
+"use strict";
+/**
+ * Sweepers - Automatic cache cleanup utilities
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultSweeperOptions = exports.SweeperManager = exports.Sweepers = void 0;
+/**
+ * Sweeper filters - predefined filter functions
+ */
+exports.Sweepers = {
+    /**
+     * Filter that sweeps items older than a certain lifetime
+     */
+    filterByLifetime(options = {}) {
+        const lifetime = options.lifetime ?? 14400; // 4 hours default
+        const getTimestamp = options.getComparisonTimestamp ??
+            ((v) => v.createdTimestamp ?? v.createdAt?.getTime() ?? 0);
+        const exclude = options.excludeFromSweep ?? (() => false);
+        return () => {
+            const now = Date.now();
+            const cutoff = now - (lifetime * 1000);
+            return (value) => {
+                if (exclude(value))
+                    return false;
+                const timestamp = getTimestamp(value);
+                return timestamp < cutoff;
+            };
+        };
+    },
+    /**
+     * Filter that sweeps archived threads
+     */
+    archivedThreadSweepFilter(lifetime = 14400) {
+        return () => {
+            const now = Date.now();
+            const cutoff = now - (lifetime * 1000);
+            return (thread) => {
+                if (!thread.archived)
+                    return false;
+                const archivedAt = thread.archivedAt?.getTime() ?? thread.archiveTimestamp ?? 0;
+                return archivedAt < cutoff;
+            };
+        };
+    },
+    /**
+     * Filter that sweeps expired invites
+     */
+    expiredInviteSweepFilter() {
+        return () => {
+            const now = Date.now();
+            return (invite) => {
+                if (!invite.expiresAt && !invite.expiresTimestamp)
+                    return false;
+                const expiresAt = invite.expiresAt?.getTime() ?? invite.expiresTimestamp ?? Infinity;
+                return expiresAt < now;
+            };
+        };
+    },
+    /**
+     * Filter that sweeps outdated presences
+     */
+    outdatedPresenceSweepFilter(lifetime = 21600) {
+        return () => {
+            const now = Date.now();
+            const cutoff = now - (lifetime * 1000);
+            return (presence) => {
+                const lastUpdate = presence.lastModified ?? presence.updatedAt?.getTime() ?? 0;
+                return lastUpdate < cutoff;
+            };
+        };
+    },
+    /**
+     * Filter that sweeps all items (use with caution)
+     */
+    sweepAll() {
+        return () => () => true;
+    },
+    /**
+     * Filter that sweeps nothing
+     */
+    sweepNone() {
+        return () => () => false;
+    },
+};
+/**
+ * Sweeper manager class
+ */
+class SweeperManager {
+    client;
+    intervals = new Map();
+    options;
+    constructor(client, options = {}) {
+        this.client = client;
+        this.options = options;
+    }
+    /**
+     * Start all configured sweepers
+     */
+    start() {
+        for (const [key, config] of Object.entries(this.options)) {
+            if (config && config.interval > 0) {
+                this.startSweeper(key, config);
+            }
+        }
+    }
+    /**
+     * Start a specific sweeper
+     */
+    startSweeper(name, config) {
+        // Clear existing interval if any
+        this.stopSweeper(name);
+        const interval = setInterval(() => {
+            this.sweep(name, config.filter);
+        }, config.interval * 1000);
+        this.intervals.set(name, interval);
+    }
+    /**
+     * Stop a specific sweeper
+     */
+    stopSweeper(name) {
+        const interval = this.intervals.get(name);
+        if (interval) {
+            clearInterval(interval);
+            this.intervals.delete(name);
+        }
+    }
+    /**
+     * Stop all sweepers
+     */
+    stop() {
+        for (const name of this.intervals.keys()) {
+            this.stopSweeper(name);
+        }
+    }
+    /**
+     * Manually trigger a sweep
+     */
+    sweep(name, filter) {
+        const cache = this.getCache(name);
+        if (!cache)
+            return 0;
+        const filterFn = filter ?? this.options[name]?.filter;
+        if (!filterFn)
+            return 0;
+        return cache.sweep(filterFn());
+    }
+    /**
+     * Get the cache for a sweeper type
+     */
+    getCache(name) {
+        switch (name) {
+            case 'users':
+                return this.client.users?.cache ?? null;
+            case 'guildMembers':
+                // Sweep across all guilds
+                let memberCount = 0;
+                this.client.guilds?.cache.forEach((guild) => {
+                    if (guild.members?.cache) {
+                        const filter = this.options.guildMembers?.filter;
+                        if (filter)
+                            memberCount += guild.members.cache.sweep(filter());
+                    }
+                });
+                return null; // Already handled
+            case 'messages':
+                // Sweep across all channels
+                this.client.channels?.cache.forEach((channel) => {
+                    if (channel.messages?.cache) {
+                        const filter = this.options.messages?.filter;
+                        if (filter)
+                            channel.messages.cache.sweep(filter());
+                    }
+                });
+                return null;
+            case 'threads':
+                return this.client.channels?.cache.filter((c) => c.isThread?.()) ?? null;
+            case 'presences':
+                // Sweep across all guilds
+                this.client.guilds?.cache.forEach((guild) => {
+                    if (guild.presences?.cache) {
+                        const filter = this.options.presences?.filter;
+                        if (filter)
+                            guild.presences.cache.sweep(filter());
+                    }
+                });
+                return null;
+            case 'voiceStates':
+                this.client.guilds?.cache.forEach((guild) => {
+                    if (guild.voiceStates?.cache) {
+                        const filter = this.options.voiceStates?.filter;
+                        if (filter)
+                            guild.voiceStates.cache.sweep(filter());
+                    }
+                });
+                return null;
+            case 'reactions':
+                // Sweep reactions from all messages
+                this.client.channels?.cache.forEach((channel) => {
+                    channel.messages?.cache.forEach((message) => {
+                        if (message.reactions?.cache) {
+                            const filter = this.options.reactions?.filter;
+                            if (filter)
+                                message.reactions.cache.sweep(filter());
+                        }
+                    });
+                });
+                return null;
+            case 'emojis':
+                return this.client.emojis?.cache ?? null;
+            case 'stickers':
+                return this.client.stickers?.cache ?? null;
+            case 'invites':
+                // Sweep across all guilds
+                this.client.guilds?.cache.forEach((guild) => {
+                    if (guild.invites?.cache) {
+                        const filter = this.options.invites?.filter;
+                        if (filter)
+                            guild.invites.cache.sweep(filter());
+                    }
+                });
+                return null;
+            case 'bans':
+                this.client.guilds?.cache.forEach((guild) => {
+                    if (guild.bans?.cache) {
+                        const filter = this.options.bans?.filter;
+                        if (filter)
+                            guild.bans.cache.sweep(filter());
+                    }
+                });
+                return null;
+            default:
+                return null;
+        }
+    }
+    /**
+     * Get sweeper statistics
+     */
+    getStats() {
+        const stats = {};
+        for (const [name, config] of Object.entries(this.options)) {
+            if (config) {
+                stats[name] = {
+                    interval: config.interval,
+                    running: this.intervals.has(name),
+                };
+            }
+        }
+        return stats;
+    }
+}
+exports.SweeperManager = SweeperManager;
+/**
+ * Default sweeper options for common use cases
+ */
+exports.DefaultSweeperOptions = {
+    messages: {
+        interval: 3600, // 1 hour
+        filter: exports.Sweepers.filterByLifetime({ lifetime: 1800 }), // 30 minutes
+    },
+    threads: {
+        interval: 3600,
+        filter: exports.Sweepers.archivedThreadSweepFilter(14400), // 4 hours
+    },
+    invites: {
+        interval: 3600,
+        filter: exports.Sweepers.expiredInviteSweepFilter(),
+    },
+};
+exports.default = SweeperManager;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Sweepers.js","sourceRoot":"","sources":["../../src/utils/Sweepers.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * Sweepers - Automatic cache cleanup utilities\r\n */\r\n\r\nimport { Collection } from './Collection';\r\n\r\n/**\r\n * Sweeper options for a specific cache\r\n */\r\nexport interface SweeperOptions {\r\n  /** Interval in seconds between sweeps */\r\n  interval: number;\r\n  /** Filter function to determine what to sweep */\r\n  filter: () => (value: any, key: string, collection: Collection<string, any>) => boolean;\r\n}\r\n\r\n/**\r\n * Global sweeper configuration\r\n */\r\nexport interface SweeperDefinitions {\r\n  /** Sweep application commands */\r\n  applicationCommands?: SweeperOptions;\r\n  /** Sweep bans */\r\n  bans?: SweeperOptions;\r\n  /** Sweep emojis */\r\n  emojis?: SweeperOptions;\r\n  /** Sweep invites */\r\n  invites?: SweeperOptions;\r\n  /** Sweep guild members */\r\n  guildMembers?: SweeperOptions;\r\n  /** Sweep messages */\r\n  messages?: SweeperOptions;\r\n  /** Sweep presences */\r\n  presences?: SweeperOptions;\r\n  /** Sweep reactions */\r\n  reactions?: SweeperOptions;\r\n  /** Sweep stage instances */\r\n  stageInstances?: SweeperOptions;\r\n  /** Sweep stickers */\r\n  stickers?: SweeperOptions;\r\n  /** Sweep thread members */\r\n  threadMembers?: SweeperOptions;\r\n  /** Sweep threads */\r\n  threads?: SweeperOptions;\r\n  /** Sweep users */\r\n  users?: SweeperOptions;\r\n  /** Sweep voice states */\r\n  voiceStates?: SweeperOptions;\r\n}\r\n\r\n/**\r\n * Sweeper filters - predefined filter functions\r\n */\r\nexport const Sweepers = {\r\n  /**\r\n   * Filter that sweeps items older than a certain lifetime\r\n   */\r\n  filterByLifetime<T extends { createdTimestamp?: number; createdAt?: Date }>(options: {\r\n    lifetime?: number;\r\n    getComparisonTimestamp?: (value: T) => number;\r\n    excludeFromSweep?: (value: T) => boolean;\r\n  } = {}) {\r\n    const lifetime = options.lifetime ?? 14400; // 4 hours default\r\n    const getTimestamp = options.getComparisonTimestamp ?? \r\n      ((v: T) => v.createdTimestamp ?? v.createdAt?.getTime() ?? 0);\r\n    const exclude = options.excludeFromSweep ?? (() => false);\r\n    \r\n    return () => {\r\n      const now = Date.now();\r\n      const cutoff = now - (lifetime * 1000);\r\n      \r\n      return (value: T) => {\r\n        if (exclude(value)) return false;\r\n        const timestamp = getTimestamp(value);\r\n        return timestamp < cutoff;\r\n      };\r\n    };\r\n  },\r\n\r\n  /**\r\n   * Filter that sweeps archived threads\r\n   */\r\n  archivedThreadSweepFilter(lifetime = 14400) {\r\n    return () => {\r\n      const now = Date.now();\r\n      const cutoff = now - (lifetime * 1000);\r\n      \r\n      return (thread: any) => {\r\n        if (!thread.archived) return false;\r\n        const archivedAt = thread.archivedAt?.getTime() ?? thread.archiveTimestamp ?? 0;\r\n        return archivedAt < cutoff;\r\n      };\r\n    };\r\n  },\r\n\r\n  /**\r\n   * Filter that sweeps expired invites\r\n   */\r\n  expiredInviteSweepFilter() {\r\n    return () => {\r\n      const now = Date.now();\r\n      return (invite: any) => {\r\n        if (!invite.expiresAt && !invite.expiresTimestamp) return false;\r\n        const expiresAt = invite.expiresAt?.getTime() ?? invite.expiresTimestamp ?? Infinity;\r\n        return expiresAt < now;\r\n      };\r\n    };\r\n  },\r\n\r\n  /**\r\n   * Filter that sweeps outdated presences\r\n   */\r\n  outdatedPresenceSweepFilter(lifetime = 21600) {\r\n    return () => {\r\n      const now = Date.now();\r\n      const cutoff = now - (lifetime * 1000);\r\n      \r\n      return (presence: any) => {\r\n        const lastUpdate = presence.lastModified ?? presence.updatedAt?.getTime() ?? 0;\r\n        return lastUpdate < cutoff;\r\n      };\r\n    };\r\n  },\r\n\r\n  /**\r\n   * Filter that sweeps all items (use with caution)\r\n   */\r\n  sweepAll() {\r\n    return () => () => true;\r\n  },\r\n\r\n  /**\r\n   * Filter that sweeps nothing\r\n   */\r\n  sweepNone() {\r\n    return () => () => false;\r\n  },\r\n};\r\n\r\n/**\r\n * Sweeper manager class\r\n */\r\nexport class SweeperManager {\r\n  private client: any;\r\n  private intervals: Map<string, NodeJS.Timeout> = new Map();\r\n  private options: SweeperDefinitions;\r\n\r\n  constructor(client: any, options: SweeperDefinitions = {}) {\r\n    this.client = client;\r\n    this.options = options;\r\n  }\r\n\r\n  /**\r\n   * Start all configured sweepers\r\n   */\r\n  start(): void {\r\n    for (const [key, config] of Object.entries(this.options)) {\r\n      if (config && config.interval > 0) {\r\n        this.startSweeper(key as keyof SweeperDefinitions, config);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Start a specific sweeper\r\n   */\r\n  private startSweeper(name: keyof SweeperDefinitions, config: SweeperOptions): void {\r\n    // Clear existing interval if any\r\n    this.stopSweeper(name);\r\n    \r\n    const interval = setInterval(() => {\r\n      this.sweep(name, config.filter);\r\n    }, config.interval * 1000);\r\n    \r\n    this.intervals.set(name, interval);\r\n  }\r\n\r\n  /**\r\n   * Stop a specific sweeper\r\n   */\r\n  stopSweeper(name: keyof SweeperDefinitions): void {\r\n    const interval = this.intervals.get(name);\r\n    if (interval) {\r\n      clearInterval(interval);\r\n      this.intervals.delete(name);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Stop all sweepers\r\n   */\r\n  stop(): void {\r\n    for (const name of this.intervals.keys()) {\r\n      this.stopSweeper(name as keyof SweeperDefinitions);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Manually trigger a sweep\r\n   */\r\n  sweep(name: keyof SweeperDefinitions, filter?: () => (value: any, key: string, collection: Collection<string, any>) => boolean): number {\r\n    const cache = this.getCache(name);\r\n    if (!cache) return 0;\r\n    \r\n    const filterFn = filter ?? this.options[name]?.filter;\r\n    if (!filterFn) return 0;\r\n    \r\n    return cache.sweep(filterFn());\r\n  }\r\n\r\n  /**\r\n   * Get the cache for a sweeper type\r\n   */\r\n  private getCache(name: keyof SweeperDefinitions): Collection<string, any> | null {\r\n    switch (name) {\r\n      case 'users':\r\n        return this.client.users?.cache ?? null;\r\n      case 'guildMembers':\r\n        // Sweep across all guilds\r\n        let memberCount = 0;\r\n        this.client.guilds?.cache.forEach((guild: any) => {\r\n          if (guild.members?.cache) {\r\n            const filter = this.options.guildMembers?.filter;\r\n            if (filter) memberCount += guild.members.cache.sweep(filter());\r\n          }\r\n        });\r\n        return null; // Already handled\r\n      case 'messages':\r\n        // Sweep across all channels\r\n        this.client.channels?.cache.forEach((channel: any) => {\r\n          if (channel.messages?.cache) {\r\n            const filter = this.options.messages?.filter;\r\n            if (filter) channel.messages.cache.sweep(filter());\r\n          }\r\n        });\r\n        return null;\r\n      case 'threads':\r\n        return this.client.channels?.cache.filter((c: any) => c.isThread?.()) ?? null;\r\n      case 'presences':\r\n        // Sweep across all guilds\r\n        this.client.guilds?.cache.forEach((guild: any) => {\r\n          if (guild.presences?.cache) {\r\n            const filter = this.options.presences?.filter;\r\n            if (filter) guild.presences.cache.sweep(filter());\r\n          }\r\n        });\r\n        return null;\r\n      case 'voiceStates':\r\n        this.client.guilds?.cache.forEach((guild: any) => {\r\n          if (guild.voiceStates?.cache) {\r\n            const filter = this.options.voiceStates?.filter;\r\n            if (filter) guild.voiceStates.cache.sweep(filter());\r\n          }\r\n        });\r\n        return null;\r\n      case 'reactions':\r\n        // Sweep reactions from all messages\r\n        this.client.channels?.cache.forEach((channel: any) => {\r\n          channel.messages?.cache.forEach((message: any) => {\r\n            if (message.reactions?.cache) {\r\n              const filter = this.options.reactions?.filter;\r\n              if (filter) message.reactions.cache.sweep(filter());\r\n            }\r\n          });\r\n        });\r\n        return null;\r\n      case 'emojis':\r\n        return this.client.emojis?.cache ?? null;\r\n      case 'stickers':\r\n        return this.client.stickers?.cache ?? null;\r\n      case 'invites':\r\n        // Sweep across all guilds\r\n        this.client.guilds?.cache.forEach((guild: any) => {\r\n          if (guild.invites?.cache) {\r\n            const filter = this.options.invites?.filter;\r\n            if (filter) guild.invites.cache.sweep(filter());\r\n          }\r\n        });\r\n        return null;\r\n      case 'bans':\r\n        this.client.guilds?.cache.forEach((guild: any) => {\r\n          if (guild.bans?.cache) {\r\n            const filter = this.options.bans?.filter;\r\n            if (filter) guild.bans.cache.sweep(filter());\r\n          }\r\n        });\r\n        return null;\r\n      default:\r\n        return null;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get sweeper statistics\r\n   */\r\n  getStats(): Record<string, { interval: number; running: boolean }> {\r\n    const stats: Record<string, { interval: number; running: boolean }> = {};\r\n    \r\n    for (const [name, config] of Object.entries(this.options)) {\r\n      if (config) {\r\n        stats[name] = {\r\n          interval: config.interval,\r\n          running: this.intervals.has(name),\r\n        };\r\n      }\r\n    }\r\n    \r\n    return stats;\r\n  }\r\n}\r\n\r\n/**\r\n * Default sweeper options for common use cases\r\n */\r\nexport const DefaultSweeperOptions: SweeperDefinitions = {\r\n  messages: {\r\n    interval: 3600, // 1 hour\r\n    filter: Sweepers.filterByLifetime({ lifetime: 1800 }), // 30 minutes\r\n  },\r\n  threads: {\r\n    interval: 3600,\r\n    filter: Sweepers.archivedThreadSweepFilter(14400), // 4 hours\r\n  },\r\n  invites: {\r\n    interval: 3600,\r\n    filter: Sweepers.expiredInviteSweepFilter(),\r\n  },\r\n};\r\n\r\nexport default SweeperManager;\r\n"]}

package/dist/utils/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Utility exports
+ */
+export * from './Collection';
+export * from './Formatters';
+export * from './SnowflakeUtil';
+export * from './BitField';
+export * from './PermissionsBitField';
+export * from './IntentsBitField';
+export * from './DataResolver';
+export * from './Collector';
+export * from './Partials';
+export * from './Sweepers';

package/dist/utils/index.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * Utility exports
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Collection"), exports);
+__exportStar(require("./Formatters"), exports);
+__exportStar(require("./SnowflakeUtil"), exports);
+__exportStar(require("./BitField"), exports);
+__exportStar(require("./PermissionsBitField"), exports);
+__exportStar(require("./IntentsBitField"), exports);
+__exportStar(require("./DataResolver"), exports);
+__exportStar(require("./Collector"), exports);
+__exportStar(require("./Partials"), exports);
+__exportStar(require("./Sweepers"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOztHQUVHOzs7Ozs7Ozs7Ozs7Ozs7O0FBRUgsK0NBQTZCO0FBQzdCLCtDQUE2QjtBQUM3QixrREFBZ0M7QUFDaEMsNkNBQTJCO0FBQzNCLHdEQUFzQztBQUN0QyxvREFBa0M7QUFDbEMsaURBQStCO0FBQy9CLDhDQUE0QjtBQUM1Qiw2Q0FBMkI7QUFDM0IsNkNBQTJCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXHJcbiAqIFV0aWxpdHkgZXhwb3J0c1xyXG4gKi9cclxuXHJcbmV4cG9ydCAqIGZyb20gJy4vQ29sbGVjdGlvbic7XHJcbmV4cG9ydCAqIGZyb20gJy4vRm9ybWF0dGVycyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vU25vd2ZsYWtlVXRpbCc7XHJcbmV4cG9ydCAqIGZyb20gJy4vQml0RmllbGQnO1xyXG5leHBvcnQgKiBmcm9tICcuL1Blcm1pc3Npb25zQml0RmllbGQnO1xyXG5leHBvcnQgKiBmcm9tICcuL0ludGVudHNCaXRGaWVsZCc7XHJcbmV4cG9ydCAqIGZyb20gJy4vRGF0YVJlc29sdmVyJztcclxuZXhwb3J0ICogZnJvbSAnLi9Db2xsZWN0b3InO1xyXG5leHBvcnQgKiBmcm9tICcuL1BhcnRpYWxzJztcclxuZXhwb3J0ICogZnJvbSAnLi9Td2VlcGVycyc7XHJcbiJdfQ==