discord.js-selfbott-v13 2.15.1

package/src/structures/PartialGroupDMChannel.js

@@ -0,0 +1,449 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const { joinVoiceChannel, entersState, VoiceConnectionStatus } = require('@discordjs/voice');
+const { Channel } = require('./Channel');
+const Invite = require('./Invite');
+const TextBasedChannel = require('./interfaces/TextBasedChannel');
+const { Error } = require('../errors');
+const MessageManager = require('../managers/MessageManager');
+const { Status, Opcodes } = require('../util/Constants');
+const DataResolver = require('../util/DataResolver');
+
+/**
+ * Represents a Partial Group DM Channel on Discord.
+ * @extends {Channel}
+ */
+class PartialGroupDMChannel extends Channel {
+  constructor(client, data) {
+    super(client, data);
+
+    // No flags are present when fetching partial group DM channels.
+    this.flags = null;
+
+    /**
+     * The name of this Group DM Channel
+     * @type {?string}
+     */
+    this.name = null;
+
+    /**
+     * The hash of the channel icon
+     * @type {?string}
+     */
+    this.icon = null;
+
+    /**
+     * Messages data
+     * @type {Collection}
+     */
+    this.messages = new MessageManager(this);
+
+    /**
+     * Last Message ID
+     * @type {?Snowflake}
+     */
+    this.lastMessageId = null;
+
+    /**
+     * Last Pin Timestamp
+     * @type {UnixTimestamp}
+     */
+    this.lastPinTimestamp = null;
+
+    /**
+     * Owner ID
+     * @type {?Snowflake}
+     */
+    this.ownerId = null;
+
+    /**
+     * Invites fetch
+     * @type {Collection<string, Invite>}
+     */
+    this.invites = new Collection();
+
+    this._recipients = [];
+
+    this._patch(data);
+  }
+
+  /**
+   * The recipients of this Group DM Channel.
+   * @type {Collection<Snowflake, User>}
+   * @readonly
+   */
+  get recipients() {
+    const collect = new Collection();
+    this._recipients.map(recipient => collect.set(recipient.id, this.client.users._add(recipient)));
+    collect.set(this.client.user.id, this.client.user);
+    return collect;
+  }
+
+  /**
+   * The owner of this Group DM Channel
+   * @type {?User}
+   * @readonly
+   */
+  get owner() {
+    return this.client.users.cache.get(this.ownerId);
+  }
+
+  /**
+   *
+   * @param {Object} data Channel Data
+   * @private
+   */
+  _patch(data) {
+    super._patch(data);
+    if ('recipients' in data && Array.isArray(data.recipients)) {
+      this._recipients = data.recipients;
+    }
+    if ('last_pin_timestamp' in data) {
+      const date = new Date(data.last_pin_timestamp);
+      this.lastPinTimestamp = date.getTime();
+    }
+    if ('last_message_id' in data) {
+      this.lastMessageId = data.last_message_id;
+    }
+    if ('owner_id' in data) {
+      this.ownerId = data.owner_id;
+    }
+    if ('name' in data) {
+      this.name = data.name;
+    }
+    if ('icon' in data) {
+      this.icon = data.icon;
+    }
+  }
+
+  /**
+   * Edit channel data
+   * @param {Object} data name, icon owner
+   * @returns {Promise<undefined>}
+   * @private
+   */
+  async edit(data) {
+    const _data = {};
+    if ('name' in data) _data.name = data.name?.trim() ?? null;
+    if (typeof data.icon !== 'undefined') {
+      _data.icon = await DataResolver.resolveImage(data.icon);
+    }
+    if ('owner' in data) {
+      _data.owner = data.owner;
+    }
+    const newData = await this.client.api.channels(this.id).patch({
+      data: _data,
+    });
+
+    return this.client.actions.ChannelUpdate.handle(newData).updated;
+  }
+
+  /**
+   * The URL to this channel's icon.
+   * @param {StaticImageURLOptions} [options={}] Options for the Image URL
+   * @returns {?string}
+   */
+  iconURL({ format, size } = {}) {
+    return this.icon && this.client.rest.cdn.GDMIcon(this.id, this.icon, format, size);
+  }
+
+  /**
+   * Adds a user to this Group DM Channel.
+   * @param {UserResolvable} user User to add to the group
+   * @returns {Promise<PartialGroupDMChannel>}
+   */
+  async addMember(user) {
+    const userId = this.client.users.resolveId(user);
+    user = this.client.users.resolve(userId);
+    if (!userId) {
+      return Promise.reject(new TypeError('User is not a User or User ID'));
+    }
+    // API
+    // if (this.recipients.get(userId)) return Promise.reject(new Error('USER_ALREADY_IN_GROUP_DM_CHANNEL')); // Fails sometimes if member leaves recently (ex. user leave msg's channel used for adding)
+    await this.client.api.channels[this.id].recipients[userId].put();
+    this._recipients.push(user);
+    return this;
+  }
+
+  /**
+   * Removes a user from this Group DM Channel.
+   * @param {UserResolvable} user User to remove from the group
+   * @returns {Promise<PartialGroupDMChannel>}
+   */
+  async removeMember(user) {
+    if (this.ownerId !== this.client.user.id) {
+      return Promise.reject(new Error('NOT_OWNER_GROUP_DM_CHANNEL'));
+    }
+    user = this.client.users.resolveId(user);
+    if (!user) {
+      return Promise.reject(new TypeError('User is not a User or User ID'));
+    }
+    // API
+    // if (!this.recipients.get(user)) return Promise.reject(new Error('USER_NOT_IN_GROUP_DM_CHANNEL'));
+    await this.client.api.channels[this.id].recipients[user].delete();
+    this._recipients = this._recipients.filter(r => r.id !== user);
+    return this;
+  }
+
+  /**
+   * Renames this Group DM Channel.
+   * @param {?string} name Name of the channel
+   * @returns {Promise<PartialGroupDMChannel>}
+   */
+  setName(name) {
+    return this.edit({ name });
+  }
+
+  /**
+   * Sets the icon of this Group DM Channel.
+   * @param {?(Base64Resolvable|BufferResolvable)} icon Icon of the channel
+   * @returns {Promise<PartialGroupDMChannel>}
+   */
+  setIcon(icon) {
+    return this.edit({ icon });
+  }
+
+  /**
+   * Changes the owner of this Group DM Channel.
+   * @param {UserResolvable} user User to transfer ownership to
+   * @returns {Promise<PartialGroupDMChannel>}
+   */
+  setOwner(user) {
+    const id = this.client.users.resolveId(user);
+    if (!id) {
+      throw new TypeError('User is not a User or User ID');
+    }
+    if (this.ownerId !== this.client.user.id) {
+      throw new Error('NOT_OWNER_GROUP_DM_CHANNEL');
+    }
+    if (this.ownerId === id) {
+      return this;
+    }
+    return this.edit({ owner: id });
+  }
+
+  /**
+   * Gets the invite for this Group DM Channel.
+   * @returns {Promise<Invite>}
+   */
+  async getInvite() {
+    const inviteCode = await this.client.api.channels(this.id).invites.post({
+      data: {
+        max_age: 86400,
+      },
+    });
+    const invite = new Invite(this.client, inviteCode);
+    this.invites.set(invite.code, invite);
+    return invite;
+  }
+
+  /**
+   * Get all the invites for this Group DM Channel.
+   * @param {boolean} force Using API to fetch invites or cache
+   * @returns {Promise<Collection<string, Invite>>}
+   */
+  async fetchInvite(force = false) {
+    if (this.ownerId !== this.client.user.id) {
+      return Promise.reject(new Error('NOT_OWNER_GROUP_DM_CHANNEL'));
+    }
+    if (!force && this.invites.size) return this.invites;
+    const invites = await this.client.api.channels(this.id).invites.get();
+    await Promise.all(invites.map(invite => this.invites.set(invite.code, new Invite(this.client, invite))));
+    return this.invites;
+  }
+
+  /**
+   * Delete invites from this Group DM Channel.
+   * @param {Invite} invite Invite to add to the channel
+   * @returns {Promise<PartialGroupDMChannel>}
+   */
+  async removeInvite(invite) {
+    if (this.ownerId !== this.client.user.id) {
+      return Promise.reject(new Error('NOT_OWNER_GROUP_DM_CHANNEL'));
+    }
+    if (!(invite instanceof Invite)) {
+      return Promise.reject(new TypeError('Invite is not an instance of Discord.Invite'));
+    }
+    await this.client.api.channels(this.id).invites[invite.code].delete();
+    this.invites.delete(invite.code);
+    return this;
+  }
+
+  /**
+   * Leave this Group DM Channel.
+   * @param {?boolean} slient Leave without notifying other members
+   * @returns {Promise<Channel>}
+   * @example
+   * // Delete the channel
+   * channel.delete()
+   *   .then(console.log)
+   *   .catch(console.error);
+   */
+  async delete(slient = false) {
+    if (typeof slient === 'boolean' && slient) {
+      await this.client.api.channels(this.id).delete({
+        query: {
+          silent: true,
+        },
+      });
+    } else {
+      await this.client.api.channels(this.id).delete();
+    }
+    return this;
+  }
+
+  // These are here only for documentation purposes - they are implemented by TextBasedChannel
+  /* eslint-disable no-empty-function */
+  get lastMessage() {}
+  get lastPinAt() {}
+  send() {}
+  sendTyping() {}
+
+  /**
+   * @typedef {Object} CallOptions
+   * @property {boolean} [selfDeaf] Whether to deafen yourself
+   * @property {boolean} [selfMute] Whether to mute yourself
+   * @property {boolean} [ring=true] Emit a ringtone
+   */
+  // Testing feature: Call
+  // URL: https://discord.com/api/v9/channels/DMchannelId/call/ring
+  /**
+   * Call this Group DMChannel. Return discordjs/voice VoiceConnection
+   * @param {CallOptions} options Options for the call
+   * @returns {Promise<VoiceConnection>}
+   */
+  call(options = {}) {
+    options = Object.assign(
+      {
+        ring: true,
+      },
+      options || {},
+    );
+    return new Promise((resolve, reject) => {
+      if (!this.client.options.patchVoice) {
+        reject(
+          new Error(
+            'VOICE_NOT_PATCHED',
+            'Enable voice patching in client options\nhttps://discordjs-self-v13.netlify.app/#/docs/docs/main/typedef/ClientOptions',
+          ),
+        );
+      } else {
+        if (options.ring) {
+          this.client.api.channels(this.id).call.ring.post({
+            data: {
+              recipients: null,
+            },
+          });
+        }
+        const connection = joinVoiceChannel({
+          channelId: this.id,
+          guildId: null,
+          adapterCreator: this.voiceAdapterCreator,
+          selfDeaf: options.selfDeaf ?? false,
+          selfMute: options.selfMute ?? false,
+        });
+        entersState(connection, VoiceConnectionStatus.Ready, 30000)
+          .then(connection => {
+            resolve(connection);
+          })
+          .catch(err => {
+            connection.destroy();
+            reject(err);
+          });
+      }
+    });
+  }
+
+  /**
+   * Ring the user's phone / PC (call)
+   * @param {UserResolvable[]} recipients Array of recipients
+   * @returns {Promise<any>}
+   */
+  ring(recipients) {
+    if (!recipients || !Array.isArray(recipients) || recipients.length == 0) recipients = null;
+    recipients = recipients.map(r => this.client.users.resolveId(r)).filter(r => r && this.recipients.get(r));
+    return this.client.api.channels(this.id).call.ring.post({
+      data: {
+        recipients,
+      },
+    });
+  }
+
+  /**
+   * Sync VoiceState of this Group DMChannel.
+   * @returns {undefined}
+   */
+  sync() {
+    this.client.ws.broadcast({
+      op: Opcodes.DM_UPDATE,
+      d: {
+        channel_id: this.id,
+      },
+    });
+  }
+  /**
+   * The user in this voice-based channel
+   * @type {Collection<Snowflake, User>}
+   * @readonly
+   */
+  get voiceUsers() {
+    const coll = new Collection();
+    for (const state of this.client.voiceStates.cache.values()) {
+      if (state.channelId === this.id && state.user) {
+        coll.set(state.id, state.user);
+      }
+    }
+    return coll;
+  }
+  /**
+   * Get connection to current call
+   * @type {?VoiceConnection}
+   * @readonly
+   */
+  get voiceConnection() {
+    const check = this.client.callVoice?.joinConfig?.channelId == this.id;
+    if (check) {
+      return this.client.callVoice;
+    }
+    return null;
+  }
+  /**
+   * Get current shard
+   * @type {WebSocketShard}
+   * @readonly
+   */
+  get shard() {
+    return this.client.ws.shards.first();
+  }
+  /**
+   * The voice state adapter for this client that can be used with @discordjs/voice to play audio in DM / Group DM channels.
+   * @type {?Function}
+   * @readonly
+   */
+  get voiceAdapterCreator() {
+    return methods => {
+      this.client.voice.adapters.set(this.id, methods);
+      return {
+        sendPayload: data => {
+          if (this.shard.status !== Status.READY) return false;
+          this.shard.send(data);
+          return true;
+        },
+        destroy: () => {
+          this.client.voice.adapters.delete(this.id);
+        },
+      };
+    };
+  }
+}
+
+TextBasedChannel.applyToClass(PartialGroupDMChannel, true, [
+  'bulkDelete',
+  'fetchWebhooks',
+  'createWebhook',
+  'setRateLimitPerUser',
+  'setNSFW',
+]);
+
+module.exports = PartialGroupDMChannel;

package/src/structures/PermissionOverwrites.js

@@ -0,0 +1,196 @@
+'use strict';
+
+const Base = require('./Base');
+const { Role } = require('./Role');
+const { TypeError } = require('../errors');
+const { OverwriteTypes } = require('../util/Constants');
+const Permissions = require('../util/Permissions');
+
+/**
+ * Represents a permission overwrite for a role or member in a guild channel.
+ * @extends {Base}
+ */
+class PermissionOverwrites extends Base {
+  constructor(client, data, channel) {
+    super(client);
+
+    /**
+     * The GuildChannel this overwrite is for
+     * @name PermissionOverwrites#channel
+     * @type {GuildChannel}
+     * @readonly
+     */
+    Object.defineProperty(this, 'channel', { value: channel });
+
+    if (data) this._patch(data);
+  }
+
+  _patch(data) {
+    /**
+     * The overwrite's id, either a {@link User} or a {@link Role} id
+     * @type {Snowflake}
+     */
+    this.id = data.id;
+
+    if ('type' in data) {
+      /**
+       * The type of this overwrite
+       * @type {OverwriteType}
+       */
+      this.type = typeof data.type === 'number' ? OverwriteTypes[data.type] : data.type;
+    }
+
+    if ('deny' in data) {
+      /**
+       * The permissions that are denied for the user or role.
+       * @type {Readonly<Permissions>}
+       */
+      this.deny = new Permissions(BigInt(data.deny)).freeze();
+    }
+
+    if ('allow' in data) {
+      /**
+       * The permissions that are allowed for the user or role.
+       * @type {Readonly<Permissions>}
+       */
+      this.allow = new Permissions(BigInt(data.allow)).freeze();
+    }
+  }
+
+  /**
+   * Edits this Permission Overwrite.
+   * @param {PermissionOverwriteOptions} options The options for the update
+   * @param {string} [reason] Reason for creating/editing this overwrite
+   * @returns {Promise<PermissionOverwrites>}
+   * @example
+   * // Update permission overwrites
+   * permissionOverwrites.edit({
+   *   SEND_MESSAGES: false
+   * })
+   *   .then(channel => console.log(channel.permissionOverwrites.get(message.author.id)))
+   *   .catch(console.error);
+   */
+  async edit(options, reason) {
+    await this.channel.permissionOverwrites.upsert(this.id, options, { type: OverwriteTypes[this.type], reason }, this);
+    return this;
+  }
+
+  /**
+   * Deletes this Permission Overwrite.
+   * @param {string} [reason] Reason for deleting this overwrite
+   * @returns {Promise<PermissionOverwrites>}
+   */
+  async delete(reason) {
+    await this.channel.permissionOverwrites.delete(this.id, reason);
+    return this;
+  }
+
+  toJSON() {
+    return {
+      id: this.id,
+      type: OverwriteTypes[this.type],
+      allow: this.allow,
+      deny: this.deny,
+    };
+  }
+
+  /**
+   * An object mapping permission flags to `true` (enabled), `null` (unset) or `false` (disabled).
+   * ```js
+   * {
+   *  'SEND_MESSAGES': true,
+   *  'EMBED_LINKS': null,
+   *  'ATTACH_FILES': false,
+   * }
+   * ```
+   * @typedef {Object} PermissionOverwriteOptions
+   */
+
+  /**
+   * @typedef {Object} ResolvedOverwriteOptions
+   * @property {Permissions} allow The allowed permissions
+   * @property {Permissions} deny The denied permissions
+   */
+
+  /**
+   * Resolves bitfield permissions overwrites from an object.
+   * @param {PermissionOverwriteOptions} options The options for the update
+   * @param {ResolvedOverwriteOptions} initialPermissions The initial permissions
+   * @returns {ResolvedOverwriteOptions}
+   */
+  static resolveOverwriteOptions(options, { allow, deny } = {}) {
+    allow = new Permissions(allow);
+    deny = new Permissions(deny);
+
+    for (const [perm, value] of Object.entries(options)) {
+      if (value === true) {
+        allow.add(perm);
+        deny.remove(perm);
+      } else if (value === false) {
+        allow.remove(perm);
+        deny.add(perm);
+      } else if (value === null) {
+        allow.remove(perm);
+        deny.remove(perm);
+      }
+    }
+
+    return { allow, deny };
+  }
+
+  /**
+   * The raw data for a permission overwrite
+   * @typedef {Object} RawOverwriteData
+   * @property {Snowflake} id The id of the {@link Role} or {@link User} this overwrite belongs to
+   * @property {string} allow The permissions to allow
+   * @property {string} deny The permissions to deny
+   * @property {number} type The type of this OverwriteData
+   */
+
+  /**
+   * Data that can be resolved into {@link RawOverwriteData}. This can be:
+   * * PermissionOverwrites
+   * * OverwriteData
+   * @typedef {PermissionOverwrites|OverwriteData} OverwriteResolvable
+   */
+
+  /**
+   * Data that can be used for a permission overwrite
+   * @typedef {Object} OverwriteData
+   * @property {GuildMemberResolvable|RoleResolvable} id Member or role this overwrite is for
+   * @property {PermissionResolvable} [allow] The permissions to allow
+   * @property {PermissionResolvable} [deny] The permissions to deny
+   * @property {OverwriteType} [type] The type of this OverwriteData
+   */
+
+  /**
+   * Resolves an overwrite into {@link RawOverwriteData}.
+   * @param {OverwriteResolvable} overwrite The overwrite-like data to resolve
+   * @param {Guild} [guild] The guild to resolve from
+   * @returns {RawOverwriteData}
+   */
+  static resolve(overwrite, guild) {
+    if (overwrite instanceof this) return overwrite.toJSON();
+    if (typeof overwrite.id === 'string' && overwrite.type in OverwriteTypes) {
+      return {
+        id: overwrite.id,
+        type: OverwriteTypes[overwrite.type],
+        allow: Permissions.resolve(overwrite.allow ?? Permissions.defaultBit).toString(),
+        deny: Permissions.resolve(overwrite.deny ?? Permissions.defaultBit).toString(),
+      };
+    }
+
+    const userOrRole = guild.roles.resolve(overwrite.id) ?? guild.client.users.resolve(overwrite.id);
+    if (!userOrRole) throw new TypeError('INVALID_TYPE', 'parameter', 'User nor a Role');
+    const type = userOrRole instanceof Role ? OverwriteTypes.role : OverwriteTypes.member;
+
+    return {
+      id: userOrRole.id,
+      type,
+      allow: Permissions.resolve(overwrite.allow ?? Permissions.defaultBit).toString(),
+      deny: Permissions.resolve(overwrite.deny ?? Permissions.defaultBit).toString(),
+    };
+  }
+}
+
+module.exports = PermissionOverwrites;