@jubbio/core 1.3.1 → 1.3.2

package/dist/cjs/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/cjs/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,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

package/dist/cjs/utils/Sweepers.d.ts

@@ -0,0 +1,119 @@
+/**
+ * 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 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 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/cjs/utils/Sweepers.js

@@ -0,0 +1,249 @@
+"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 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 '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
+    },
+    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":["/**\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/cjs/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/cjs/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOztHQUVHOzs7Ozs7Ozs7Ozs7Ozs7O0FBRUgsK0NBQTZCO0FBQzdCLCtDQUE2QjtBQUM3QixrREFBZ0M7QUFDaEMsNkNBQTJCO0FBQzNCLHdEQUFzQztBQUN0QyxvREFBa0M7QUFDbEMsaURBQStCO0FBQy9CLDhDQUE0QjtBQUM1Qiw2Q0FBMkI7QUFDM0IsNkNBQTJCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBVdGlsaXR5IGV4cG9ydHNcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL0NvbGxlY3Rpb24nO1xuZXhwb3J0ICogZnJvbSAnLi9Gb3JtYXR0ZXJzJztcbmV4cG9ydCAqIGZyb20gJy4vU25vd2ZsYWtlVXRpbCc7XG5leHBvcnQgKiBmcm9tICcuL0JpdEZpZWxkJztcbmV4cG9ydCAqIGZyb20gJy4vUGVybWlzc2lvbnNCaXRGaWVsZCc7XG5leHBvcnQgKiBmcm9tICcuL0ludGVudHNCaXRGaWVsZCc7XG5leHBvcnQgKiBmcm9tICcuL0RhdGFSZXNvbHZlcic7XG5leHBvcnQgKiBmcm9tICcuL0NvbGxlY3Rvcic7XG5leHBvcnQgKiBmcm9tICcuL1BhcnRpYWxzJztcbmV4cG9ydCAqIGZyb20gJy4vU3dlZXBlcnMnO1xuIl19