@ovencord/discord.js 14.16.3

package/src/structures/GuildEmoji.ts

@@ -0,0 +1,159 @@
+import { PermissionFlagsBits  } from 'discord-api-types/v10';
+import { DiscordjsError, ErrorCodes  } from '../errors/index.js';
+import { GuildEmojiRoleManager  } from '../managers/GuildEmojiRoleManager.js';
+import { BaseGuildEmoji  } from './BaseGuildEmoji.js';
+
+/**
+ * Represents a custom emoji.
+ *
+ * @extends {BaseGuildEmoji}
+ */
+export class GuildEmoji extends BaseGuildEmoji {
+  public client: any;
+  public author: any;
+  public _roles: any;
+  constructor(client, data, guild) {
+    super(client, data, guild);
+
+    /**
+     * The user who created this emoji
+     *
+     * @type {?User}
+     */
+    this.author = null;
+
+    /**
+     * Array of role ids this emoji is active for
+     *
+     * @name GuildEmoji#_roles
+     * @type {Snowflake[]}
+     * @private
+     */
+    Object.defineProperty(this, '_roles', { value: [], writable: true });
+
+    this._patch(data);
+  }
+
+  /**
+   * The guild this emoji is part of
+   *
+   * @type {Guild}
+   * @name GuildEmoji#guild
+   */
+
+  _clone() {
+    const clone = super._clone();
+    clone._roles = this._roles.slice();
+    return clone;
+  }
+
+  _patch(data) {
+    super._patch(data);
+
+    if (data.user) this.author = this.client.users._add(data.user);
+    if (data.roles) this._roles = data.roles;
+  }
+
+  /**
+   * Whether the emoji is deletable by the client user
+   *
+   * @type {boolean}
+   * @readonly
+   */
+  get deletable() {
+    if (!this.guild.members.me) throw new DiscordjsError(ErrorCodes.GuildUncachedMe);
+    return !this.managed && this.guild.members.me.permissions.has(PermissionFlagsBits.ManageGuildExpressions);
+  }
+
+  /**
+   * A manager for roles this emoji is active for.
+   *
+   * @type {GuildEmojiRoleManager}
+   * @readonly
+   */
+  get roles() {
+    return new GuildEmojiRoleManager(this);
+  }
+
+  /**
+   * Fetches the author for this emoji
+   *
+   * @returns {Promise<User>}
+   */
+  async fetchAuthor() {
+    return this.guild.emojis.fetchAuthor(this);
+  }
+
+  /**
+   * Data for editing an emoji.
+   *
+   * @typedef {Object} GuildEmojiEditOptions
+   * @property {string} [name] The name of the emoji
+   * @property {Collection<Snowflake, Role>|RoleResolvable[]} [roles] Roles to restrict emoji to
+   * @property {string} [reason] Reason for editing this emoji
+   */
+
+  /**
+   * Edits the emoji.
+   *
+   * @param {GuildEmojiEditOptions} options The options to provide
+   * @returns {Promise<GuildEmoji>}
+   * @example
+   * // Edit an emoji
+   * emoji.edit({ name: 'newemoji' })
+   *   .then(emoji => console.log(`Edited emoji ${emoji}`))
+   *   .catch(console.error);
+   */
+  async edit(options) {
+    return this.guild.emojis.edit(this.id, options);
+  }
+
+  /**
+   * Sets the name of the emoji.
+   *
+   * @param {string} name The new name for the emoji
+   * @param {string} [reason] Reason for changing the emoji's name
+   * @returns {Promise<GuildEmoji>}
+   */
+  async setName(name, reason) {
+    return this.edit({ name, reason });
+  }
+
+  /**
+   * Deletes the emoji.
+   *
+   * @param {string} [reason] Reason for deleting the emoji
+   * @returns {Promise<GuildEmoji>}
+   */
+  async delete(reason) {
+    await this.guild.emojis.delete(this.id, reason);
+    return this;
+  }
+
+  /**
+   * Whether this emoji is the same as another one.
+   *
+   * @param {GuildEmoji|APIEmoji} other The emoji to compare it to
+   * @returns {boolean}
+   */
+  equals(other) {
+    if (other instanceof GuildEmoji) {
+      return (
+        other.id === this.id &&
+        other.name === this.name &&
+        other.managed === this.managed &&
+        other.available === this.available &&
+        other.requiresColons === this.requiresColons &&
+        other.roles.cache.size === this.roles.cache.size &&
+        other.roles.cache.every(role => this.roles.cache.has(role.id))
+      );
+    } else {
+      return (
+        other.id === this.id &&
+        other.name === this.name &&
+        other.roles.length === this.roles.cache.size &&
+        other.roles.every(role => this.roles.cache.has(role))
+      );
+    }
+  }
+}

package/src/structures/GuildInvite.ts

@@ -0,0 +1,233 @@
+import { Routes, PermissionFlagsBits, InviteType  } from 'discord-api-types/v10';
+import { DiscordjsError, ErrorCodes  } from '../errors/index.js';
+import { InviteFlagsBitField  } from '../util/InviteFlagsBitField.js';
+import { BaseInvite  } from './BaseInvite.js';
+import { GuildScheduledEvent  } from './GuildScheduledEvent.js';
+import { IntegrationApplication  } from './IntegrationApplication.js';
+import { InviteGuild  } from './InviteGuild.js';
+
+/**
+ * A channel invite leading to a guild.
+ *
+ * @extends {BaseInvite}
+ */
+export class GuildInvite extends BaseInvite {
+  public client: any;
+  public type: any;
+  public guildId: any;
+  public flags: any;
+  public guild: any;
+  public channel: any;
+  public targetType: any;
+  public targetUser: any;
+  public targetApplication: any;
+  public guildScheduledEvent: any;
+  public uses: any;
+  public maxUses: any;
+  public temporary: any;
+  public approximatePresenceCount: any;
+  constructor(client, data) {
+    super(client, data);
+
+    // Type may be missing from audit logs.
+    this.type = InviteType.Guild;
+
+    /**
+     * The id of the guild this invite is for.
+     *
+     * @type {Snowflake}
+     */
+    // Guild id may be missing from audit logs.
+    this.guildId = data.guild_id ?? data.guild.id;
+
+    /**
+     * The maximum age of the invite in seconds. `0` for no expiry.
+     * <info>This is only available when the invite was fetched through {@link GuildInviteManager#fetch}
+     * or created through {@link GuildInviteManager#create}.</info>
+     *
+     * @name GuildInvite#maxAge
+     * @type {?number}
+     */
+
+    /**
+     * The approximate total number of members of the guild.
+     * <info>This is only available when the invite was fetched through {@link Client#fetchInvite}.</info>
+     *
+     * @name GuildInvite#approximateMemberCount
+     * @type {?number}
+     */
+  }
+
+  _patch(data) {
+    super._patch(data);
+
+    if ('flags' in data) {
+      /**
+       * The flags of this invite.
+       *
+       * @type {Readonly<InviteFlagsBitField>}
+       */
+      this.flags = new InviteFlagsBitField(data.flags).freeze();
+    } else {
+      this.flags ??= new InviteFlagsBitField().freeze();
+    }
+
+    if ('guild' in data) {
+      /**
+       * The guild the invite is for. May include welcome screen data.
+       *
+       * @type {?(Guild|InviteGuild)}
+       */
+      this.guild = this.client.guilds.cache.get(data.guild.id) ?? new InviteGuild(this.client, data.guild);
+    } else {
+      this.guild ??= null;
+    }
+
+    if ('channel' in data) {
+      /**
+       * The channel this invite is for.
+       *
+       * @type {?GuildInvitableChannel}
+       */
+      this.channel =
+        this.client.channels._add(data.channel, this.guild, { cache: false }) ??
+        this.client.channels.cache.get(this.channelId);
+
+      this.channelId ??= data.channel.id;
+    }
+
+    if ('target_type' in data) {
+      /**
+       * The target type.
+       *
+       * @type {?InviteTargetType}
+       */
+      this.targetType = data.target_type;
+    } else {
+      this.targetType ??= null;
+    }
+
+    if ('target_user' in data) {
+      /**
+       * The user whose stream to display for this voice channel stream invite.
+       *
+       * @type {?User}
+       */
+      this.targetUser = this.client.users._add(data.target_user);
+    } else {
+      this.targetUser ??= null;
+    }
+
+    if ('target_application' in data) {
+      /**
+       * The embedded application to open for this voice channel embedded application invite.
+       *
+       * @type {?IntegrationApplication}
+       */
+      this.targetApplication = new IntegrationApplication(this.client, data.target_application);
+    } else {
+      this.targetApplication ??= null;
+    }
+
+    if ('guild_scheduled_event' in data) {
+      /**
+       * The guild scheduled event data if there is a {@link GuildScheduledEvent} in the channel.
+       *
+       * @type {?GuildScheduledEvent}
+       */
+      this.guildScheduledEvent = new GuildScheduledEvent(this.client, data.guild_scheduled_event);
+    } else {
+      this.guildScheduledEvent ??= null;
+    }
+
+    if ('uses' in data) {
+      /**
+       * How many times this invite has been used.
+       * <info>This is only available when the invite was fetched through {@link GuildInviteManager#fetch}
+       * or created through {@link GuildInviteManager#create}.</info>
+       *
+       * @type {?number}
+       */
+      this.uses = data.uses;
+    } else {
+      this.uses ??= null;
+    }
+
+    if ('max_uses' in data) {
+      /**
+       * The maximum uses of this invite.
+       * <info>This is only available when the invite was fetched through {@link GuildInviteManager#fetch}
+       * or created through {@link GuildInviteManager#create}.</info>
+       *
+       * @type {?number}
+       */
+      this.maxUses = data.max_uses;
+    } else {
+      this.maxUses ??= null;
+    }
+
+    if ('temporary' in data) {
+      /**
+       * Whether this invite grants temporary membership.
+       * <info>This is only available when the invite was fetched through {@link GuildInviteManager#fetch}
+       * or created through {@link GuildInviteManager#create}.</info>
+       *
+       * @type {?boolean}
+       */
+      this.temporary = data.temporary ?? null;
+    } else {
+      this.temporary ??= null;
+    }
+
+    if ('approximate_presence_count' in data) {
+      /**
+       * The approximate number of online members of the guild.
+       * <info>This is only available when the invite was fetched through {@link Client#fetchInvite}.</info>
+       *
+       * @type {?number}
+       */
+      this.approximatePresenceCount = data.approximate_presence_count;
+    } else {
+      this.approximatePresenceCount ??= null;
+    }
+  }
+
+  /**
+   * Whether the invite is deletable by the client user.
+   *
+   * @type {boolean}
+   * @readonly
+   */
+  get deletable() {
+    const guild = this.guild;
+    if (!guild || !this.client.guilds.cache.has(guild.id)) return false;
+    if (!guild.members.me) throw new DiscordjsError(ErrorCodes.GuildUncachedMe);
+    return Boolean(
+      this.channel?.permissionsFor(this.client.user).has(PermissionFlagsBits.ManageChannels, false) ||
+      guild.members.me.permissions.has(PermissionFlagsBits.ManageGuild),
+    );
+  }
+
+  /**
+   * Delete this invite.
+   *
+   * @param {string} [reason] Reason for deleting this invite
+   * @returns {Promise<void>}
+   */
+  async delete(reason) {
+    await this.client.rest.delete(Routes.invite(this.code), { reason });
+  }
+
+  toJSON() {
+    return super.toJSON({
+      url: true,
+      expiresTimestamp: true,
+      presenceCount: false,
+      memberCount: false,
+      uses: false,
+      channel: 'channelId',
+      inviter: 'inviterId',
+      guild: 'guildId',
+    });
+  }
+}