From 1e00fc200173686f7fdc50405e63c894077e9d59 Mon Sep 17 00:00:00 2001
From: Jiralite <33201955+Jiralite@users.noreply.github.com>
Date: Tue, 14 Dec 2021 18:04:07 +0000
Subject: [PATCH] refactor(RoleManager): Move some methods over from Role
 (#7096)

---
 src/managers/RoleManager.js | 36 ++++++++++++++++++++++++++++++++++++
 src/structures/Role.js      | 24 ++++++++++++++++--------
 typings/index.d.ts          |  3 +++
 3 files changed, 55 insertions(+), 8 deletions(-)

diff --git a/src/managers/RoleManager.js b/src/managers/RoleManager.js
index 094bc741e..a947c29af 100644
--- a/src/managers/RoleManager.js
+++ b/src/managers/RoleManager.js
@@ -218,6 +218,23 @@ class RoleManager extends CachedManager {
     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(deleted => console.log(`Deleted role ${deleted.name}`))
+   *   .catch(console.error);
+   */
+  async delete(role, reason) {
+    const id = this.resolveId(role);
+    await this.client.api.guilds[this.guild.id].roles[id].delete({ reason });
+    this.client.actions.GuildRoleDelete.handle({ guild_id: this.guild.id, role_id: id });
+  }
+
   /**
    * Batch-updates the guild's role positions
    * @param {GuildRolePosition[]} rolePositions Role positions to update
@@ -244,6 +261,25 @@ class RoleManager extends CachedManager {
     }).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 TypeError('INVALID_TYPE', 'role', 'Role nor a Snowflake');
+
+    if (resolvedRole1.position === resolvedRole2.position) {
+      return Number(BigInt(resolvedRole2.id) - BigInt(resolvedRole1.id));
+    }
+
+    return resolvedRole1.position - resolvedRole2.position;
+  }
+
   /**
    * Gets the managed role a user created when joining the guild, if any
    * <info>Only ever available for bots</info>
diff --git a/src/structures/Role.js b/src/structures/Role.js
index a8e7ea888..bddca2868 100644
--- a/src/structures/Role.js
+++ b/src/structures/Role.js
@@ -1,11 +1,13 @@
 'use strict';
 
 const Base = require('./Base');
-const { Error, TypeError } = require('../errors');
+const { Error } = require('../errors');
 const Permissions = require('../util/Permissions');
 const SnowflakeUtil = require('../util/SnowflakeUtil');
 const Util = require('../util/Util');
 
+let deprecationEmittedForComparePositions = false;
+
 /**
  * @type {WeakSet<Role>}
  * @private
@@ -207,9 +209,7 @@ class Role extends Base {
    * positive number if this one is higher (other's is lower), 0 if equal
    */
   comparePositionTo(role) {
-    role = this.guild.roles.resolve(role);
-    if (!role) throw new TypeError('INVALID_TYPE', 'role', 'Role nor a Snowflake');
-    return this.constructor.comparePositions(this, role);
+    return this.guild.roles.comparePositions(this, role);
   }
 
   /**
@@ -407,8 +407,7 @@ class Role extends Base {
    *   .catch(console.error);
    */
   async delete(reason) {
-    await this.client.api.guilds[this.guild.id].roles[this.id].delete({ reason });
-    this.client.actions.GuildRoleDelete.handle({ guild_id: this.guild.id, role_id: this.id });
+    await this.guild.roles.delete(this.id, reason);
     return this;
   }
 
@@ -469,10 +468,19 @@ class Role extends Base {
    * @param {Role} 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
+   * @deprecated Use {@link RoleManager#comparePositions} instead.
    */
   static comparePositions(role1, role2) {
-    if (role1.position === role2.position) return role2.id - role1.id;
-    return role1.position - role2.position;
+    if (!deprecationEmittedForComparePositions) {
+      process.emitWarning(
+        'The Role.comparePositions method is deprecated. Use RoleManager#comparePositions instead.',
+        'DeprecationWarning',
+      );
+
+      deprecationEmittedForComparePositions = true;
+    }
+
+    return role1.guild.roles.comparePositions(role1, role2);
   }
 }
 
diff --git a/typings/index.d.ts b/typings/index.d.ts
index 6332d46c2..c9583dfda 100644
--- a/typings/index.d.ts
+++ b/typings/index.d.ts
@@ -1895,6 +1895,7 @@ export class Role extends Base {
   public toJSON(): unknown;
   public toString(): RoleMention;
 
+  /** @deprecated Use {@link RoleManager.comparePositions} instead. */
   public static comparePositions(role1: Role, role2: Role): number;
 }
 
@@ -3074,7 +3075,9 @@ export class RoleManager extends CachedManager<Snowflake, Role, RoleResolvable>
   public fetch(id?: undefined, options?: BaseFetchOptions): Promise<Collection<Snowflake, Role>>;
   public create(options?: CreateRoleOptions): Promise<Role>;
   public edit(role: RoleResolvable, options: RoleData, reason?: string): Promise<Role>;
+  public delete(role: RoleResolvable, reason?: string): Promise<void>;
   public setPositions(rolePositions: readonly RolePosition[]): Promise<Guild>;
+  public comparePositions(role1: RoleResolvable, role2: RoleResolvable): number;
 }
 
 export class StageInstanceManager extends CachedManager<Snowflake, StageInstance, StageInstanceResolvable> {