discord.js-seflbot-v13 1.1.0

package/src/structures/WidgetMember.js

@@ -0,0 +1,99 @@
+'use strict';
+
+const Base = require('./Base');
+
+/**
+ * Represents a WidgetMember.
+ * @extends {Base}
+ */
+class WidgetMember extends Base {
+  /**
+   * Activity sent in a {@link WidgetMember}.
+   * @typedef {Object} WidgetActivity
+   * @property {string} name The name of the activity
+   */
+
+  constructor(client, data) {
+    super(client);
+
+    /**
+     * The id of the user. It's an arbitrary number.
+     * @type {string}
+     */
+    this.id = data.id;
+
+    /**
+     * The username of the member.
+     * @type {string}
+     */
+    this.username = data.username;
+
+    /**
+     * The discriminator of the member.
+     * @type {string}
+     */
+    this.discriminator = data.discriminator;
+
+    /**
+     * The avatar of the member.
+     * @type {?string}
+     */
+    this.avatar = data.avatar;
+
+    /**
+     * The status of the member.
+     * @type {PresenceStatus}
+     */
+    this.status = data.status;
+
+    /**
+     * If the member is server deafened
+     * @type {?boolean}
+     */
+    this.deaf = data.deaf ?? null;
+
+    /**
+     * If the member is server muted
+     * @type {?boolean}
+     */
+    this.mute = data.mute ?? null;
+
+    /**
+     * If the member is self deafened
+     * @type {?boolean}
+     */
+    this.selfDeaf = data.self_deaf ?? null;
+
+    /**
+     * If the member is self muted
+     * @type {?boolean}
+     */
+    this.selfMute = data.self_mute ?? null;
+
+    /**
+     * If the member is suppressed
+     * @type {?boolean}
+     */
+    this.suppress = data.suppress ?? null;
+
+    /**
+     * The id of the voice channel the member is in, if any
+     * @type {?Snowflake}
+     */
+    this.channelId = data.channel_id ?? null;
+
+    /**
+     * The avatar URL of the member.
+     * @type {string}
+     */
+    this.avatarURL = data.avatar_url;
+
+    /**
+     * The activity of the member.
+     * @type {?WidgetActivity}
+     */
+    this.activity = data.activity ?? null;
+  }
+}
+
+module.exports = WidgetMember;

package/src/structures/interfaces/Application.js

@@ -0,0 +1,190 @@
+'use strict';
+
+const process = require('node:process');
+const { ClientApplicationAssetTypes, Endpoints } = require('../../util/Constants');
+const Permissions = require('../../util/Permissions');
+const SnowflakeUtil = require('../../util/SnowflakeUtil');
+const Base = require('../Base');
+
+const AssetTypes = Object.keys(ClientApplicationAssetTypes);
+
+let deprecationEmittedForFetchAssets = false;
+
+/**
+ * Represents an OAuth2 Application.
+ * @extends {Base}
+ * @abstract
+ */
+class Application extends Base {
+  constructor(client, data) {
+    super(client);
+    this._patch(data);
+  }
+
+  _patch(data) {
+    /**
+     * The application's id
+     * @type {Snowflake}
+     */
+    this.id = data.id;
+
+    if ('name' in data) {
+      /**
+       * The name of the application
+       * @type {?string}
+       */
+      this.name = data.name;
+    } else {
+      this.name ??= null;
+    }
+
+    if ('description' in data) {
+      /**
+       * The application's description
+       * @type {?string}
+       */
+      this.description = data.description;
+    } else {
+      this.description ??= null;
+    }
+
+    if ('icon' in data) {
+      /**
+       * The application's icon hash
+       * @type {?string}
+       */
+      this.icon = data.icon;
+    } else {
+      this.icon ??= null;
+    }
+
+    if ('role_connections_verification_url' in data) {
+      /**
+       * This application's role connection verification entry point URL
+       * @type {?string}
+       */
+      this.roleConnectionsVerificationURL = data.role_connections_verification_url;
+    } else {
+      this.roleConnectionsVerificationURL ??= null;
+    }
+  }
+
+  /**
+   * The timestamp the application was created at
+   * @type {number}
+   * @readonly
+   */
+  get createdTimestamp() {
+    return SnowflakeUtil.timestampFrom(this.id);
+  }
+
+  /**
+   * The time the application was created at
+   * @type {Date}
+   * @readonly
+   */
+  get createdAt() {
+    return new Date(this.createdTimestamp);
+  }
+
+  /**
+   * Invites this application to a guild / server
+   * @param {Snowflake} guild_id The id of the guild that you want to invite the bot to
+   * @param {PermissionResolvable} [permissions] The permissions for the bot in number form (the default is 8 / Administrator)
+   * @param {string} [captcha] The captcha key to add
+   * @returns {Promise<void>} nothing :)
+   */
+  async invite(guild_id, permissions, captcha = null) {
+    permissions = Permissions.resolve(permissions || 0n);
+    const postData = {
+      authorize: true,
+      guild_id,
+      permissions: '0',
+    };
+    if (permissions) {
+      postData.permissions = permissions;
+    }
+    if (captcha && typeof captcha === 'string' && captcha.length > 0) {
+      postData.captcha = captcha;
+    }
+    await this.client.api.oauth2.authorize.post({
+      query: {
+        client_id: this.id,
+        scope: 'bot applications.commands',
+      },
+      data: postData,
+      headers: {
+        referer: `https://discord.com/oauth2/authorize?client_id=${this.id}&permissions=${permissions}&scope=bot`,
+      },
+    });
+  }
+
+  /**
+   * A link to the application's icon.
+   * @param {StaticImageURLOptions} [options={}] Options for the Image URL
+   * @returns {?string}
+   */
+  iconURL({ format, size } = {}) {
+    if (!this.icon) return null;
+    return this.client.rest.cdn.AppIcon(this.id, this.icon, { format, size });
+  }
+
+  /**
+   * A link to this application's cover image.
+   * @param {StaticImageURLOptions} [options={}] Options for the Image URL
+   * @returns {?string}
+   */
+  coverURL({ format, size } = {}) {
+    if (!this.cover) return null;
+    return Endpoints.CDN(this.client.options.http.cdn).AppIcon(this.id, this.cover, { format, size });
+  }
+
+  /**
+   * Asset data.
+   * @typedef {Object} ApplicationAsset
+   * @property {Snowflake} id The asset's id
+   * @property {string} name The asset's name
+   * @property {string} type The asset's type
+   */
+
+  /**
+   * Gets the application's rich presence assets.
+   * @returns {Promise<Array<ApplicationAsset>>}
+   * @deprecated This will be removed in the next major as it is unsupported functionality.
+   */
+  async fetchAssets() {
+    if (!deprecationEmittedForFetchAssets) {
+      process.emitWarning(
+        'Application#fetchAssets is deprecated as it is unsupported and will be removed in the next major version.',
+        'DeprecationWarning',
+      );
+
+      deprecationEmittedForFetchAssets = true;
+    }
+
+    const assets = await this.client.api.oauth2.applications(this.id).assets.get();
+    return assets.map(a => ({
+      id: a.id,
+      name: a.name,
+      type: AssetTypes[a.type - 1],
+    }));
+  }
+
+  /**
+   * When concatenated with a string, this automatically returns the application's name instead of the
+   * Application object.
+   * @returns {?string}
+   * @example
+   * // Logs: Application name: My App
+   * console.log(`Application name: ${application}`);
+   */
+  toString() {
+    return this.name;
+  }
+
+  toJSON() {
+    return super.toJSON({ createdTimestamp: true });
+  }
+}
+
+module.exports = Application;

package/src/structures/interfaces/Collector.js

@@ -0,0 +1,300 @@
+'use strict';
+
+const EventEmitter = require('node:events');
+const { setTimeout } = require('node:timers');
+const { Collection } = require('@discordjs/collection');
+const { TypeError } = require('../../errors');
+const Util = require('../../util/Util');
+
+/**
+ * Filter to be applied to the collector.
+ * @typedef {Function} CollectorFilter
+ * @param {...*} args Any arguments received by the listener
+ * @param {Collection} collection The items collected by this collector
+ * @returns {boolean|Promise<boolean>}
+ */
+
+/**
+ * Options to be applied to the collector.
+ * @typedef {Object} CollectorOptions
+ * @property {CollectorFilter} [filter] The filter applied to this collector
+ * @property {number} [time] How long to run the collector for in milliseconds
+ * @property {number} [idle] How long to stop the collector after inactivity in milliseconds
+ * @property {boolean} [dispose=false] Whether to dispose data when it's deleted
+ */
+
+/**
+ * Abstract class for defining a new Collector.
+ * @extends {EventEmitter}
+ * @abstract
+ */
+class Collector extends EventEmitter {
+  constructor(client, options = {}) {
+    super();
+
+    /**
+     * The client that instantiated this Collector
+     * @name Collector#client
+     * @type {Client}
+     * @readonly
+     */
+    Object.defineProperty(this, 'client', { value: client });
+
+    /**
+     * The filter applied to this collector
+     * @type {CollectorFilter}
+     * @returns {boolean|Promise<boolean>}
+     */
+    this.filter = options.filter ?? (() => true);
+
+    /**
+     * The options of this collector
+     * @type {CollectorOptions}
+     */
+    this.options = options;
+
+    /**
+     * The items collected by this collector
+     * @type {Collection}
+     */
+    this.collected = new Collection();
+
+    /**
+     * Whether this collector has finished collecting
+     * @type {boolean}
+     */
+    this.ended = false;
+
+    /**
+     * Timeout for cleanup
+     * @type {?Timeout}
+     * @private
+     */
+    this._timeout = null;
+
+    /**
+     * Timeout for cleanup due to inactivity
+     * @type {?Timeout}
+     * @private
+     */
+    this._idletimeout = null;
+
+    if (typeof this.filter !== 'function') {
+      throw new TypeError('INVALID_TYPE', 'options.filter', 'function');
+    }
+
+    this.handleCollect = this.handleCollect.bind(this);
+    this.handleDispose = this.handleDispose.bind(this);
+
+    if (options.time) this._timeout = setTimeout(() => this.stop('time'), options.time).unref();
+    if (options.idle) this._idletimeout = setTimeout(() => this.stop('idle'), options.idle).unref();
+  }
+
+  /**
+   * Call this to handle an event as a collectable element. Accepts any event data as parameters.
+   * @param {...*} args The arguments emitted by the listener
+   * @returns {Promise<void>}
+   * @emits Collector#collect
+   */
+  async handleCollect(...args) {
+    const collect = await this.collect(...args);
+
+    if (collect && (await this.filter(...args, this.collected))) {
+      this.collected.set(collect, args[0]);
+
+      /**
+       * Emitted whenever an element is collected.
+       * @event Collector#collect
+       * @param {...*} args The arguments emitted by the listener
+       */
+      this.emit('collect', ...args);
+
+      if (this._idletimeout) {
+        clearTimeout(this._idletimeout);
+        this._idletimeout = setTimeout(() => this.stop('idle'), this.options.idle).unref();
+      }
+    }
+    this.checkEnd();
+  }
+
+  /**
+   * Call this to remove an element from the collection. Accepts any event data as parameters.
+   * @param {...*} args The arguments emitted by the listener
+   * @returns {Promise<void>}
+   * @emits Collector#dispose
+   */
+  async handleDispose(...args) {
+    if (!this.options.dispose) return;
+
+    const dispose = this.dispose(...args);
+    if (!dispose || !(await this.filter(...args)) || !this.collected.has(dispose)) return;
+    this.collected.delete(dispose);
+
+    /**
+     * Emitted whenever an element is disposed of.
+     * @event Collector#dispose
+     * @param {...*} args The arguments emitted by the listener
+     */
+    this.emit('dispose', ...args);
+    this.checkEnd();
+  }
+
+  /**
+   * Returns a promise that resolves with the next collected element;
+   * rejects with collected elements if the collector finishes without receiving a next element
+   * @type {Promise}
+   * @readonly
+   */
+  get next() {
+    return new Promise((resolve, reject) => {
+      if (this.ended) {
+        reject(this.collected);
+        return;
+      }
+
+      const cleanup = () => {
+        this.removeListener('collect', onCollect);
+        this.removeListener('end', onEnd);
+      };
+
+      const onCollect = item => {
+        cleanup();
+        resolve(item);
+      };
+
+      const onEnd = () => {
+        cleanup();
+        reject(this.collected); // eslint-disable-line prefer-promise-reject-errors
+      };
+
+      this.on('collect', onCollect);
+      this.on('end', onEnd);
+    });
+  }
+
+  /**
+   * Stops this collector and emits the `end` event.
+   * @param {string} [reason='user'] The reason this collector is ending
+   * @emits Collector#end
+   */
+  stop(reason = 'user') {
+    if (this.ended) return;
+
+    if (this._timeout) {
+      clearTimeout(this._timeout);
+      this._timeout = null;
+    }
+    if (this._idletimeout) {
+      clearTimeout(this._idletimeout);
+      this._idletimeout = null;
+    }
+    this.ended = true;
+
+    /**
+     * Emitted when the collector is finished collecting.
+     * @event Collector#end
+     * @param {Collection} collected The elements collected by the collector
+     * @param {string} reason The reason the collector ended
+     */
+    this.emit('end', this.collected, reason);
+  }
+
+  /**
+   * Options used to reset the timeout and idle timer of a {@link Collector}.
+   * @typedef {Object} CollectorResetTimerOptions
+   * @property {number} [time] How long to run the collector for (in milliseconds)
+   * @property {number} [idle] How long to wait to stop the collector after inactivity (in milliseconds)
+   */
+
+  /**
+   * Resets the collector's timeout and idle timer.
+   * @param {CollectorResetTimerOptions} [options] Options for resetting
+   */
+  resetTimer({ time, idle } = {}) {
+    if (this._timeout) {
+      clearTimeout(this._timeout);
+      this._timeout = setTimeout(() => this.stop('time'), time ?? this.options.time).unref();
+    }
+    if (this._idletimeout) {
+      clearTimeout(this._idletimeout);
+      this._idletimeout = setTimeout(() => this.stop('idle'), idle ?? this.options.idle).unref();
+    }
+  }
+
+  /**
+   * Checks whether the collector should end, and if so, ends it.
+   * @returns {boolean} Whether the collector ended or not
+   */
+  checkEnd() {
+    const reason = this.endReason;
+    if (reason) this.stop(reason);
+    return Boolean(reason);
+  }
+
+  /**
+   * Allows collectors to be consumed with for-await-of loops
+   * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of}
+   */
+  async *[Symbol.asyncIterator]() {
+    const queue = [];
+    const onCollect = item => queue.push(item);
+    this.on('collect', onCollect);
+
+    try {
+      while (queue.length || !this.ended) {
+        if (queue.length) {
+          yield queue.shift();
+        } else {
+          // eslint-disable-next-line no-await-in-loop
+          await new Promise(resolve => {
+            const tick = () => {
+              this.removeListener('collect', tick);
+              this.removeListener('end', tick);
+              return resolve();
+            };
+            this.on('collect', tick);
+            this.on('end', tick);
+          });
+        }
+      }
+    } finally {
+      this.removeListener('collect', onCollect);
+    }
+  }
+
+  toJSON() {
+    return Util.flatten(this);
+  }
+
+  /* eslint-disable no-empty-function */
+  /**
+   * The reason this collector has ended with, or null if it hasn't ended yet
+   * @type {?string}
+   * @readonly
+   * @abstract
+   */
+  get endReason() {}
+
+  /**
+   * Handles incoming events from the `handleCollect` function. Returns null if the event should not
+   * be collected, or returns an object describing the data that should be stored.
+   * @see Collector#handleCollect
+   * @param {...*} args Any args the event listener emits
+   * @returns {?(*|Promise<?*>)} Data to insert into collection, if any
+   * @abstract
+   */
+  collect() {}
+
+  /**
+   * Handles incoming events from the `handleDispose`. Returns null if the event should not
+   * be disposed, or returns the key that should be removed.
+   * @see Collector#handleDispose
+   * @param {...*} args Any args the event listener emits
+   * @returns {?*} Key to remove from the collection, if any
+   * @abstract
+   */
+  dispose() {}
+  /* eslint-enable no-empty-function */
+}
+
+module.exports = Collector;