@biggy1337/discord-sbjs 1.3.11

package/src/util/LimitedCollection.js

@@ -0,0 +1,131 @@
+'use strict';
+
+const { setInterval } = require('node:timers');
+const { Collection } = require('@discordjs/collection');
+const { _cleanupSymbol } = require('./Constants.js');
+const Sweepers = require('./Sweepers.js');
+const { TypeError } = require('../errors/DJSError.js');
+
+/**
+ * @typedef {Function} SweepFilter
+ * @param {LimitedCollection} collection The collection being swept
+ * @returns {Function|null} Return `null` to skip sweeping, otherwise a function passed to `sweep()`,
+ * See {@link [Collection#sweep](https://discord.js.org/docs/packages/collection/stable/Collection:Class#sweep)}
+ * for the definition of this function.
+ */
+
+/**
+ * Options for defining the behavior of a LimitedCollection
+ * @typedef {Object} LimitedCollectionOptions
+ * @property {?number} [maxSize=Infinity] The maximum size of the Collection
+ * @property {?Function} [keepOverLimit=null] A function, which is passed the value and key of an entry, ran to decide
+ * to keep an entry past the maximum size
+ * @property {?SweepFilter} [sweepFilter=null] DEPRECATED: There is no direct alternative to this,
+ * however most of its purpose is fulfilled by {@link Client#sweepers}
+ * A function ran every `sweepInterval` to determine how to sweep
+ * @property {?number} [sweepInterval=0] DEPRECATED: There is no direct alternative to this,
+ * however most of its purpose is fulfilled by {@link Client#sweepers}
+ * How frequently, in seconds, to sweep the collection.
+ */
+
+/**
+ * A Collection which holds a max amount of entries and sweeps periodically.
+ * @extends {Collection}
+ * @param {LimitedCollectionOptions} [options={}] Options for constructing the Collection.
+ * @param {Iterable} [iterable=null] Optional entries passed to the Map constructor.
+ */
+class LimitedCollection extends Collection {
+  constructor(options = {}, iterable) {
+    if (typeof options !== 'object' || options === null) {
+      throw new TypeError('INVALID_TYPE', 'options', 'object', true);
+    }
+    const { maxSize = Infinity, keepOverLimit = null, sweepInterval = 0, sweepFilter = null } = options;
+
+    if (typeof maxSize !== 'number') {
+      throw new TypeError('INVALID_TYPE', 'maxSize', 'number');
+    }
+    if (keepOverLimit !== null && typeof keepOverLimit !== 'function') {
+      throw new TypeError('INVALID_TYPE', 'keepOverLimit', 'function');
+    }
+    if (typeof sweepInterval !== 'number') {
+      throw new TypeError('INVALID_TYPE', 'sweepInterval', 'number');
+    }
+    if (sweepFilter !== null && typeof sweepFilter !== 'function') {
+      throw new TypeError('INVALID_TYPE', 'sweepFilter', 'function');
+    }
+
+    super(iterable);
+
+    /**
+     * The max size of the Collection.
+     * @type {number}
+     */
+    this.maxSize = maxSize;
+
+    /**
+     * A function called to check if an entry should be kept when the Collection is at max size.
+     * @type {?Function}
+     */
+    this.keepOverLimit = keepOverLimit;
+
+    /**
+     * A function called every sweep interval that returns a function passed to `sweep`.
+     * @deprecated in favor of {@link Client#sweepers}
+     * @type {?SweepFilter}
+     */
+    this.sweepFilter = sweepFilter;
+
+    /**
+     * The id of the interval being used to sweep.
+     * @deprecated in favor of {@link Client#sweepers}
+     * @type {?Timeout}
+     */
+    this.interval =
+      sweepInterval > 0 && sweepInterval !== Infinity && sweepFilter
+        ? setInterval(() => {
+            const sweepFn = this.sweepFilter(this);
+            if (sweepFn === null) return;
+            if (typeof sweepFn !== 'function') throw new TypeError('SWEEP_FILTER_RETURN');
+            this.sweep(sweepFn);
+          }, sweepInterval * 1_000).unref()
+        : null;
+  }
+
+  set(key, value) {
+    if (this.maxSize === 0) return this;
+    if (this.size >= this.maxSize && !this.has(key)) {
+      for (const [k, v] of this.entries()) {
+        const keep = this.keepOverLimit?.(v, k, this) ?? false;
+        if (!keep) {
+          this.delete(k);
+          break;
+        }
+      }
+    }
+    return super.set(key, value);
+  }
+
+  /**
+   * Create a sweepFilter function that uses a lifetime to determine sweepability.
+   * @param {LifetimeFilterOptions} [options={}] The options used to generate the filter function
+   * @deprecated Use {@link Sweepers.filterByLifetime} instead
+   * @returns {SweepFilter}
+   */
+  static filterByLifetime({
+    lifetime = 14400,
+    getComparisonTimestamp = e => e?.createdTimestamp,
+    excludeFromSweep = () => false,
+  } = {}) {
+    return Sweepers.filterByLifetime({ lifetime, getComparisonTimestamp, excludeFromSweep });
+  }
+
+  [_cleanupSymbol]() {
+    return this.interval ? () => clearInterval(this.interval) : null;
+  }
+
+  static get [Symbol.species]() {
+    return Collection;
+  }
+}
+
+module.exports = LimitedCollection;

package/src/util/ListenerUtil.js

@@ -0,0 +1,12 @@
+'use strict';
+
+function hasListener(emitter, event) {
+  if (!emitter) return false;
+  if (typeof emitter.hasListenerFast === 'function') return emitter.hasListenerFast(event);
+  if (typeof emitter.listenerCount === 'function') return emitter.listenerCount(event) > 0;
+  return false;
+}
+
+module.exports = {
+  hasListener,
+};

package/src/util/MessageFlags.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const BitField = require('./BitField');
+
+/**
+ * Data structure that makes it easy to interact with a {@link Message#flags} bitfield.
+ * @extends {BitField}
+ */
+class MessageFlags extends BitField {}
+
+/**
+ * @name MessageFlags
+ * @kind constructor
+ * @memberof MessageFlags
+ * @param {BitFieldResolvable} [bits=0] Bit(s) to read from
+ */
+
+/**
+ * Bitfield of the packed bits
+ * @type {number}
+ * @name MessageFlags#bitfield
+ */
+
+/**
+ * Numeric message flags. All available properties:
+ * * `CROSSPOSTED`
+ * * `IS_CROSSPOST`
+ * * `SUPPRESS_EMBEDS`
+ * * `SOURCE_MESSAGE_DELETED`
+ * * `URGENT`
+ * * `HAS_THREAD`
+ * * `EPHEMERAL`
+ * * `LOADING`
+ * * `FAILED_TO_MENTION_SOME_ROLES_IN_THREAD`
+ * * `GUILD_FEED_HIDDEN`
+ * * `SHOULD_SHOW_LINK_NOT_DISCORD_WARNING`
+ * * `SUPPRESS_NOTIFICATIONS`
+ * * `IS_VOICE_MESSAGE`
+ * * `HAS_SNAPSHOT`
+ * * `IS_COMPONENTS_V2`
+ * @type {Object}
+ * @see {@link https://discord.com/developers/docs/resources/channel#message-object-message-flags}
+ * @see {@link https://docs.discord.food/resources/message#message-flags}
+ */
+MessageFlags.FLAGS = {
+  CROSSPOSTED: 1 << 0,
+  IS_CROSSPOST: 1 << 1,
+  SUPPRESS_EMBEDS: 1 << 2,
+  SOURCE_MESSAGE_DELETED: 1 << 3,
+  URGENT: 1 << 4,
+  HAS_THREAD: 1 << 5,
+  EPHEMERAL: 1 << 6,
+  LOADING: 1 << 7,
+  FAILED_TO_MENTION_SOME_ROLES_IN_THREAD: 1 << 8,
+  GUILD_FEED_HIDDEN: 1 << 9,
+  SHOULD_SHOW_LINK_NOT_DISCORD_WARNING: 1 << 10,
+  SUPPRESS_NOTIFICATIONS: 1 << 12,
+  IS_VOICE_MESSAGE: 1 << 13,
+  HAS_SNAPSHOT: 1 << 14,
+  IS_COMPONENTS_V2: 1 << 15,
+};
+
+module.exports = MessageFlags;

package/src/util/Options.js

@@ -0,0 +1,431 @@
+'use strict';
+
+const { randomUUID } = require('node:crypto');
+const { UserAgent } = require('./Constants');
+const Intents = require('./Intents');
+
+/**
+ * Rate limit data
+ * @typedef {Object} RateLimitData
+ * @property {number} timeout Time until this rate limit ends, in milliseconds
+ * @property {number} limit The maximum amount of requests of this endpoint
+ * @property {string} method The HTTP method of this request
+ * @property {string} path The path of the request relative to the HTTP endpoint
+ * @property {string} route The route of the request relative to the HTTP endpoint
+ * @property {boolean} global Whether this is a global rate limit
+ */
+
+/**
+ * Whether this rate limit should throw an Error
+ * @typedef {Function} RateLimitQueueFilter
+ * @param {RateLimitData} rateLimitData The data of this rate limit
+ * @returns {boolean|Promise<boolean>}
+ */
+
+/**
+ * @typedef {Function} CacheFactory
+ * @param {Function} manager The manager class the cache is being requested from.
+ * @param {Function} holds The class that the cache will hold.
+ * @returns {Collection} A Collection used to store the cache of the manager.
+ */
+
+/**
+ * @typedef {Function} CaptchaSolver
+ * @param {Captcha} captcha Discord Captcha
+ * @param {string} UserAgent Current UserAgent
+ * @returns {Promise<string>} HCaptcha Token
+ * @example
+ * async function solveCaptcha(captcha, userAgent) {
+ *   const NOPECHA_KEY = process.env.NOPECHA_KEY;
+ *   if (!NOPECHA_KEY) throw new Error('Missing NOPECHA_KEY environment variable');
+ *
+ *   const createPayload = {
+ *     key: NOPECHA_KEY,
+ *     type: 'hcaptcha',
+ *     sitekey: captcha.captcha_sitekey,
+ *     url: 'https://discord.com',
+ *     useragent: userAgent,
+ *   };
+ *
+ *   if (captcha.captcha_rqdata) {
+ *     createPayload.data = { rqdata: captcha.captcha_rqdata };
+ *   }
+ *
+ *   const createRes = await fetch('https://api.nopecha.com/token/', {
+ *     method: 'POST',
+ *     headers: { 'Content-Type': 'application/json' },
+ *     body: JSON.stringify(createPayload),
+ *   });
+ *   const createBody = await createRes.json();
+ *   if (!createRes.ok || createBody?.error) {
+ *     throw new Error(`NopeCHA create failed ${createBody.message}`);
+ *   }
+ *
+ *   const taskId = createBody?.data;
+ *   if (typeof taskId !== 'string' || taskId.length === 0) {
+ *     throw new Error('NopeCHA create failed: missing task id');
+ *   }
+ *
+ *   const timeoutMs = 60_000;
+ *   const pollEveryMs = 2_500;
+ *   const startedAt = Date.now();
+ *
+ *   while (Date.now() - startedAt < timeoutMs) {
+ *     const query = new URLSearchParams({ key: NOPECHA_KEY, id: taskId });
+ *     const pollRes = await fetch(`https://api.nopecha.com/token/?${query.toString()}`);
+ *     const pollBody = await pollRes.json();
+ *
+ *     if (pollBody?.error === 14) {
+ *       await new Promise(resolve => setTimeout(resolve, pollEveryMs));
+ *       continue;
+ *     }
+ *
+ *     if (!pollRes.ok || pollBody?.error) {
+ *       throw new Error(`NopeCHA poll failed ${pollBody.message}`);
+ *     }
+ *
+ *     if (typeof pollBody?.data === 'string' && pollBody.data.length > 0) return pollBody.data;
+ *     throw new Error('NopeCHA poll failed: missing captcha token');
+ *   }
+ *
+ *   throw new Error(`NopeCHA solve timeout after ${timeoutMs}ms`);
+ * }
+ */
+
+/**
+ * Options for a client.
+ * @typedef {Object} ClientOptions
+ * @property {number} [DMChannelVoiceStatusSync=0] The amount of time in milliseconds that the Client to register the event with each DM channel (0=Disable)
+ * @property {number} [captchaRetryLimit=3] Captcha retry limit
+ * @property {CaptchaSolver} [captchaSolver] Captcha Solver
+ * @property {string} [TOTPKey] TOTP key / 2FA Key for two-factor authentication
+ * This is a 32-character Base32 string (excluding spaces), typically shown only once during your 2FA setup (QR code), or in the "Manual Entry" section.
+ * The library automatically removes spaces and converts the secret to uppercase.
+ * Example value: 'ftc3 uz6q 5lpw 2kew 4thr vtyp n2cu topn' or 'WSLIVE6EKYSRMVRBZLFGG2KVIVJMMQY5'
+ * @property {number} [closeTimeout=5000] The amount of time in milliseconds to wait for the close frame to be received
+ * from the WebSocket.
+ * <info>Don't have this too high/low. It's best to have it between 2000-6000 ms.</info>
+ * (e.g. recommended shard count, shard count of the ShardingManager)
+ * @property {CacheFactory} [makeCache] Function to create a cache.
+ * You can use your own function, or the {@link Options} class to customize the Collection used for the cache.
+ * <warn>Overriding the cache used in `GuildManager`, `ChannelManager`, `GuildChannelManager`, `RoleManager`,
+ * and `PermissionOverwriteManager` is unsupported and **will** break functionality</warn>
+ * @property {number} [messageCacheLifetime=0] DEPRECATED: Pass `lifetime` to `sweepers.messages` instead.
+ * How long a message should stay in the cache until it is considered sweepable (in seconds, 0 for forever)
+ * @property {number} [messageSweepInterval=0] DEPRECATED: Pass `interval` to `sweepers.messages` instead.
+ * How frequently to remove messages from the cache that are older than the message cache lifetime
+ * (in seconds, 0 for never)
+ * @property {MessageMentionOptions} [allowedMentions] Default value for {@link MessageOptions#allowedMentions}
+ * @property {number} [invalidRequestWarningInterval=0] The number of invalid REST requests (those that return
+ * 401, 403, or 429) in a 10 minute window between emitted warnings (0 for no warnings). That is, if set to 500,
+ * warnings will be emitted at invalid request number 500, 1000, 1500, and so on.
+ * @property {PartialType[]} [partials=['USER', 'CHANNEL', 'GUILD_MEMBER', 'MESSAGE', 'REACTION', 'GUILD_SCHEDULED_EVENT']] Structures allowed to be partial. This means events can be emitted even when
+ * they're missing all the data for a particular structure. See the "Partial Structures" topic on the
+ * [guide](https://discordjs.guide/popular-topics/partials.html) for some
+ * important usage information, as partials require you to put checks in place when handling data.
+ * @property {number} [restWsBridgeTimeout=5000] Maximum time permitted between REST responses and their
+ * corresponding WebSocket events
+ * @property {number} [restTimeOffset=500] Extra time in milliseconds to wait before continuing to make REST
+ * requests (higher values will reduce rate-limiting errors on bad connections)
+ * @property {number} [restRequestTimeout=15000] Time to wait before cancelling a REST request, in milliseconds
+ * @property {number} [restSweepInterval=60] How frequently to delete inactive request buckets, in seconds
+ * (or 0 for never)
+ * @property {number} [restGlobalRateLimit=50] How many requests to allow sending per second (0 for unlimited, 50 for
+ * the standard global limit used by Discord)
+ * @property {string[]|RateLimitQueueFilter} [rejectOnRateLimit] Decides how rate limits and pre-emptive throttles
+ * should be handled. If this option is an array containing the prefix of the request route (e.g. /channels to match any
+ * route starting with /channels, such as /channels/222197033908436994/messages) or a function returning true, a
+ * {@link RateLimitError} will be thrown. Otherwise the request will be queued for later
+ * @property {number} [retryLimit=1] How many times to retry on 5XX errors
+ * (Infinity for an indefinite amount of retries)
+ * @property {boolean} [failIfNotExists=true] Default value for {@link ReplyMessageOptions#failIfNotExists}
+ * @property {PresenceData} [presence={ status: 'online', since: 0, activities: [], afk: false }] Presence data to use upon login
+ * @property {number} [waitGuildTimeout=15_000] Time in milliseconds that Clients with the GUILDS intent should wait for
+ * missing guilds to be received before starting the bot. If not specified, the default is 15 seconds.
+ * @property {SweeperOptions} [sweepers={}] Options for cache sweeping
+ * @property {WebsocketOptions} [ws] Options for the WebSocket
+ * @property {HTTPOptions} [http] HTTP options
+ */
+
+/**
+ * Options for {@link Sweepers} defining the behavior of cache sweeping
+ * @typedef {Object<SweeperKey, SweepOptions>} SweeperOptions
+ */
+
+/**
+ * Options for sweeping a single type of item from cache
+ * @typedef {Object} SweepOptions
+ * @property {number} interval The interval (in seconds) at which to perform sweeping of the item
+ * @property {number} [lifetime] How long an item should stay in cache until it is considered sweepable.
+ * <warn>This property is only valid for the `invites`, `messages`, and `threads` keys. The `filter` property
+ * is mutually exclusive to this property and takes priority</warn>
+ * @property {GlobalSweepFilter} filter The function used to determine the function passed to the sweep method
+ * <info>This property is optional when the key is `invites`, `messages`, or `threads` and `lifetime` is set</info>
+ */
+
+/**
+ * WebSocket options (these are left as snake_case to match the API)
+ * @typedef {Object} WebsocketOptions
+ * @property {AgentOptions} [agent={}] HTTPS Agent options (WS Proxy)
+ * @property {boolean} [compress=false] Whether to compress data sent on the connection
+ * @property {WebSocketProperties} [properties] Properties to identify the client with
+ */
+
+/**
+ * HTTPS Agent options.
+ * @typedef {Object} AgentOptions
+ * @see {@link https://nodejs.org/api/https.html#https_class_https_agent}
+ * @see {@link https://nodejs.org/api/http.html#http_new_agent_options}
+ */
+
+/**
+ * Proxy options compatible with Bun's fetch `proxy` setting.
+ * @typedef {Object} ProxyAgentOptions
+ */
+
+/**
+ * HTTP options.
+ * The module is designed to be self-contained: by default it uses Bun's native fetch and WebSocket
+ * without external HTTP clients or binaries. All endpoints are configurable.
+ * @typedef {Object} HTTPOptions
+ * @property {number} [version=9] API version to use
+ * @property {ProxyAgentOptions} [agent={}] Proxy options for Bun fetch
+ * @property {Function} [fetch] Optional fetch override. Must match the standard fetch(url, options) signature.
+ * If not provided, uses Bun's native fetch. Use this to inject a custom implementation (e.g. TLS-impersonating
+ * fetch) without adding dependencies to the package.
+ * @property {boolean} [tlsFingerprint=false] Use Impit for TLS fingerprint impersonation (Chrome-like ClientHello).
+ * @property {string} [api='https://discord.com/api'] Base URL of the API
+ * @property {string} [cdn='https://cdn.discordapp.com'] Base URL of the CDN
+ * @property {string} [invite='https://discord.gg'] Base URL of invites
+ * @property {string} [template='https://discord.new'] Base URL of templates
+ * @property {Object} [headers] Additional headers to send for all API requests
+ * @property {string} [scheduledEvent='https://discord.com/events'] Base URL of guild scheduled events
+ */
+
+/**
+ * Contains various utilities for client options.
+ */
+class Options extends null {
+  /**
+   * The default client options.
+   * @returns {ClientOptions}
+   */
+  static createDefault() {
+    return {
+      DMChannelVoiceStatusSync: 0,
+      captchaRetryLimit: 3,
+      captchaSolver: () => {
+        const err = new Error('CAPTCHA_SOLVER_NOT_IMPLEMENTED');
+        err.cause =
+          'You need to provide a captcha solver to use this feature\nExample: const client = new Client({ captchaSolver: yourAsyncFunction })';
+        throw err;
+      },
+      TOTPKey: null,
+      closeTimeout: 5_000,
+      waitGuildTimeout: 15_000,
+      shardCount: 1,
+      shards: [0],
+      makeCache: this.cacheWithLimits(this.defaultMakeCacheSettings),
+      messageCacheLifetime: 0,
+      messageSweepInterval: 0,
+      invalidRequestWarningInterval: 0,
+      intents: Intents.ALL,
+      partials: ['USER', 'CHANNEL', 'GUILD_MEMBER', 'MESSAGE', 'REACTION', 'GUILD_SCHEDULED_EVENT'], // Enable the partials
+      restWsBridgeTimeout: 5_000,
+      restRequestTimeout: 15_000,
+      restGlobalRateLimit: 50,
+      retryLimit: 1,
+      restTimeOffset: 500,
+      restSweepInterval: 60,
+      failIfNotExists: true,
+      presence: { status: 'online', since: 0, activities: [], afk: true },
+      sweepers: this.defaultSweeperSettings,
+      ws: {
+        capabilities: (1 << 2) | (1 << 3) | (1 << 4) | (1 << 10),
+        properties: {
+          os: 'Windows',
+          browser: 'Discord Client',
+          release_channel: 'stable',
+          client_version: '1.0.9210',
+          os_version: '10.0.19045',
+          os_arch: 'x64',
+          app_arch: 'x64',
+          system_locale: 'en-US',
+          has_client_mods: false,
+          client_launch_id: randomUUID(),
+          browser_user_agent: UserAgent,
+          browser_version: '134.0.6998.205',
+          os_sdk_version: '19045',
+          client_build_number: 471091,
+          native_build_number: 72186,
+          client_event_source: null,
+          launch_signature: randomUUID(),
+          client_heartbeat_session_id: randomUUID(),
+          client_app_state: 'focused',
+        },
+        compress: false,
+        useQosHeartbeat: true,
+        client_state: {
+          guild_versions: {},
+        },
+        version: 9,
+        agent: {},
+      },
+      http: {
+        agent: {},
+        tlsFingerprint: false,
+        headers: {
+          'User-Agent': UserAgent,
+        },
+        version: 9,
+        api: 'https://discord.com/api',
+        cdn: 'https://cdn.discordapp.com',
+        invite: 'https://discord.gg',
+        template: 'https://discord.new',
+        scheduledEvent: 'https://discord.com/events',
+      },
+    };
+  }
+
+  /**
+   * Create a cache factory using predefined settings to sweep or limit.
+   * @param {Object<string, LimitedCollectionOptions|number>} [settings={}] Settings passed to the relevant constructor.
+   * If no setting is provided for a manager, it uses Collection.
+   * If a number is provided for a manager, it uses that number as the max size for a LimitedCollection.
+   * If LimitedCollectionOptions are provided for a manager, it uses those settings to form a LimitedCollection.
+   * @returns {CacheFactory}
+   * @example
+   * // Store up to 200 messages per channel and discard archived threads if they were archived more than 4 hours ago.
+   * // Note archived threads will remain in the guild and client caches with these settings
+   * Options.cacheWithLimits({
+   *    MessageManager: 200,
+   *    ThreadManager: {
+   *      sweepInterval: 3600,
+   *      sweepFilter: LimitedCollection.filterByLifetime({
+   *        getComparisonTimestamp: e => e.archiveTimestamp,
+   *        excludeFromSweep: e => !e.archived,
+   *      }),
+   *    },
+   *  });
+   * @example
+   * // Sweep messages every 5 minutes, removing messages that have not been edited or created in the last 30 minutes
+   * Options.cacheWithLimits({
+   *   // Keep default thread sweeping behavior
+   *   ...Options.defaultMakeCacheSettings,
+   *   // Override MessageManager
+   *   MessageManager: {
+   *     sweepInterval: 300,
+   *     sweepFilter: LimitedCollection.filterByLifetime({
+   *       lifetime: 1800,
+   *       getComparisonTimestamp: e => e.editedTimestamp ?? e.createdTimestamp,
+   *     })
+   *   }
+   * });
+   */
+  static cacheWithLimits(settings = {}) {
+    const { Collection } = require('@discordjs/collection');
+    const LimitedCollection = require('./LimitedCollection');
+
+    return manager => {
+      const setting = settings[manager.name];
+      /* eslint-disable-next-line eqeqeq */
+      if (setting == null) {
+        return new Collection();
+      }
+      if (typeof setting === 'number') {
+        if (setting === Infinity) {
+          return new Collection();
+        }
+        return new LimitedCollection({ maxSize: setting });
+      }
+      /* eslint-disable eqeqeq */
+      const noSweeping =
+        setting.sweepFilter == null ||
+        setting.sweepInterval == null ||
+        setting.sweepInterval <= 0 ||
+        setting.sweepInterval === Infinity;
+      const noLimit = setting.maxSize == null || setting.maxSize === Infinity;
+      /* eslint-enable eqeqeq */
+      if (noSweeping && noLimit) {
+        return new Collection();
+      }
+      return new LimitedCollection(setting);
+    };
+  }
+
+  /**
+   * Create a cache factory that always caches everything.
+   * @returns {CacheFactory}
+   */
+  static cacheEverything() {
+    const { Collection } = require('@discordjs/collection');
+    return () => new Collection();
+  }
+
+  /**
+   * The default settings passed to {@link ClientOptions.makeCache}.
+   * The caches that this changes are bounded to prevent unbounded growth.
+   * <info>If you want to keep default behavior and add on top of it you can use this object and add on to it, e.g.
+   * `makeCache: Options.cacheWithLimits({ ...Options.defaultMakeCacheSettings, ReactionManager: 0 })`</info>
+   * @type {Object<string, LimitedCollectionOptions|number>}
+   */
+  static get defaultMakeCacheSettings() {
+    return {
+      ApplicationCommandManager: 0,
+      AutoModerationRuleManager: 0,
+      BaseGuildEmojiManager: 0,
+      GuildEmojiManager: 0,
+      GuildMemberManager: 120,
+      GuildBanManager: 0,
+      GuildInviteManager: 0,
+      GuildScheduledEventManager: 0,
+      GuildStickerManager: 0,
+      MessageManager: 60,
+      PresenceManager: 0,
+      ReactionManager: 0,
+      ReactionUserManager: 0,
+      StageInstanceManager: 0,
+      ThreadManager: 25,
+      ThreadMemberManager: 0,
+      UserManager: 350,
+      VoiceStateManager: 0,
+    };
+  }
+}
+
+/**
+ * The default settings passed to {@link ClientOptions.sweepers}.
+ * The sweepers that this changes are:
+ * * `threads` - Sweep archived threads every hour, removing those archived more than 4 hours ago
+ * <info>If you want to keep default behavior and add on top of it you can use this object and add on to it, e.g.
+ * `sweepers: { ...Options.defaultSweeperSettings, messages: { interval: 300, lifetime: 600 } }`</info>
+ * @type {SweeperOptions}
+ */
+Options.defaultSweeperSettings = {
+  messages: {
+    interval: 180,
+    lifetime: 240,
+  },
+  users: {
+    interval: 600,
+    filter: () => user => user.id !== user.client.user?.id,
+  },
+  guildMembers: {
+    interval: 600,
+    filter: () => member => member.id !== member.client.user?.id,
+  },
+  presences: {
+    interval: 300,
+    filter: () => presence => presence.userId !== presence.client.user?.id,
+  },
+  voiceStates: {
+    interval: 300,
+    filter: () => voiceState => voiceState.id !== voiceState.client.user?.id,
+  },
+  threads: {
+    interval: 600,
+    lifetime: 1800,
+  },
+};
+
+module.exports = Options;