@ovencord/discord.js 14.16.3

package/src/structures/PermissionOverwrites.ts

@@ -0,0 +1,222 @@
+import { OverwriteType  } from 'discord-api-types/v10';
+import { DiscordjsTypeError, ErrorCodes  } from '../errors/index.js';
+import { PermissionsBitField  } from '../util/PermissionsBitField.js';
+import { Base  } from './Base.js';
+import { Role  } from './Role.js';
+
+/**
+ * Represents a permission overwrite for a role or member in a guild channel.
+ *
+ * @extends {Base}
+ */
+export class PermissionOverwrites extends Base {
+  public client: any;
+  public id: any;
+  public type: any;
+  public deny: any;
+  public allow: any;
+  constructor(client, data, channel) {
+    super(client);
+
+    /**
+     * The GuildChannel this overwrite is for
+     *
+     * @name PermissionOverwrites#channel
+     * @type {GuildChannel}
+     * @readonly
+     */
+    Object.defineProperty(this, 'channel', { value: channel });
+
+    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 = data.type;
+    }
+
+    if ('deny' in data) {
+      /**
+       * The permissions that are denied for the user or role.
+       *
+       * @type {Readonly<PermissionsBitField>}
+       */
+      this.deny = new PermissionsBitField(BigInt(data.deny)).freeze();
+    }
+
+    if ('allow' in data) {
+      /**
+       * The permissions that are allowed for the user or role.
+       *
+       * @type {Readonly<PermissionsBitField>}
+       */
+      this.allow = new PermissionsBitField(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({
+   *   SendMessages: 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: 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: this.type,
+      allow: this.allow,
+      deny: this.deny,
+    };
+  }
+
+  /**
+   * An object mapping permission flags to `true` (enabled), `null` (unset) or `false` (disabled).
+   * ```js
+   * {
+   *  'SendMessages': true,
+   *  'EmbedLinks': null,
+   *  'AttachFiles': false,
+   * }
+   * ```
+   *
+   * @typedef {Object<string, ?boolean>} PermissionOverwriteOptions
+   */
+
+  /**
+   * @typedef {Object} ResolvedOverwriteOptions
+   * @property {PermissionsBitField} allow The allowed permissions
+   * @property {PermissionsBitField} 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, initialPermissions = {}) {
+    const allow = new PermissionsBitField(initialPermissions.allow);
+    const deny = new PermissionsBitField(initialPermissions.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 APIOverwrite}. This can be:
+   * - PermissionOverwrites
+   * - OverwriteData
+   *
+   * @typedef {PermissionOverwrites|OverwriteData} OverwriteResolvable
+   */
+
+  /**
+   * Data that can be used for a permission overwrite
+   *
+   * @typedef {Object} OverwriteData
+   * @property {UserResolvable|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 (mandatory if `id` is a Snowflake)
+   */
+
+  /**
+   * Resolves an overwrite into {@link APIOverwrite}.
+   *
+   * @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();
+
+    const id = guild.roles.resolveId(overwrite.id) ?? guild.client.users.resolveId(overwrite.id);
+    if (!id) {
+      throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'overwrite.id', 'UserResolvable or RoleResolvable');
+    }
+
+    if (overwrite.type !== undefined && (typeof overwrite.type !== 'number' || !(overwrite.type in OverwriteType))) {
+      throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'overwrite.type', 'OverwriteType', true);
+    }
+
+    let type;
+    if (typeof overwrite.id === 'string') {
+      if (overwrite.type === undefined) {
+        throw new DiscordjsTypeError(ErrorCodes.PermissionOverwritesTypeMandatory);
+      }
+
+      type = overwrite.type;
+    } else {
+      type = overwrite.id instanceof Role ? OverwriteType.Role : OverwriteType.Member;
+      if (overwrite.type !== undefined && type !== overwrite.type) {
+        throw new DiscordjsTypeError(ErrorCodes.PermissionOverwritesTypeMismatch, OverwriteType[type]);
+      }
+    }
+
+    return {
+      id,
+      type,
+      allow: PermissionsBitField.resolve(overwrite.allow ?? PermissionsBitField.DefaultBit).toString(),
+      deny: PermissionsBitField.resolve(overwrite.deny ?? PermissionsBitField.DefaultBit).toString(),
+    };
+  }
+}

package/src/structures/Poll.ts

@@ -0,0 +1,195 @@
+import { Collection  } from '@ovencord/collection';
+import { DiscordjsError, ErrorCodes  } from '../errors/index.js';
+import { Base  } from './Base.js';
+import { PollAnswer  } from './PollAnswer.js';
+
+/**
+ * Represents a Poll
+ *
+ * @extends {Base}
+ */
+export class Poll extends Base {
+  public client: any;
+  public channelId: any;
+  public messageId: any;
+  public answers: any;
+  public resultsFinalized: any;
+  public allowMultiselect: any;
+  public layoutType: any;
+  public expiresTimestamp: any;
+  public question: any;
+  constructor(client, data, message, channel) {
+    super(client);
+
+    /**
+     * The id of the channel that this poll is in
+     *
+     * @type {Snowflake}
+     */
+    this.channelId = data.channel_id ?? channel.id;
+
+    /**
+     * The channel that this poll is in
+     *
+     * @name Poll#channel
+     * @type {TextBasedChannel}
+     * @readonly
+     */
+
+    Object.defineProperty(this, 'channel', { value: channel });
+
+    /**
+     * The id of the message that started this poll
+     *
+     * @type {Snowflake}
+     */
+    this.messageId = data.message_id ?? message.id;
+
+    /**
+     * The message that started this poll
+     *
+     * @name Poll#message
+     * @type {Message}
+     * @readonly
+     */
+
+    Object.defineProperty(this, 'message', { value: message });
+
+    /**
+     * The answers of this poll
+     *
+     * @type {Collection<number, PollAnswer|PartialPollAnswer>}
+     */
+    this.answers = new Collection();
+
+    this._patch(data);
+  }
+
+  _patch(data) {
+    if (data.answers) {
+      for (const answer of data.answers) {
+        const existing = this.answers.get(answer.answer_id);
+        if (existing) {
+          existing._patch(answer);
+        } else {
+          this.answers.set(answer.answer_id, new PollAnswer(this.client, answer, this));
+        }
+      }
+    }
+
+    if (data.results) {
+      /**
+       * Whether this poll's results have been precisely counted
+       *
+       * @type {boolean}
+       */
+      this.resultsFinalized = data.results.is_finalized;
+
+      for (const answerResult of data.results.answer_counts) {
+        const answer = this.answers.get(answerResult.id);
+        answer?._patch(answerResult);
+      }
+    } else {
+      this.resultsFinalized ??= false;
+    }
+
+    if ('allow_multiselect' in data) {
+      /**
+       * Whether this poll allows multiple answers
+       *
+       * @type {boolean}
+       */
+      this.allowMultiselect = data.allow_multiselect;
+    } else {
+      this.allowMultiselect ??= null;
+    }
+
+    if ('layout_type' in data) {
+      /**
+       * The layout type of this poll
+       *
+       * @type {PollLayoutType}
+       */
+      this.layoutType = data.layout_type;
+    } else {
+      this.layoutType ??= null;
+    }
+
+    if ('expiry' in data) {
+      /**
+       * The timestamp when this poll expires
+       *
+       * @type {?number}
+       */
+      this.expiresTimestamp = data.expiry && Date.parse(data.expiry);
+    } else {
+      this.expiresTimestamp ??= null;
+    }
+
+    if (data.question) {
+      /**
+       * The media for a poll's question
+       *
+       * @typedef {Object} PollQuestionMedia
+       * @property {?string} text The text of this question
+       */
+
+      /**
+       * The media for this poll's question
+       *
+       * @type {PollQuestionMedia}
+       */
+      this.question = {
+        text: data.question.text,
+      };
+    } else {
+      this.question ??= {
+        text: null,
+      };
+    }
+  }
+
+  /**
+   * The date when this poll expires
+   *
+   * @type {?Date}
+   * @readonly
+   */
+  get expiresAt() {
+    return this.expiresTimestamp && new Date(this.expiresTimestamp);
+  }
+
+  /**
+   * Whether this poll is a partial
+   *
+   * @type {boolean}
+   * @readonly
+   */
+  get partial() {
+    return this.allowMultiselect === null;
+  }
+
+  /**
+   * Fetches the message that started this poll, then updates the poll from the fetched message.
+   *
+   * @returns {Promise<Poll>}
+   */
+  async fetch() {
+    await this.channel.messages.fetch(this.messageId);
+
+    return this;
+  }
+
+  /**
+   * Ends this poll.
+   *
+   * @returns {Promise<Message>}
+   */
+  async end() {
+    if (this.expiresTimestamp !== null && Date.now() > this.expiresTimestamp) {
+      throw new DiscordjsError(ErrorCodes.PollAlreadyExpired);
+    }
+
+    return this.channel.messages.endPoll(this.messageId);
+  }
+}

package/src/structures/PollAnswer.ts

@@ -0,0 +1,100 @@
+import { PollAnswerVoterManager  } from '../managers/PollAnswerVoterManager.js';
+import { resolveGuildEmoji  } from '../util/Util.js';
+import { Base  } from './Base.js';
+import { Emoji  } from './Emoji.js';
+
+/**
+ * Represents an answer to a {@link Poll}
+ *
+ * @extends {Base}
+ */
+export class PollAnswer extends Base {
+  public client: any;
+  public id: any;
+  public voters: any;
+  public voteCount: any;
+  public _emoji: any;
+  public text: any;
+  constructor(client, data, poll) {
+    super(client);
+
+    /**
+     * The {@link Poll} this answer is part of
+     *
+     * @name PollAnswer#poll
+     * @type {Poll|PartialPoll}
+     * @readonly
+     */
+    Object.defineProperty(this, 'poll', { value: poll });
+
+    /**
+     * The id of this answer
+     *
+     * @type {number}
+     */
+    this.id = data.answer_id;
+
+    /**
+     * The manager of the voters for this answer
+     *
+     * @type {PollAnswerVoterManager}
+     */
+    this.voters = new PollAnswerVoterManager(this);
+
+    /**
+     * The raw emoji of this answer
+     *
+     * @name PollAnswer#_emoji
+     * @type {?APIPartialEmoji}
+     * @private
+     */
+    Object.defineProperty(this, '_emoji', { value: null, writable: true });
+
+    this._patch(data);
+  }
+
+  _patch(data) {
+    // This `count` field comes from `poll.results.answer_counts`
+    if ('count' in data) {
+      /**
+       * The amount of votes this answer has
+       *
+       * @type {number}
+       */
+      this.voteCount = data.count;
+    } else {
+      this.voteCount ??= this.voters.cache.size;
+    }
+
+    /**
+     * The text of this answer
+     *
+     * @type {?string}
+     */
+    this.text ??= data.poll_media?.text ?? null;
+
+    if (data.poll_media?.emoji) {
+      this._emoji = data.poll_media.emoji;
+    }
+  }
+
+  /**
+   * The emoji of this answer
+   *
+   * @type {?(GuildEmoji|Emoji)}
+   */
+  get emoji() {
+    if (!this._emoji || (!this._emoji.id && !this._emoji.name)) return null;
+    return resolveGuildEmoji(this.client, this._emoji.id) ?? new Emoji(this.client, this._emoji);
+  }
+
+  /**
+   * Whether this poll answer is a partial.
+   *
+   * @type {boolean}
+   * @readonly
+   */
+  get partial() {
+    return this.poll.partial || (this.text === null && this.emoji === null);
+  }
+}