@ovencord/discord.js 14.16.3

package/src/structures/ThreadMember.ts

@@ -0,0 +1,125 @@
+import { ThreadMemberFlagsBitField  } from '../util/ThreadMemberFlagsBitField.js';
+import { Base  } from './Base.js';
+
+/**
+ * Represents a Member for a Thread.
+ *
+ * @extends {Base}
+ */
+export class ThreadMember extends Base {
+  public thread: any;
+  public joinedTimestamp: any;
+  public flags: any;
+  public id: any;
+  public member: any;
+  constructor(thread, data, extra = {}) {
+    super(thread.client);
+
+    /**
+     * The thread that this member is a part of
+     *
+     * @type {ThreadChannel}
+     */
+    this.thread = thread;
+
+    /**
+     * The timestamp the member last joined the thread at
+     *
+     * @type {?number}
+     */
+    this.joinedTimestamp = null;
+
+    /**
+     * The flags for this thread member. This will be `null` if partial.
+     *
+     * @type {?ThreadMemberFlagsBitField}
+     */
+    this.flags = null;
+
+    /**
+     * The id of the thread member
+     *
+     * @type {Snowflake}
+     */
+    this.id = data.user_id;
+
+    this._patch(data, extra);
+  }
+
+  _patch(data, extra = {}) {
+    if ('join_timestamp' in data) this.joinedTimestamp = Date.parse(data.join_timestamp);
+    if ('flags' in data) this.flags = new ThreadMemberFlagsBitField(data.flags).freeze();
+
+    if ('member' in data) {
+      /**
+       * The guild member associated with this thread member.
+       *
+       * @type {?GuildMember}
+       * @private
+       */
+      this.member = this.thread.guild.members._add(data.member, extra.cache);
+    } else {
+      this.member ??= null;
+    }
+  }
+
+  /**
+   * Whether this thread member is a partial
+   *
+   * @type {boolean}
+   * @readonly
+   */
+  get partial() {
+    return this.flags === null;
+  }
+
+  /**
+   * The guild member associated with this thread member
+   *
+   * @type {?GuildMember}
+   * @readonly
+   */
+  get guildMember() {
+    return this.member ?? this.thread.guild.members.cache.get(this.id) ?? null;
+  }
+
+  /**
+   * The last time this member joined the thread
+   *
+   * @type {?Date}
+   * @readonly
+   */
+  get joinedAt() {
+    return this.joinedTimestamp && new Date(this.joinedTimestamp);
+  }
+
+  /**
+   * The user associated with this thread member
+   *
+   * @type {?User}
+   * @readonly
+   */
+  get user() {
+    return this.client.users.cache.get(this.id) ?? null;
+  }
+
+  /**
+   * Whether the client user can manage this thread member
+   *
+   * @type {boolean}
+   * @readonly
+   */
+  get manageable() {
+    return !this.thread.archived && this.thread.editable;
+  }
+
+  /**
+   * Removes this member from the thread.
+   *
+   * @returns {Promise<ThreadMember>}
+   */
+  async remove() {
+    await this.thread.members.remove(this.id);
+    return this;
+  }
+}

package/src/structures/ThreadOnlyChannel.ts

@@ -0,0 +1,276 @@
+import { GuildForumThreadManager  } from '../managers/GuildForumThreadManager.js';
+import { transformAPIGuildForumTag, transformAPIGuildDefaultReaction  } from '../util/Channels.js';
+import { GuildChannel  } from './GuildChannel.js';
+import { TextBasedChannel  } from './interfaces/TextBasedChannel.js';
+
+/**
+ * @typedef {Object} GuildForumTagEmoji
+ * @property {?Snowflake} id The id of a guild's custom emoji
+ * @property {?string} name The unicode character of the emoji
+ */
+
+/**
+ * @typedef {Object} GuildForumTag
+ * @property {Snowflake} id The id of the tag
+ * @property {string} name The name of the tag
+ * @property {boolean} moderated Whether this tag can only be added to or removed from threads
+ * by a member with the `ManageThreads` permission
+ * @property {?GuildForumTagEmoji} emoji The emoji of this tag
+ */
+
+/**
+ * @typedef {Object} GuildForumTagData
+ * @property {Snowflake} [id] The id of the tag
+ * @property {string} name The name of the tag
+ * @property {boolean} [moderated] Whether this tag can only be added to or removed from threads
+ * by a member with the `ManageThreads` permission
+ * @property {?GuildForumTagEmoji} [emoji] The emoji of this tag
+ */
+
+/**
+ * @typedef {Object} DefaultReactionEmoji
+ * @property {?Snowflake} id The id of a guild's custom emoji
+ * @property {?string} name The unicode character of the emoji
+ */
+
+/**
+ * Represents symbols utilized by thread-only channels.
+ *
+ * @extends {GuildChannel}
+ * @implements {TextBasedChannel}
+ * @abstract
+ */
+export class ThreadOnlyChannel extends GuildChannel {
+  public client: any;
+  public threads: any;
+  public availableTags: any;
+  public defaultReactionEmoji: any;
+  public defaultThreadRateLimitPerUser: any;
+  public rateLimitPerUser: any;
+  public defaultAutoArchiveDuration: any;
+  public nsfw: any;
+  public topic: any;
+  public defaultSortOrder: any;
+  constructor(guild, data, client) {
+    super(guild, data, client, false);
+
+    /**
+     * A manager of the threads belonging to this channel
+     *
+     * @type {GuildForumThreadManager}
+     */
+    this.threads = new GuildForumThreadManager(this);
+
+    this._patch(data);
+  }
+
+  _patch(data) {
+    super._patch(data);
+    if ('available_tags' in data) {
+      /**
+       * The set of tags that can be used in this channel.
+       *
+       * @type {GuildForumTag[]}
+       */
+      this.availableTags = data.available_tags.map(tag => transformAPIGuildForumTag(tag));
+    } else {
+      this.availableTags ??= [];
+    }
+
+    if ('default_reaction_emoji' in data) {
+      /**
+       * The emoji to show in the add reaction button on a thread in a guild forum channel
+       *
+       * @type {?DefaultReactionEmoji}
+       */
+      this.defaultReactionEmoji = data.default_reaction_emoji
+        ? transformAPIGuildDefaultReaction(data.default_reaction_emoji)
+        : null;
+    } else {
+      this.defaultReactionEmoji ??= null;
+    }
+
+    if ('default_thread_rate_limit_per_user' in data) {
+      /**
+       * The initial rate limit per user (slowmode) to set on newly created threads in a channel.
+       *
+       * @type {?number}
+       */
+      this.defaultThreadRateLimitPerUser = data.default_thread_rate_limit_per_user;
+    } else {
+      this.defaultThreadRateLimitPerUser ??= null;
+    }
+
+    if ('rate_limit_per_user' in data) {
+      /**
+       * The rate limit per user (slowmode) for this channel.
+       *
+       * @type {?number}
+       */
+      this.rateLimitPerUser = data.rate_limit_per_user;
+    } else {
+      this.rateLimitPerUser ??= null;
+    }
+
+    if ('default_auto_archive_duration' in data) {
+      /**
+       * The default auto archive duration for newly created threads in this channel.
+       *
+       * @type {?ThreadAutoArchiveDuration}
+       */
+      this.defaultAutoArchiveDuration = data.default_auto_archive_duration;
+    } else {
+      this.defaultAutoArchiveDuration ??= null;
+    }
+
+    if ('nsfw' in data) {
+      /**
+       * If this channel is considered NSFW.
+       *
+       * @type {boolean}
+       */
+      this.nsfw = data.nsfw;
+    } else {
+      this.nsfw ??= false;
+    }
+
+    if ('topic' in data) {
+      /**
+       * The topic of this channel.
+       *
+       * @type {?string}
+       */
+      this.topic = data.topic;
+    }
+
+    if ('default_sort_order' in data) {
+      /**
+       * The default sort order mode used to order posts
+       *
+       * @type {?SortOrderType}
+       */
+      this.defaultSortOrder = data.default_sort_order;
+    } else {
+      this.defaultSortOrder ??= null;
+    }
+  }
+
+  /**
+   * Sets the available tags for this forum channel
+   *
+   * @param {GuildForumTagData[]} availableTags The tags to set as available in this channel
+   * @param {string} [reason] Reason for changing the available tags
+   * @returns {Promise<this>}
+   */
+  async setAvailableTags(availableTags, reason) {
+    return this.edit({ availableTags, reason });
+  }
+
+  /**
+   * Sets the default reaction emoji for this channel
+   *
+   * @param {?DefaultReactionEmoji} defaultReactionEmoji The emoji to set as the default reaction emoji
+   * @param {string} [reason] Reason for changing the default reaction emoji
+   * @returns {Promise<this>}
+   */
+  async setDefaultReactionEmoji(defaultReactionEmoji, reason) {
+    return this.edit({ defaultReactionEmoji, reason });
+  }
+
+  /**
+   * Sets the default rate limit per user (slowmode) for new threads in this channel
+   *
+   * @param {number} defaultThreadRateLimitPerUser The rate limit to set on newly created threads in this channel
+   * @param {string} [reason] Reason for changing the default rate limit
+   * @returns {Promise<this>}
+   */
+  async setDefaultThreadRateLimitPerUser(defaultThreadRateLimitPerUser, reason) {
+    return this.edit({ defaultThreadRateLimitPerUser, reason });
+  }
+
+  /**
+   * Creates an invite to this guild channel.
+   *
+   * @param {InviteCreateOptions} [options={}] The options for creating the invite
+   * @returns {Promise<Invite>}
+   * @example
+   * // Create an invite to a channel
+   * channel.createInvite()
+   *   .then(invite => console.log(`Created an invite with a code of ${invite.code}`))
+   *   .catch(console.error);
+   */
+  async createInvite(options) {
+    return this.guild.invites.create(this.id, options);
+  }
+
+  /**
+   * Fetches a collection of invites to this guild channel.
+   * Resolves with a collection mapping invites by their codes.
+   *
+   * @param {boolean} [cache=true] Whether to cache the fetched invites
+   * @returns {Promise<Collection<string, Invite>>}
+   */
+  async fetchInvites(cache) {
+    return this.guild.invites.fetch({ channelId: this.id, cache });
+  }
+
+  /**
+   * Sets the default auto archive duration for all newly created threads in this channel.
+   *
+   * @param {ThreadAutoArchiveDuration} defaultAutoArchiveDuration The new default auto archive duration
+   * @param {string} [reason] Reason for changing the channel's default auto archive duration
+   * @returns {Promise<this>}
+   */
+  async setDefaultAutoArchiveDuration(defaultAutoArchiveDuration, reason) {
+    return this.edit({ defaultAutoArchiveDuration, reason });
+  }
+
+  /**
+   * Sets a new topic for the guild channel.
+   *
+   * @param {?string} topic The new topic for the guild channel
+   * @param {string} [reason] Reason for changing the guild channel's topic
+   * @returns {Promise<this>}
+   * @example
+   * // Set a new channel topic
+   * channel.setTopic('needs more rate limiting')
+   *   .then(newChannel => console.log(`Channel's new topic is ${newChannel.topic}`))
+   *   .catch(console.error);
+   */
+  async setTopic(topic, reason) {
+    return this.edit({ topic, reason });
+  }
+
+  /**
+   * Sets the default sort order mode used to order posts
+   *
+   * @param {?SortOrderType} defaultSortOrder The default sort order mode to set on this channel
+   * @param {string} [reason] Reason for changing the default sort order
+   * @returns {Promise<this>}
+   */
+  async setDefaultSortOrder(defaultSortOrder, reason) {
+    return this.edit({ defaultSortOrder, reason });
+  }
+
+  // These are here only for documentation purposes - they are implemented by TextBasedChannel
+
+  createWebhook() {}
+
+  fetchWebhooks() {}
+
+  setNSFW() {}
+
+  setRateLimitPerUser() {}
+}
+
+TextBasedChannel.applyToClass(ThreadOnlyChannel, [
+  'send',
+  'lastMessage',
+  'lastPinAt',
+  'bulkDelete',
+  'sendTyping',
+  'createMessageCollector',
+  'awaitMessages',
+  'createMessageComponentCollector',
+  'awaitMessageComponent',
+]);

package/src/structures/ThumbnailComponent.ts

@@ -0,0 +1,51 @@
+import { Component  } from './Component.js';
+import { UnfurledMediaItem  } from './UnfurledMediaItem.js';
+
+/**
+ * Represents a thumbnail component
+ *
+ * @extends {Component}
+ */
+export class ThumbnailComponent extends Component {
+  public media: any;
+  constructor({ media, ...data }) {
+    super(data);
+
+    /**
+     * The media associated with this thumbnail
+     *
+     * @type {UnfurledMediaItem}
+     * @readonly
+     */
+    this.media = new UnfurledMediaItem(media);
+  }
+
+  /**
+   * The description of this thumbnail
+   *
+   * @type {?string}
+   * @readonly
+   */
+  get description() {
+    return this.data.description ?? null;
+  }
+
+  /**
+   * Whether this thumbnail is spoilered
+   *
+   * @type {boolean}
+   * @readonly
+   */
+  get spoiler() {
+    return this.data.spoiler ?? false;
+  }
+
+  /**
+   * Returns the API-compatible JSON for this component
+   *
+   * @returns {APIThumbnailComponent}
+   */
+  toJSON() {
+    return { ...this.data, media: this.media.toJSON() };
+  }
+}

package/src/structures/Typing.ts

@@ -0,0 +1,81 @@
+import { Base  } from './Base.js';
+
+/**
+ * Represents a typing state for a user in a channel.
+ *
+ * @extends {Base}
+ */
+export class Typing extends Base {
+  public channel: any;
+  public user: any;
+  public startedTimestamp: any;
+  constructor(channel, user, data) {
+    super(channel.client);
+
+    /**
+     * The channel the status is from
+     *
+     * @type {TextBasedChannels}
+     */
+    this.channel = channel;
+
+    /**
+     * The user who is typing
+     *
+     * @type {User}
+     */
+    this.user = user;
+
+    this._patch(data);
+  }
+
+  _patch(data) {
+    if ('timestamp' in data) {
+      /**
+       * The UNIX timestamp in milliseconds the user started typing at
+       *
+       * @type {number}
+       */
+      this.startedTimestamp = data.timestamp * 1_000;
+    }
+  }
+
+  /**
+   * Indicates whether the status is received from a guild.
+   *
+   * @returns {boolean}
+   */
+  inGuild() {
+    return this.guild !== null;
+  }
+
+  /**
+   * The time the user started typing at
+   *
+   * @type {Date}
+   * @readonly
+   */
+  get startedAt() {
+    return new Date(this.startedTimestamp);
+  }
+
+  /**
+   * The guild the status is from
+   *
+   * @type {?Guild}
+   * @readonly
+   */
+  get guild() {
+    return this.channel.guild ?? null;
+  }
+
+  /**
+   * The member who is typing
+   *
+   * @type {?GuildMember}
+   * @readonly
+   */
+  get member() {
+    return this.guild?.members.resolve(this.user) ?? null;
+  }
+}

package/src/structures/UnfurledMediaItem.ts

@@ -0,0 +1,33 @@
+/**
+ * Represents a media item in a component
+ */
+export class UnfurledMediaItem {
+  public data: any;
+  constructor(data) {
+    /**
+     * The API data associated with this media item
+     *
+     * @type {APIUnfurledMediaItem}
+     */
+    this.data = data;
+  }
+
+  /**
+   * The URL of this media item
+   *
+   * @type {string}
+   * @readonly
+   */
+  get url() {
+    return this.data.url;
+  }
+
+  /**
+   * Returns the API-compatible JSON for this media item
+   *
+   * @returns {APIUnfurledMediaItem}
+   */
+  toJSON() {
+    return { ...this.data };
+  }
+}