darkcord
Version:
A NodeJS Package to interact with Discord API
315 lines (314 loc) • 8.93 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ThreadMember = exports.Member = exports.MemberRoles = exports.UncachedClientMemberError = void 0;
const v10_1 = require("discord-api-types/v10");
const Base_1 = require("./Base");
const BitField_1 = require("./BitField");
const Permission_1 = require("./Permission");
class UncachedClientMemberError extends Error {
constructor() {
super("The client member is not cached. This is likely due to the member not being in the guild or the guild not being cached.");
this.name = "UncachedClientMemberError";
}
}
exports.UncachedClientMemberError = UncachedClientMemberError;
class MemberRoles {
guild;
_roles;
cache;
constructor(guild, roles) {
this.guild = guild;
Object.defineProperty(this, "_roles", {
value: roles,
enumerable: false,
});
this.cache = guild.roles.cache.filter((role) => roles.includes(role.id));
}
/**
* Get the member role with the highest position
* @returns
*/
get highest() {
return this.cache.reduce(([, prev], [, role]) => {
return prev && this.guild.roles.comparePositions(role.id, prev.id) > 0
? [role.id, role]
: [prev.id, prev];
}, [this.guild.id, this.guild.roles.everyone])?.[1];
}
/**
* Compare the position of a member role with another guild role
* @param roleId The member role id
* @param otherRoleId The guild role id
* @returns
*/
comparePositions(roleId, otherRoleId) {
const role = this.cache.get(roleId);
if (!role) {
throw new TypeError("Role not found in cache");
}
return this.guild.roles.comparePositions(role.id, otherRoleId);
}
[Symbol.iterator]() {
return this.cache.values();
}
toArray() {
return this._roles;
}
}
exports.MemberRoles = MemberRoles;
class Member extends Base_1.Base {
guild;
/**
* The member's guild avatar hash
*/
avatar;
/**
* Timestamp of when the time out will be removed; until then, they cannot interact with the guild
*/
communicationDisabledUntil;
/**
* The user this guild member represents
*/
user;
/**
* Whether the user is deafened in voice channels
*/
deaf;
/**
* When the user started boosting the guild
*/
premiumSince;
/**
* Whether the user has not yet passed the guild's Membership Screening requirements
*/
pending;
/**
* Member roles
*/
roles;
/**
* Member permissions bitfield
*/
permissions;
/**
* Whether the user is muted in voice channels
*/
mute;
/**
* This member's guild nickname
*/
nickname;
/**
* When the user joined the guild
*/
joinedAt;
constructor(data, guild) {
super(data, guild._client, data.user?.id);
this.guild = guild;
this.avatar = data.avatar;
this.communicationDisabledUntil = data.communication_disabled_until;
Object.defineProperty(this, "user", {
value: null,
writable: true,
enumerable: false,
});
if (data.user) {
this.user = this._client.cache.users.add(data.user);
}
this.nickname = data.nick ?? null;
this.deaf = data.deaf;
this.premiumSince = data.premium_since
? Date.parse(data.premium_since)
: null;
this.joinedAt = data.joined_at ? Date.parse(data.joined_at) : null;
this.pending = Boolean(data.pending);
this.roles = new MemberRoles(guild, data.roles);
this.mute = data.mute;
this.permissions = this.guild.permissionsOf(this);
}
/**
* The current voice state of this member
*/
get voiceState() {
return this.guild.voiceStates.get(this.id);
}
get manageable() {
if (this.id === this.guild.ownerId) {
return false;
}
if (this.id === this._client.user.id) {
return false;
}
if (this._client.user.id === this.guild.ownerId) {
return true;
}
if (!this.guild.clientMember) {
throw new UncachedClientMemberError();
}
return (this.guild.clientMember.roles.comparePositions(this.guild.clientMember.roles.highest.id, this.roles.highest.id) > 0);
}
get bannable() {
if (!this.guild.clientMember) {
throw new UncachedClientMemberError();
}
return (this.manageable &&
this.guild.clientMember.permissions.has(Permission_1.Permissions.Flags.BanMembers));
}
get kickable() {
if (!this.guild.clientMember) {
throw new UncachedClientMemberError();
}
return (this.manageable &&
this.guild.clientMember.permissions.has(Permission_1.Permissions.Flags.KickMembers));
}
/**
* The member's display name
*/
displayName() {
return this.nickname ?? this.user?.displayName();
}
/**
* The member's guild avatar url
* @param options
* @returns
*/
avatarURL(options) {
if (!this.avatar) {
return null;
}
let url = v10_1.RouteBases.cdn +
v10_1.CDNRoutes.guildMemberAvatar(this.guild.id, this.id, this.avatar, options?.format ?? this.avatar.startsWith("a_")
? v10_1.ImageFormat.GIF
: v10_1.ImageFormat.PNG);
if (options?.size) {
url += "?size=" + options.size.toString();
}
return url;
}
/**
* The member's display avatar url
* @param options options for display avatar url
* @returns
*/
displayAvatarURL(options) {
return (this.avatarURL(options) ?? this.user?.displayAvatarURL(options) ?? null);
}
/**
* Add a role to this member
* @param roleId Id of role to be added
* @param reason
* @returns
*/
addRole(roleId, reason) {
return this.guild.addMemberRole(this.id, roleId, reason);
}
/**
* Remove a role to this member
* @param roleId Id of role to be removed
* @param reason
* @returns
*/
removeRole(roleId, reason) {
return this.guild.removeMemberRole(this.id, roleId, reason);
}
/**
* Ban this member from the guild
* @param options
* @param reason
* @returns
*/
ban(options, reason) {
return this.guild.createMemberBan(this.id, options, reason);
}
edit(options, reason) {
return this.guild.editMember(this.id, options, reason);
}
/**
* Applies timeout to the member for a specified time
* @param timeout
* @param reason
* @returns
*/
disableCommunicationUntil(timeout, reason) {
return this.edit({
communicationDisabledUntil: new Date(Date.now() > timeout ? Date.now() + timeout : timeout).toISOString(),
}, reason);
}
toJSON() {
return Base_1.Base.toJSON(this, [
"avatar",
"avatarURL",
"communicationDisabledUntil",
"createdAt",
"deaf",
"guild",
"id",
"joinedAt",
"mute",
"pending",
"permissions",
"premiumSince",
"rawData",
"roles",
"user",
]);
}
}
exports.Member = Member;
class ThreadMember extends Base_1.Base {
/**
* Thread guild
*/
guild;
/**
* An timestamp for when the member last joined
*/
joinTimestamp;
/**
* Member flags combined as a bitfield
*/
flags;
/**
* The thread of member is in
*/
thread;
/**
* The id of the thread
*/
threadId;
constructor(data, thread) {
super(data, data.client, data.user_id);
this.thread = thread;
this.threadId = data.id || thread.id;
this.guild = thread.guild;
this.joinTimestamp = Date.parse(data.join_timestamp);
this.flags = new BitField_1.BitField(data.flags, v10_1.ThreadMemberFlags);
}
/**
* The guild member associated with this thread member
*/
get guildMember() {
return this.guild.members.cache.get(this.id);
}
/**
* The user associated with this this thread member
*/
get user() {
return this._client.cache.users.get(this.id);
}
toJSON() {
return Base_1.Base.toJSON(this, [
"createdAt",
"flags",
"guild",
"guildMember",
"id",
"joinTimestamp",
"rawData",
"thread",
"threadId",
"user",
]);
}
}
exports.ThreadMember = ThreadMember;