@ovencord/discord.js 14.16.3

package/src/managers/ReactionManager.ts

@@ -0,0 +1,72 @@
+import { Routes  } from 'discord-api-types/v10';
+import { MessageReaction  } from '../structures/MessageReaction.js';
+import { CachedManager  } from './CachedManager.js';
+
+/**
+ * Manages API methods for reactions and holds their cache.
+ *
+ * @extends {CachedManager}
+ */
+export class ReactionManager extends CachedManager {
+  public message: any;
+  constructor(message, iterable) {
+    super(message.client, MessageReaction, iterable);
+
+    /**
+     * The message that this manager belongs to
+     *
+     * @type {Message}
+     */
+    this.message = message;
+  }
+
+  _add(data, cache) {
+    return super._add(data, cache, { id: data.emoji.id ?? data.emoji.name, extras: [this.message] });
+  }
+
+  /**
+   * The reaction cache of this manager
+   *
+   * @type {Collection<string|Snowflake, MessageReaction>}
+   * @name ReactionManager#cache
+   */
+
+  /**
+   * Data that can be resolved to a MessageReaction object. This can be:
+   * - A MessageReaction
+   * - A Snowflake
+   * - The Unicode representation of an emoji
+   *
+   * @typedef {MessageReaction|Snowflake} MessageReactionResolvable
+   */
+
+  /**
+   * Resolves a {@link MessageReactionResolvable} to a {@link MessageReaction} object.
+   *
+   * @method resolve
+   * @memberof ReactionManager
+   * @instance
+   * @param {MessageReactionResolvable} reaction The MessageReaction to resolve
+   * @returns {?MessageReaction}
+   */
+
+  /**
+   * Resolves a {@link MessageReactionResolvable} to a {@link MessageReaction} id.
+   *
+   * @method resolveId
+   * @memberof ReactionManager
+   * @instance
+   * @param {MessageReactionResolvable} reaction The MessageReaction to resolve
+   * @returns {?Snowflake}
+   */
+
+  /**
+   * Removes all reactions from a message.
+   *
+   * @returns {Promise<Message>}
+   */
+  async removeAll() {
+    await this.client.rest.delete(Routes.channelMessageAllReactions(this.message.channelId, this.message.id));
+    return this.message;
+  }
+}

package/src/managers/ReactionUserManager.ts

@@ -0,0 +1,82 @@
+import { Collection  } from '@ovencord/collection';
+import { makeURLSearchParams  } from '@ovencord/rest';
+import { ReactionType, Routes  } from 'discord-api-types/v10';
+import { DiscordjsError, ErrorCodes  } from '../errors/index.js';
+import { User  } from '../structures/User.js';
+import { CachedManager  } from './CachedManager.js';
+
+/**
+ * Manages API methods for users who reacted to a reaction and stores their cache.
+ *
+ * @extends {CachedManager}
+ */
+export class ReactionUserManager extends CachedManager {
+  public reaction: any;
+  constructor(reaction, iterable) {
+    super(reaction.client, User, iterable);
+
+    /**
+     * The reaction that this manager belongs to
+     *
+     * @type {MessageReaction}
+     */
+    this.reaction = reaction;
+  }
+
+  /**
+   * The cache of this manager
+   *
+   * @type {Collection<Snowflake, User>}
+   * @name ReactionUserManager#cache
+   */
+
+  /**
+   * Options used to fetch users who gave a reaction.
+   *
+   * @typedef {Object} FetchReactionUsersOptions
+   * @property {ReactionType} [type=ReactionType.Normal] The reaction type to fetch
+   * @property {number} [limit=100] The maximum amount of users to fetch, defaults to `100`
+   * @property {Snowflake} [after] Limit fetching users to those with an id greater than the supplied id
+   */
+
+  /**
+   * Fetches all the users that gave this reaction. Resolves with a collection of users, mapped by their ids.
+   *
+   * @param {FetchReactionUsersOptions} [options] Options for fetching the users
+   * @returns {Promise<Collection<Snowflake, User>>}
+   */
+  async fetch({ type = ReactionType.Normal, limit = 100, after } = {}) {
+    const message = this.reaction.message;
+    const query = makeURLSearchParams({ limit, after, type });
+    const data = await this.client.rest.get(
+      Routes.channelMessageReaction(message.channelId, message.id, this.reaction.emoji.identifier),
+      { query },
+    );
+    const users = new Collection();
+    for (const rawUser of data) {
+      const user = this.client.users._add(rawUser);
+      this.cache.set(user.id, user);
+      users.set(user.id, user);
+    }
+
+    return users;
+  }
+
+  /**
+   * Removes a user from this reaction.
+   *
+   * @param {UserResolvable} [user=this.client.user] The user to remove the reaction of
+   * @returns {Promise<MessageReaction>}
+   */
+  async remove(user = this.client.user) {
+    const userId = this.client.users.resolveId(user);
+    if (!userId) throw new DiscordjsError(ErrorCodes.ReactionResolveUser);
+    const message = this.reaction.message;
+    const route =
+      userId === this.client.user.id
+        ? Routes.channelMessageOwnReaction(message.channelId, message.id, this.reaction.emoji.identifier)
+        : Routes.channelMessageUserReaction(message.channelId, message.id, this.reaction.emoji.identifier, userId);
+    await this.client.rest.delete(route);
+    return this.reaction;
+  }
+}

package/src/managers/RoleManager.ts

@@ -0,0 +1,432 @@
+import process from 'node:process';
+import { Collection  } from '@ovencord/collection';
+import { Routes  } from 'discord-api-types/v10';
+import { DiscordjsTypeError, ErrorCodes  } from '../errors/index.js';
+import { Role  } from '../structures/Role.js';
+import { resolveImage  } from '../util/DataResolver.js';
+import { PermissionsBitField  } from '../util/PermissionsBitField.js';
+import { setPosition, resolveColor  } from '../util/Util.js';
+import { CachedManager  } from './CachedManager.js';
+
+let cacheWarningEmitted = false;
+
+/**
+ * Manages API methods for roles and stores their cache.
+ *
+ * @extends {CachedManager}
+ */
+export class RoleManager extends CachedManager {
+  public guild: any;
+  constructor(guild, iterable) {
+    super(guild.client, Role, iterable);
+    if (!cacheWarningEmitted && this._cache.constructor.name !== 'Collection') {
+      cacheWarningEmitted = true;
+      process.emitWarning(
+        `Overriding the cache handling for ${this.constructor.name} is unsupported and breaks functionality.`,
+        'UnsupportedCacheOverwriteWarning',
+      );
+    }
+
+    /**
+     * The guild belonging to this manager
+     *
+     * @type {Guild}
+     */
+    this.guild = guild;
+  }
+
+  /**
+   * The role cache of this manager
+   *
+   * @type {Collection<Snowflake, Role>}
+   * @name RoleManager#cache
+   */
+
+  _add(data, cache) {
+    return super._add(data, cache, { extras: [this.guild] });
+  }
+
+  /**
+   * Obtains a role from Discord, or the role cache if they're already available.
+   *
+   * @param {Snowflake} [id] The role's id
+   * @param {BaseFetchOptions} [options] Additional options for this fetch
+   * @returns {Promise<Role|Collection<Snowflake, Role>>}
+   * @example
+   * // Fetch all roles from the guild
+   * message.guild.roles.fetch()
+   *   .then(roles => console.log(`There are ${roles.size} roles.`))
+   *   .catch(console.error);
+   * @example
+   * // Fetch a single role
+   * message.guild.roles.fetch('222078108977594368')
+   *   .then(role => console.log(`The role color is: ${role.colors.primaryColor}`))
+   *   .catch(console.error);
+   */
+  async fetch(id, { cache = true, force = false } = {}) {
+    if (!id) {
+      const innerData = await this.client.rest.get(Routes.guildRoles(this.guild.id));
+      const roles = new Collection();
+      for (const role of innerData) roles.set(role.id, this._add(role, cache));
+      return roles;
+    }
+
+    if (!force) {
+      const existing = this.cache.get(id);
+      if (existing) return existing;
+    }
+
+    const data = await this.client.rest.get(Routes.guildRole(this.guild.id, id));
+    return this._add(data, cache);
+  }
+
+  /**
+   * Fetches the member count of each role in the guild.
+   * <info>This does not include the `@everyone` role.</info>
+   *
+   * @returns {Promise<Collection<Snowflake, number>>} A collection mapping role ids to their respective member counts.
+   */
+  async fetchMemberCounts() {
+    const data = await this.client.rest.get(Routes.guildRoleMemberCounts(this.guild.id));
+    return new Collection(Object.entries(data));
+  }
+
+  /**
+   * Data that can be resolved to a Role object. This can be:
+   * - A Role
+   * - A Snowflake
+   *
+   * @typedef {Role|Snowflake} RoleResolvable
+   */
+
+  /**
+   * Resolves a {@link RoleResolvable} to a {@link Role} object.
+   *
+   * @method resolve
+   * @memberof RoleManager
+   * @instance
+   * @param {RoleResolvable} role The role resolvable to resolve
+   * @returns {?Role}
+   */
+
+  /**
+   * Resolves a {@link RoleResolvable} to a {@link Role} id.
+   *
+   * @method resolveId
+   * @memberof RoleManager
+   * @instance
+   * @param {RoleResolvable} role The role resolvable to resolve
+   * @returns {?Snowflake}
+   */
+
+  /**
+   * @typedef {Object} RoleColorsResolvable
+   * @property {ColorResolvable} primaryColor The primary color of the role
+   * @property {ColorResolvable} [secondaryColor] The secondary color of the role.
+   * This will make the role a gradient between the other provided colors
+   * @property {ColorResolvable} [tertiaryColor] The tertiary color of the role.
+   * When sending `tertiaryColor` the API enforces the role color to be a holographic style with values of `primaryColor = 11127295`, `secondaryColor = 16759788`, and `tertiaryColor = 16761760`.
+   * These values are available as a constant: `Constants.HolographicStyle`
+   */
+
+  /**
+   * Options used to create a new role.
+   *
+   * @typedef {Object} RoleCreateOptions
+   * @property {string} [name] The name of the new role
+   * @property {RoleColorsResolvable} [colors] The colors to create the role with
+   * @property {boolean} [hoist] Whether or not the new role should be hoisted
+   * @property {PermissionResolvable} [permissions] The permissions for the new role
+   * @property {number} [position] The position of the new role
+   * @property {boolean} [mentionable] Whether or not the new role should be mentionable
+   * @property {?(BufferResolvable|Base64Resolvable|EmojiResolvable)} [icon] The icon for the role
+   * <warn>The `EmojiResolvable` should belong to the same guild as the role.
+   * If not, pass the emoji's URL directly</warn>
+   * @property {?string} [unicodeEmoji] The unicode emoji for the role
+   * @property {string} [reason] The reason for creating this role
+   */
+
+  /**
+   * Creates a new role in the guild with given information.
+   * <warn>The position will silently reset to 1 if an invalid one is provided, or none.</warn>
+   *
+   * @param {RoleCreateOptions} [options] Options for creating the new role
+   * @returns {Promise<Role>}
+   * @example
+   * // Create a new role
+   * guild.roles.create()
+   *   .then(console.log)
+   *   .catch(console.error);
+   * @example
+   * // Create a new role with data and a reason
+   * guild.roles.create({
+   *   name: 'Super Cool Blue People',
+   *   reason: 'we needed a role for Super Cool People',
+   *   colors: {
+   *     primaryColor: Colors.Blue,
+   *   },
+   * })
+   *   .then(console.log)
+   *   .catch(console.error);
+   * @example
+   * // Create a role with holographic colors
+   * guild.roles.create({
+   *   name: 'Holographic Role',
+   *   reason: 'Creating a role with holographic effect',
+   *   colors: {
+   *     primaryColor: Constants.HolographicStyle.Primary,
+   *     secondaryColor: Constants.HolographicStyle.Secondary,
+   *     tertiaryColor: Constants.HolographicStyle.Tertiary,
+   *   },
+   * })
+   *   .then(console.log)
+   *   .catch(console.error);
+   */
+  async create(options = {}) {
+    let { permissions, icon } = options;
+    const { name, hoist, position, mentionable, reason, unicodeEmoji } = options;
+    if (permissions !== undefined) permissions = new PermissionsBitField(permissions);
+    if (icon) {
+      const guildEmojiURL = this.guild.emojis.resolve(icon)?.imageURL();
+      icon = guildEmojiURL ? await resolveImage(guildEmojiURL) : await resolveImage(icon);
+      if (typeof icon !== 'string') icon = undefined;
+    }
+
+    const colors = options.colors && {
+      primary_color: resolveColor(options.colors.primaryColor),
+      secondary_color: options.colors.secondaryColor && resolveColor(options.colors.secondaryColor),
+      tertiary_color: options.colors.tertiaryColor && resolveColor(options.colors.tertiaryColor),
+    };
+
+    const data = await this.client.rest.post(Routes.guildRoles(this.guild.id), {
+      body: {
+        name,
+        colors,
+        hoist,
+        permissions,
+        mentionable,
+        icon,
+        unicode_emoji: unicodeEmoji,
+      },
+      reason,
+    });
+    const { role } = this.client.actions.GuildRoleCreate.handle({
+      guild_id: this.guild.id,
+      role: data,
+    });
+    if (position) return this.setPosition(role, position, { reason });
+    return role;
+  }
+
+  /**
+   * Options for editing a role
+   *
+   * @typedef {RoleData} RoleEditOptions
+   * @property {string} [reason] The reason for editing this role
+   */
+
+  /**
+   * Edits a role of the guild.
+   *
+   * @param {RoleResolvable} role The role to edit
+   * @param {RoleEditOptions} options The options to provide
+   * @returns {Promise<Role>}
+   * @example
+   * // Edit a role
+   * guild.roles.edit('222079219327434752', { name: 'buddies' })
+   *   .then(updated => console.log(`Edited role name to ${updated.name}`))
+   *   .catch(console.error);
+   */
+  async edit(role, options) {
+    const resolvedRole = this.resolve(role);
+    if (!resolvedRole) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'role', 'RoleResolvable');
+
+    if (typeof options.position === 'number') {
+      await this.setPosition(resolvedRole, options.position, { reason: options.reason });
+    }
+
+    let icon = options.icon;
+    if (icon) {
+      const guildEmojiURL = this.guild.emojis.resolve(icon)?.imageURL();
+      icon = guildEmojiURL ? await resolveImage(guildEmojiURL) : await resolveImage(icon);
+      if (typeof icon !== 'string') icon = undefined;
+    }
+
+    const colors = options.colors && {
+      primary_color: resolveColor(options.colors.primaryColor),
+      secondary_color: options.colors.secondaryColor && resolveColor(options.colors.secondaryColor),
+      tertiary_color: options.colors.tertiaryColor && resolveColor(options.colors.tertiaryColor),
+    };
+
+    const body = {
+      name: options.name,
+      colors,
+      hoist: options.hoist,
+      permissions: options.permissions === undefined ? undefined : new PermissionsBitField(options.permissions),
+      mentionable: options.mentionable,
+      icon,
+      unicode_emoji: options.unicodeEmoji,
+    };
+
+    const data = await this.client.rest.patch(Routes.guildRole(this.guild.id, resolvedRole.id), {
+      body,
+      reason: options.reason,
+    });
+
+    const clone = resolvedRole._clone();
+    clone._patch(data);
+    return clone;
+  }
+
+  /**
+   * Deletes a role.
+   *
+   * @param {RoleResolvable} role The role to delete
+   * @param {string} [reason] Reason for deleting the role
+   * @returns {Promise<void>}
+   * @example
+   * // Delete a role
+   * guild.roles.delete('222079219327434752', 'The role needed to go')
+   *   .then(() => console.log('Deleted the role'))
+   *   .catch(console.error);
+   */
+  async delete(role, reason) {
+    const id = this.resolveId(role);
+    await this.client.rest.delete(Routes.guildRole(this.guild.id, id), { reason });
+    this.client.actions.GuildRoleDelete.handle({ guild_id: this.guild.id, role_id: id });
+  }
+
+  /**
+   * Sets the new position of the role.
+   *
+   * @param {RoleResolvable} role The role to change the position of
+   * @param {number} position The new position for the role
+   * @param {SetRolePositionOptions} [options] Options for setting the position
+   * @returns {Promise<Role>}
+   * @example
+   * // Set the position of the role
+   * guild.roles.setPosition('222197033908436994', 1)
+   *   .then(updated => console.log(`Role position: ${updated.position}`))
+   *   .catch(console.error);
+   */
+  async setPosition(role, position, { relative, reason } = {}) {
+    const resolvedRole = this.resolve(role);
+    if (!resolvedRole) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'role', 'RoleResolvable');
+    const updatedRoles = await setPosition(
+      resolvedRole,
+      position,
+      relative,
+      this.guild._sortedRoles(),
+      this.client,
+      Routes.guildRoles(this.guild.id),
+      reason,
+    );
+
+    this.client.actions.GuildRolesPositionUpdate.handle({
+      guild_id: this.guild.id,
+      roles: updatedRoles,
+    });
+    return resolvedRole;
+  }
+
+  /**
+   * The data needed for updating a guild role's position
+   *
+   * @typedef {Object} GuildRolePosition
+   * @property {RoleResolvable} role The role's id
+   * @property {number} position The position to update
+   */
+
+  /**
+   * Batch-updates the guild's role positions
+   *
+   * @param {GuildRolePosition[]} rolePositions Role positions to update
+   * @returns {Promise<Guild>}
+   * @example
+   * guild.roles.setPositions([{ role: roleId, position: updatedRoleIndex }])
+   *  .then(guild => console.log(`Role positions updated for ${guild}`))
+   *  .catch(console.error);
+   */
+  async setPositions(rolePositions) {
+    // Make sure rolePositions are prepared for API
+    const resolvedRolePositions = rolePositions.map(rolePosition => ({
+      id: this.resolveId(rolePosition.role),
+      position: rolePosition.position,
+    }));
+
+    // Call the API to update role positions
+    await this.client.rest.patch(Routes.guildRoles(this.guild.id), { body: resolvedRolePositions });
+    return this.client.actions.GuildRolesPositionUpdate.handle({
+      guild_id: this.guild.id,
+      roles: resolvedRolePositions,
+    }).guild;
+  }
+
+  /**
+   * Compares the positions of two roles.
+   *
+   * @param {RoleResolvable} role1 First role to compare
+   * @param {RoleResolvable} role2 Second role to compare
+   * @returns {number} Negative number if the first role's position is lower (second role's is higher),
+   * positive number if the first's is higher (second's is lower), 0 if equal
+   */
+  comparePositions(role1, role2) {
+    const resolvedRole1 = this.resolve(role1);
+    const resolvedRole2 = this.resolve(role2);
+    if (!resolvedRole1 || !resolvedRole2) {
+      throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'role', 'Role nor a Snowflake');
+    }
+
+    const role1Position = resolvedRole1.position;
+    const role2Position = resolvedRole2.position;
+
+    if (role1Position === role2Position) {
+      return Number(BigInt(resolvedRole2.id) - BigInt(resolvedRole1.id));
+    }
+
+    return role1Position - role2Position;
+  }
+
+  /**
+   * Gets the managed role a user created when joining the guild, if any
+   * <info>Only ever available for bots</info>
+   *
+   * @param {UserResolvable} user The user to access the bot role for
+   * @returns {?Role}
+   */
+  botRoleFor(user) {
+    const userId = this.client.users.resolveId(user);
+    if (!userId) return null;
+    return this.cache.find(role => role.tags?.botId === userId) ?? null;
+  }
+
+  /**
+   * The `@everyone` role of the guild
+   *
+   * @type {Role}
+   * @readonly
+   */
+  get everyone() {
+    return this.cache.get(this.guild.id);
+  }
+
+  /**
+   * The premium subscriber role of the guild, if any
+   *
+   * @type {?Role}
+   * @readonly
+   */
+  get premiumSubscriberRole() {
+    return this.cache.find(role => role.tags?.premiumSubscriberRole) ?? null;
+  }
+
+  /**
+   * The role with the highest position in the cache
+   *
+   * @type {Role}
+   * @readonly
+   */
+  get highest() {
+    return this.cache.reduce((prev, role) => (role.comparePositionTo(prev) > 0 ? role : prev), this.cache.first());
+  }
+}