@ovencord/discord.js 14.16.3

package/src/structures/BaseGuild.ts

@@ -0,0 +1,134 @@
+import { makeURLSearchParams  } from '@ovencord/rest';
+import { DiscordSnowflake  } from '@sapphire/snowflake';
+import { Routes, GuildFeature  } from 'discord-api-types/v10';
+import { Base  } from './Base.js';
+
+/**
+ * The base class for {@link Guild}, {@link OAuth2Guild} and {@link InviteGuild}.
+ *
+ * @extends {Base}
+ * @abstract
+ */
+export class BaseGuild extends Base {
+  public client: any;
+  public id: any;
+  public name: any;
+  public features: any;
+  constructor(client, data) {
+    super(client);
+
+    /**
+     * The guild's id
+     *
+     * @type {Snowflake}
+     */
+    this.id = data.id;
+
+    /**
+     * The name of this guild
+     *
+     * @type {string}
+     */
+    this.name = data.name;
+
+    /**
+     * The icon hash of this guild
+     *
+     * @type {?string}
+     */
+    this.icon = data.icon;
+
+    /**
+     * An array of features available to this guild
+     *
+     * @type {GuildFeature[]}
+     */
+    this.features = data.features;
+  }
+
+  /**
+   * The timestamp this guild was created at
+   *
+   * @type {number}
+   * @readonly
+   */
+  get createdTimestamp() {
+    return DiscordSnowflake.timestampFrom(this.id);
+  }
+
+  /**
+   * The time this guild was created at
+   *
+   * @type {Date}
+   * @readonly
+   */
+  get createdAt() {
+    return new Date(this.createdTimestamp);
+  }
+
+  /**
+   * The acronym that shows up in place of a guild icon
+   *
+   * @type {string}
+   * @readonly
+   */
+  get nameAcronym() {
+    /* eslint-disable unicor */
+    return this.name
+      .replace(/'s /g, ' ')
+      .replace(/\w+/g, word => word[0])
+      .replace(/\s/g, '');
+    /* eslint-enable unicorn/prefer-string-replace-all */
+  }
+
+  /**
+   * Whether this guild is partnered
+   *
+   * @type {boolean}
+   * @readonly
+   */
+  get partnered() {
+    return this.features.includes(GuildFeature.Partnered);
+  }
+
+  /**
+   * Whether this guild is verified
+   *
+   * @type {boolean}
+   * @readonly
+   */
+  get verified() {
+    return this.features.includes(GuildFeature.Verified);
+  }
+
+  /**
+   * The URL to this guild's icon.
+   *
+   * @param {ImageURLOptions} [options={}] Options for the image URL
+   * @returns {?string}
+   */
+  iconURL(options = {}) {
+    return this.icon && this.client.rest.cdn.icon(this.id, this.icon, options);
+  }
+
+  /**
+   * Fetches this guild.
+   *
+   * @returns {Promise<Guild>}
+   */
+  async fetch() {
+    const data = await this.client.rest.get(Routes.guild(this.id), {
+      query: makeURLSearchParams({ with_counts: true }),
+    });
+    return this.client.guilds._add(data);
+  }
+
+  /**
+   * When concatenated with a string, this automatically returns the guild's name instead of the Guild object.
+   *
+   * @returns {string}
+   */
+  toString() {
+    return this.name;
+  }
+}

package/src/structures/BaseGuildEmoji.ts

@@ -0,0 +1,113 @@
+import { Emoji  } from './Emoji.js';
+
+/**
+ * Parent class for {@link GuildEmoji} and {@link GuildPreviewEmoji}.
+ *
+ * @extends {Emoji}
+ * @abstract
+ */
+export class BaseGuildEmoji extends Emoji {
+  public client: any;
+  public guild: any;
+  public requiresColons: any;
+  public managed: any;
+  public available: any;
+  public name: any;
+  constructor(client, data, guild) {
+    super(client, data);
+
+    /**
+     * The guild this emoji is a part of
+     *
+     * @type {Guild|GuildPreview}
+     */
+    this.guild = guild;
+
+    this.requiresColons = null;
+    this.managed = null;
+    this.available = null;
+
+    this._patch(data);
+  }
+
+  _patch(data) {
+    if ('name' in data) this.name = data.name;
+
+    if ('require_colons' in data) {
+      /**
+       * Whether or not this emoji requires colons surrounding it
+       *
+       * @type {?boolean}
+       */
+      this.requiresColons = data.require_colons;
+    }
+
+    if ('managed' in data) {
+      /**
+       * Whether this emoji is managed by an external service
+       *
+       * @type {?boolean}
+       */
+      this.managed = data.managed;
+    }
+
+    if ('available' in data) {
+      /**
+       * Whether this emoji is available
+       *
+       * @type {?boolean}
+       */
+      this.available = data.available;
+    }
+  }
+}
+
+/**
+ * Returns a URL for the emoji.
+ *
+ * @method imageURL
+ * @memberof BaseGuildEmoji
+ * @instance
+ * @param {EmojiURLOptions} [options={}] Options for the emoji URL
+ * @returns {string}
+ */
+
+/**
+ * The emoji's name
+ *
+ * @name name
+ * @memberof BaseGuildEmoji
+ * @instance
+ * @type {string}
+ * @readonly
+ */
+
+/**
+ * Whether or not the emoji is animated
+ *
+ * @name animated
+ * @memberof BaseGuildEmoji
+ * @instance
+ * @type {boolean}
+ * @readonly
+ */
+
+/**
+ * The time the emoji was created at.
+ *
+ * @name createdAt
+ * @memberof BaseGuildEmoji
+ * @instance
+ * @type {Date}
+ * @readonly
+ */
+
+/**
+ * The timestamp the emoji was created at.
+ *
+ * @name createdTimestamp
+ * @memberof BaseGuildEmoji
+ * @instance
+ * @type {number}
+ * @readonly
+ */

package/src/structures/BaseGuildTextChannel.ts

@@ -0,0 +1,230 @@
+import { GuildMessageManager  } from '../managers/GuildMessageManager.js';
+import { GuildTextThreadManager  } from '../managers/GuildTextThreadManager.js';
+import { GuildChannel  } from './GuildChannel.js';
+import { TextBasedChannel  } from './interfaces/TextBasedChannel.js';
+
+/**
+ * Represents a text-based guild channel on Discord.
+ *
+ * @extends {GuildChannel}
+ * @implements {TextBasedChannel}
+ */
+export class BaseGuildTextChannel extends GuildChannel {
+  public client: any;
+  public messages: any;
+  public threads: any;
+  public nsfw: any;
+  public topic: any;
+  public lastMessageId: any;
+  public lastPinTimestamp: any;
+  public defaultAutoArchiveDuration: any;
+  public defaultThreadRateLimitPerUser: any;
+  constructor(guild, data, client) {
+    super(guild, data, client, false);
+
+    /**
+     * A manager of the messages sent to this channel
+     *
+     * @type {GuildMessageManager}
+     */
+    this.messages = new GuildMessageManager(this);
+
+    /**
+     * A manager of the threads belonging to this channel
+     *
+     * @type {GuildTextThreadManager}
+     */
+    this.threads = new GuildTextThreadManager(this);
+
+    /**
+     * If the guild considers this channel NSFW
+     *
+     * @type {boolean}
+     */
+    this.nsfw = Boolean(data.nsfw);
+
+    this._patch(data);
+  }
+
+  _patch(data) {
+    super._patch(data);
+
+    if ('topic' in data) {
+      /**
+       * The topic of the text channel
+       *
+       * @type {?string}
+       */
+      this.topic = data.topic;
+    }
+
+    if ('nsfw' in data) {
+      this.nsfw = Boolean(data.nsfw);
+    }
+
+    if ('last_message_id' in data) {
+      /**
+       * The last message id sent in the channel, if one was sent
+       *
+       * @type {?Snowflake}
+       */
+      this.lastMessageId = data.last_message_id;
+    }
+
+    if ('last_pin_timestamp' in data) {
+      /**
+       * The timestamp when the last pinned message was pinned, if there was one
+       *
+       * @type {?number}
+       */
+      this.lastPinTimestamp = data.last_pin_timestamp ? Date.parse(data.last_pin_timestamp) : 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;
+    }
+
+    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 ('messages' in data) {
+      for (const message of data.messages) this.messages._add(message);
+    }
+  }
+
+  /**
+   * 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<TextChannel>}
+   */
+  async setDefaultAutoArchiveDuration(defaultAutoArchiveDuration, reason) {
+    return this.edit({ defaultAutoArchiveDuration, reason });
+  }
+
+  /**
+   * Sets the type of this channel.
+   * <info>Only conversion between {@link TextChannel} and {@link AnnouncementChannel} is supported.</info>
+   *
+   * @param {ChannelType.GuildText|ChannelType.GuildAnnouncement} type The new channel type
+   * @param {string} [reason] Reason for changing the channel's type
+   * @returns {Promise<GuildChannel>}
+   */
+  async setType(type, reason) {
+    return this.edit({ type, 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<GuildChannel>}
+   * @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 });
+  }
+
+  /**
+   * Data that can be resolved to an Application. This can be:
+   * - An Application
+   * - An Activity with associated Application
+   * - A Snowflake
+   *
+   * @typedef {Application|Snowflake} ApplicationResolvable
+   */
+
+  /**
+   * Options used to create an invite to a guild channel.
+   *
+   * @typedef {Object} InviteCreateOptions
+   * @property {boolean} [temporary] Whether members that joined via the invite should be automatically
+   * kicked after 24 hours if they have not yet received a role
+   * @property {number} [maxAge] How long the invite should last (in seconds, 0 for forever)
+   * @property {number} [maxUses] Maximum number of uses
+   * @property {boolean} [unique] Create a unique invite, or use an existing one with similar settings
+   * @property {UserResolvable} [targetUser] The user whose stream to display for this invite,
+   * required if `targetType` is {@link InviteTargetType.Stream}, the user must be streaming in the channel
+   * @property {ApplicationResolvable} [targetApplication] The embedded application to open for this invite,
+   * required if `targetType` is {@link InviteTargetType.Stream}, the application must have the
+   * {@link InviteTargetType.EmbeddedApplication} flag
+   * @property {InviteTargetType} [targetType] The type of the target for this voice channel invite
+   * @property {string} [reason] The reason for creating the invite
+   */
+
+  /**
+   * 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 or not to cache the fetched invites
+   * @returns {Promise<Collection<string, Invite>>}
+   */
+  async fetchInvites(cache = true) {
+    return this.guild.invites.fetch({ channelId: this.id, cache });
+  }
+
+  // These are here only for documentation purposes - they are implemented by TextBasedChannel
+
+  /* eslint-disable getter-return */
+  get lastMessage() {}
+
+  get lastPinAt() {}
+
+  send() {}
+
+  sendTyping() {}
+
+  createMessageCollector() {}
+
+  awaitMessages() {}
+
+  createMessageComponentCollector() {}
+
+  awaitMessageComponent() {}
+
+  bulkDelete() {}
+
+  fetchWebhooks() {}
+
+  createWebhook() {}
+
+  setRateLimitPerUser() {}
+
+  setNSFW() {}
+}
+
+TextBasedChannel.applyToClass(BaseGuildTextChannel);