@jubbio/core 1.3.1 → 1.3.2

package/dist/esm/utils/PermissionsBitField.js

@@ -0,0 +1,141 @@
+import { PermissionFlagsBits } from '../enums';
+/**
+ * Bit field for permissions
+ * API compatible with Discord.js PermissionsBitField
+ */
+export class PermissionsBitField {
+    /** The raw bits */
+    bitfield;
+    /** All permission flags */
+    static Flags = PermissionFlagsBits;
+    /** All permissions combined */
+    static All = Object.values(PermissionFlagsBits).reduce((acc, val) => acc | val, 0n);
+    /** Default permissions */
+    static Default = BigInt(0);
+    constructor(bits = 0n) {
+        this.bitfield = PermissionsBitField.resolve(bits);
+    }
+    /**
+     * Check if this bitfield has a permission
+     */
+    has(permission, checkAdmin = true) {
+        // Admin has all permissions
+        if (checkAdmin && this.bitfield & PermissionFlagsBits.Administrator) {
+            return true;
+        }
+        const bit = PermissionsBitField.resolve(permission);
+        return (this.bitfield & bit) === bit;
+    }
+    /**
+     * Check if this bitfield has any of the permissions
+     */
+    any(permissions, checkAdmin = true) {
+        // Admin has all permissions
+        if (checkAdmin && this.bitfield & PermissionFlagsBits.Administrator) {
+            return true;
+        }
+        const bit = PermissionsBitField.resolve(permissions);
+        return (this.bitfield & bit) !== 0n;
+    }
+    /**
+     * Check if this bitfield is missing any permissions
+     */
+    missing(permissions, checkAdmin = true) {
+        const missing = [];
+        for (const [name, bit] of Object.entries(PermissionFlagsBits)) {
+            const resolved = PermissionsBitField.resolve(permissions);
+            if ((resolved & bit) && !this.has(bit, checkAdmin)) {
+                missing.push(name);
+            }
+        }
+        return missing;
+    }
+    /**
+     * Add permissions to this bitfield
+     */
+    add(...permissions) {
+        for (const permission of permissions) {
+            this.bitfield |= PermissionsBitField.resolve(permission);
+        }
+        return this;
+    }
+    /**
+     * Remove permissions from this bitfield
+     */
+    remove(...permissions) {
+        for (const permission of permissions) {
+            this.bitfield &= ~PermissionsBitField.resolve(permission);
+        }
+        return this;
+    }
+    /**
+     * Serialize this bitfield to an array of permission names
+     */
+    toArray() {
+        const result = [];
+        for (const [name, bit] of Object.entries(PermissionFlagsBits)) {
+            if (this.bitfield & bit) {
+                result.push(name);
+            }
+        }
+        return result;
+    }
+    /**
+     * Serialize this bitfield to a JSON-compatible value
+     */
+    toJSON() {
+        return this.bitfield.toString();
+    }
+    /**
+     * Get the string representation
+     */
+    toString() {
+        return this.bitfield.toString();
+    }
+    /**
+     * Freeze this bitfield
+     */
+    freeze() {
+        return Object.freeze(this);
+    }
+    /**
+     * Check equality with another bitfield
+     */
+    equals(other) {
+        return this.bitfield === PermissionsBitField.resolve(other);
+    }
+    /**
+     * Create a new bitfield with the same bits
+     */
+    clone() {
+        return new PermissionsBitField(this.bitfield);
+    }
+    /**
+     * Resolve a permission to a bigint
+     */
+    static resolve(permission) {
+        if (typeof permission === 'bigint') {
+            return permission;
+        }
+        if (permission instanceof PermissionsBitField) {
+            return permission.bitfield;
+        }
+        if (typeof permission === 'string') {
+            const bit = PermissionFlagsBits[permission];
+            if (bit === undefined) {
+                throw new Error(`Unknown permission: ${permission}`);
+            }
+            return bit;
+        }
+        if (Array.isArray(permission)) {
+            let result = 0n;
+            for (const p of permission) {
+                result |= PermissionsBitField.resolve(p);
+            }
+            return result;
+        }
+        throw new Error(`Invalid permission: ${permission}`);
+    }
+}
+export default PermissionsBitField;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PermissionsBitField.js","sourceRoot":"","sources":["../../../src/utils/PermissionsBitField.ts"],"names":[],"mappings":"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","sourcesContent":["import { PermissionFlagsBits } from '../enums';\n\n/**\n * Permission names type\n */\nexport type PermissionString = keyof typeof PermissionFlagsBits;\n\n/**\n * Resolvable permission type\n */\nexport type PermissionResolvable = \n  | bigint \n  | bigint[] \n  | PermissionString \n  | PermissionString[] \n  | PermissionsBitField;\n\n/**\n * Bit field for permissions\n * API compatible with Discord.js PermissionsBitField\n */\nexport class PermissionsBitField {\n  /** The raw bits */\n  public bitfield: bigint;\n\n  /** All permission flags */\n  static Flags = PermissionFlagsBits;\n\n  /** All permissions combined */\n  static All = Object.values(PermissionFlagsBits).reduce((acc, val) => acc | val, 0n);\n\n  /** Default permissions */\n  static Default = BigInt(0);\n\n  constructor(bits: PermissionResolvable = 0n) {\n    this.bitfield = PermissionsBitField.resolve(bits);\n  }\n\n  /**\n   * Check if this bitfield has a permission\n   */\n  has(permission: PermissionResolvable, checkAdmin = true): boolean {\n    // Admin has all permissions\n    if (checkAdmin && this.bitfield & PermissionFlagsBits.Administrator) {\n      return true;\n    }\n\n    const bit = PermissionsBitField.resolve(permission);\n    return (this.bitfield & bit) === bit;\n  }\n\n  /**\n   * Check if this bitfield has any of the permissions\n   */\n  any(permissions: PermissionResolvable, checkAdmin = true): boolean {\n    // Admin has all permissions\n    if (checkAdmin && this.bitfield & PermissionFlagsBits.Administrator) {\n      return true;\n    }\n\n    const bit = PermissionsBitField.resolve(permissions);\n    return (this.bitfield & bit) !== 0n;\n  }\n\n  /**\n   * Check if this bitfield is missing any permissions\n   */\n  missing(permissions: PermissionResolvable, checkAdmin = true): PermissionString[] {\n    const missing: PermissionString[] = [];\n    \n    for (const [name, bit] of Object.entries(PermissionFlagsBits)) {\n      const resolved = PermissionsBitField.resolve(permissions);\n      if ((resolved & bit) && !this.has(bit, checkAdmin)) {\n        missing.push(name as PermissionString);\n      }\n    }\n    \n    return missing;\n  }\n\n  /**\n   * Add permissions to this bitfield\n   */\n  add(...permissions: PermissionResolvable[]): this {\n    for (const permission of permissions) {\n      this.bitfield |= PermissionsBitField.resolve(permission);\n    }\n    return this;\n  }\n\n  /**\n   * Remove permissions from this bitfield\n   */\n  remove(...permissions: PermissionResolvable[]): this {\n    for (const permission of permissions) {\n      this.bitfield &= ~PermissionsBitField.resolve(permission);\n    }\n    return this;\n  }\n\n  /**\n   * Serialize this bitfield to an array of permission names\n   */\n  toArray(): PermissionString[] {\n    const result: PermissionString[] = [];\n    \n    for (const [name, bit] of Object.entries(PermissionFlagsBits)) {\n      if (this.bitfield & bit) {\n        result.push(name as PermissionString);\n      }\n    }\n    \n    return result;\n  }\n\n  /**\n   * Serialize this bitfield to a JSON-compatible value\n   */\n  toJSON(): string {\n    return this.bitfield.toString();\n  }\n\n  /**\n   * Get the string representation\n   */\n  toString(): string {\n    return this.bitfield.toString();\n  }\n\n  /**\n   * Freeze this bitfield\n   */\n  freeze(): Readonly<this> {\n    return Object.freeze(this);\n  }\n\n  /**\n   * Check equality with another bitfield\n   */\n  equals(other: PermissionResolvable): boolean {\n    return this.bitfield === PermissionsBitField.resolve(other);\n  }\n\n  /**\n   * Create a new bitfield with the same bits\n   */\n  clone(): PermissionsBitField {\n    return new PermissionsBitField(this.bitfield);\n  }\n\n  /**\n   * Resolve a permission to a bigint\n   */\n  static resolve(permission: PermissionResolvable): bigint {\n    if (typeof permission === 'bigint') {\n      return permission;\n    }\n\n    if (permission instanceof PermissionsBitField) {\n      return permission.bitfield;\n    }\n\n    if (typeof permission === 'string') {\n      const bit = PermissionFlagsBits[permission as PermissionString];\n      if (bit === undefined) {\n        throw new Error(`Unknown permission: ${permission}`);\n      }\n      return bit;\n    }\n\n    if (Array.isArray(permission)) {\n      let result = 0n;\n      for (const p of permission) {\n        result |= PermissionsBitField.resolve(p);\n      }\n      return result;\n    }\n\n    throw new Error(`Invalid permission: ${permission}`);\n  }\n}\n\nexport default PermissionsBitField;\n"]}

package/dist/esm/utils/SnowflakeUtil.js

@@ -0,0 +1,89 @@
+/**
+ * Snowflake utilities
+ * API compatible with Discord.js SnowflakeUtil
+ */
+// Jubbio epoch (same as Discord: 2015-01-01T00:00:00.000Z)
+const EPOCH = 1420070400000n;
+/**
+ * A container for useful snowflake-related methods
+ */
+export 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;
+        }
+    }
+}
+// Export as default too for convenience
+export default SnowflakeUtil;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/utils/Sweepers.js

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

package/dist/esm/utils/index.js

@@ -0,0 +1,14 @@
+/**
+ * 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';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsWUFBWSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBVdGlsaXR5IGV4cG9ydHNcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL0NvbGxlY3Rpb24nO1xuZXhwb3J0ICogZnJvbSAnLi9Gb3JtYXR0ZXJzJztcbmV4cG9ydCAqIGZyb20gJy4vU25vd2ZsYWtlVXRpbCc7XG5leHBvcnQgKiBmcm9tICcuL0JpdEZpZWxkJztcbmV4cG9ydCAqIGZyb20gJy4vUGVybWlzc2lvbnNCaXRGaWVsZCc7XG5leHBvcnQgKiBmcm9tICcuL0ludGVudHNCaXRGaWVsZCc7XG5leHBvcnQgKiBmcm9tICcuL0RhdGFSZXNvbHZlcic7XG5leHBvcnQgKiBmcm9tICcuL0NvbGxlY3Rvcic7XG5leHBvcnQgKiBmcm9tICcuL1BhcnRpYWxzJztcbmV4cG9ydCAqIGZyb20gJy4vU3dlZXBlcnMnO1xuIl19

package/package.json

@@ -1,16 +1,26 @@
 {
   "name": "@jubbio/core",
-  "version": "1.3.1",
+  "version": "1.3.2",
   "description": "Core library for Jubbio bots",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/cjs/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "types": "./dist/cjs/index.d.ts"
+    }
+  },
   "files": [
     "dist",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "npm run build:cjs && npm run build:esm",
+    "build:cjs": "tsc -p tsconfig.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
     "dev": "tsc --watch",
     "prepublishOnly": "npm run build"
   },