@ovencord/discord.js 14.16.3

package/src/util/ActivityFlagsBitField.ts

@@ -0,0 +1,26 @@
+/* eslint-disable jsdoc/check-values */
+
+import { ActivityFlags  } from 'discord-api-types/v10';
+import { BitField  } from './BitField.js';
+
+/**
+ * Data structure that makes it easy to interact with an {@link Activity#flags} bitfield.
+ *
+ * @extends {BitField}
+ */
+export class ActivityFlagsBitField extends BitField {
+  /**
+   * Numeric activity flags.
+   *
+   * @type {ActivityFlags}
+   * @memberof ActivityFlagsBitField
+   */
+  static Flags = ActivityFlags;
+}
+
+/**
+ * @name ActivityFlagsBitField
+ * @kind constructor
+ * @memberof ActivityFlagsBitField
+ * @param {BitFieldResolvable} [bits=0] Bit(s) to read from
+ */

package/src/util/ApplicationFlagsBitField.ts

@@ -0,0 +1,43 @@
+/* eslint-disable jsdoc/check-values */
+
+import { ApplicationFlags  } from 'discord-api-types/v10';
+import { BitField  } from './BitField.js';
+
+/**
+ * Data structure that makes it easy to interact with a {@link ClientApplication#flags} bitfield.
+ *
+ * @extends {BitField}
+ */
+export class ApplicationFlagsBitField extends BitField {
+  /**
+   * Numeric application flags. All available properties:
+   *
+   * @type {ApplicationFlags}
+   * @memberof ApplicationFlagsBitField
+   */
+  static Flags = ApplicationFlags;
+}
+
+/**
+ * @name ApplicationFlagsBitField
+ * @kind constructor
+ * @memberof ApplicationFlagsBitField
+ * @param {BitFieldResolvable} [bits=0] Bit(s) to read from
+ */
+
+/**
+ * Bitfield of the packed bits
+ *
+ * @type {number}
+ * @name ApplicationFlagsBitField#bitfield
+ */
+
+/**
+ * Data that can be resolved to give an application flag bit field. This can be:
+ * - A string (see {@link ApplicationFlagsBitField.Flags})
+ * - An application flag
+ * - An instance of ApplicationFlagsBitField
+ * - An Array of ApplicationFlagsResolvable
+ *
+ * @typedef {string|number|ApplicationFlagsBitField|ApplicationFlagsResolvable[]} ApplicationFlagsResolvable
+ */

package/src/util/AttachmentFlagsBitField.ts

@@ -0,0 +1,26 @@
+/* eslint-disable jsdoc/check-values */
+
+import { AttachmentFlags  } from 'discord-api-types/v10';
+import { BitField  } from './BitField.js';
+
+/**
+ * Data structure that makes it easy to interact with an {@link Attachment#flags} bitfield.
+ *
+ * @extends {BitField}
+ */
+export class AttachmentFlagsBitField extends BitField {
+  /**
+   * Numeric attachment flags.
+   *
+   * @type {AttachmentFlags}
+   * @memberof AttachmentFlagsBitField
+   */
+  static Flags = AttachmentFlags;
+}
+
+/**
+ * @name AttachmentFlagsBitField
+ * @kind constructor
+ * @memberof AttachmentFlagsBitField
+ * @param {BitFieldResolvable} [bits=0] Bit(s) to read from
+ */

package/src/util/BitField.ts

@@ -0,0 +1,178 @@
+/* eslint-disable unicor */
+
+import { DiscordjsRangeError, ErrorCodes  } from '../errors/index.js';
+
+/**
+ * Data structure that makes it easy to interact with a bitfield.
+ */
+export class BitField {
+  /**
+   * Numeric bitfield flags.
+   */
+  static Flags: Record<string, any> = {};
+
+  /**
+   * Default bit value.
+   */
+  static DefaultBit: number | bigint = 0;
+
+  /**
+   * Bitfield of the packed bits.
+   */
+  public bitfield: number | bigint;
+
+  /**
+   * @param {any} [bits] Bit(s) to read from
+   */
+  constructor(bits: any = (BitField as any).DefaultBit) {
+    this.bitfield = (this.constructor as any).resolve(bits);
+  }
+
+  /**
+   * Checks whether the bitfield has a bit, or any of multiple bits.
+   *
+   * @param {any} bit Bit(s) to check for
+   * @returns {boolean}
+   */
+  any(bit: any): boolean {
+    return ((this.bitfield as any) & (this.constructor as any).resolve(bit)) !== (this.constructor as any).DefaultBit;
+  }
+
+  /**
+   * Checks if this bitfield equals another
+   *
+   * @param {any} bit Bit(s) to check for
+   * @returns {boolean}
+   */
+  equals(bit: any): boolean {
+    return this.bitfield === (this.constructor as any).resolve(bit);
+  }
+
+  /**
+   * Checks whether the bitfield has a bit, or multiple bits.
+   *
+   * @param {any} bit Bit(s) to check for
+   * @returns {boolean}
+   */
+  has(bit: any): boolean {
+    const resolvedBit = (this.constructor as any).resolve(bit);
+    return ((this.bitfield as any) & resolvedBit) === resolvedBit;
+  }
+
+  /**
+   * Gets all given bits that are missing from the bitfield.
+   *
+   * @param {any} bits Bit(s) to check for
+   * @param {...any} hasParams Additional parameters for the has method, if any
+   * @returns {string[]}
+   */
+  missing(bits: any, ...hasParams: any[]): string[] {
+    return (new (this.constructor as any)(bits)).remove(this).toArray(...hasParams);
+  }
+
+  /**
+   * Freezes these bits, making them immutable.
+   *
+   * @returns {Readonly<BitField>}
+   */
+  freeze(): Readonly<this> {
+    return Object.freeze(this);
+  }
+
+  /**
+   * Adds bits to these ones.
+   *
+   * @param {...any} bits Bits to add
+   * @returns {BitField} These bits or new BitField if the instance is frozen.
+   */
+  add(...bits: any[]): this {
+    let total: any = (this.constructor as any).DefaultBit;
+    for (const bit of bits) {
+      total |= (this.constructor as any).resolve(bit);
+    }
+
+    if (Object.isFrozen(this)) return new (this.constructor as any)((this.bitfield as any) | total);
+    (this.bitfield as any) |= total;
+    return this;
+  }
+
+  /**
+   * Removes bits from these.
+   *
+   * @param {...any} bits Bits to remove
+   * @returns {BitField} These bits or new BitField if the instance is frozen.
+   */
+  remove(...bits: any[]): this {
+    let total: any = (this.constructor as any).DefaultBit;
+    for (const bit of bits) {
+      total |= (this.constructor as any).resolve(bit);
+    }
+
+    if (Object.isFrozen(this)) return new (this.constructor as any)((this.bitfield as any) & ~total);
+    (this.bitfield as any) &= ~total;
+    return this;
+  }
+
+  /**
+   * Gets an object mapping field names to a {@link boolean} indicating whether the
+   * bit is available.
+   *
+   * @param {...any} hasParams Additional parameters for the has method, if any
+   * @returns {Object}
+   */
+  serialize(...hasParams: any[]): Record<string, boolean> {
+    const serialized: Record<string, boolean> = {};
+    for (const [flag, bit] of Object.entries((this.constructor as any).Flags)) {
+      if (isNaN(flag as any)) serialized[flag] = this.has(bit);
+    }
+
+    return serialized;
+  }
+
+  /**
+   * Gets an {@link Array} of bitfield names based on the bits available.
+   *
+   * @param {...any} hasParams Additional parameters for the has method, if any
+   * @returns {string[]}
+   */
+  toArray(...hasParams: any[]): string[] {
+    return [...this[Symbol.iterator](...hasParams)];
+  }
+
+  toJSON(): string | number {
+    return typeof this.bitfield === 'number' ? this.bitfield : this.bitfield.toString();
+  }
+
+  valueOf(): number | bigint {
+    return this.bitfield;
+  }
+
+  *[Symbol.iterator](...hasParams: any[]): Generator<string> {
+    for (const bitName of Object.keys((this.constructor as any).Flags)) {
+      if (isNaN(bitName as any) && this.has(bitName)) yield bitName;
+    }
+  }
+
+  /**
+   * Resolves bitfields to their numeric form.
+   *
+   * @param {any} [bit] bit(s) to resolve
+   * @returns {number|bigint}
+   */
+  static resolve(bit: any): number | bigint {
+    const { DefaultBit } = this;
+    if (typeof DefaultBit === typeof bit && bit >= DefaultBit) return bit;
+    if (bit instanceof BitField) return bit.bitfield;
+    if (Array.isArray(bit)) {
+      return bit.map(bit_ => this.resolve(bit_)).reduce((prev, bit_) => (prev as any) | (bit_ as any), DefaultBit);
+    }
+
+    if (typeof bit === 'string') {
+      if (!isNaN(bit as any)) return typeof DefaultBit === 'bigint' ? BigInt(bit) : Number(bit);
+      if (this.Flags[bit] !== undefined) return this.Flags[bit];
+    }
+
+    throw new DiscordjsRangeError(ErrorCodes.BitFieldInvalid, bit);
+  }
+}
+

package/src/util/ChannelFlagsBitField.ts

@@ -0,0 +1,43 @@
+/* eslint-disable jsdoc/check-values */
+
+import { ChannelFlags  } from 'discord-api-types/v10';
+import { BitField  } from './BitField.js';
+
+/**
+ * Data structure that makes it easy to interact with a {@link BaseChannel#flags} bitfield.
+ *
+ * @extends {BitField}
+ */
+export class ChannelFlagsBitField extends BitField {
+  /**
+   * Numeric guild channel flags.
+   *
+   * @type {ChannelFlags}
+   * @memberof ChannelFlagsBitField
+   */
+  static Flags = ChannelFlags;
+}
+
+/**
+ * @name ChannelFlagsBitField
+ * @kind constructor
+ * @memberof ChannelFlagsBitField
+ * @param {BitFieldResolvable} [bits=0] Bit(s) to read from
+ */
+
+/**
+ * Bitfield of the packed bits
+ *
+ * @type {number}
+ * @name ChannelFlagsBitField#bitfield
+ */
+
+/**
+ * Data that can be resolved to give a channel flag bitfield. This can be:
+ * - A string (see {@link ChannelFlagsBitField.Flags})
+ * - A channel flag
+ * - An instance of ChannelFlagsBitField
+ * - An Array of ChannelFlagsResolvable
+ *
+ * @typedef {string|number|ChannelFlagsBitField|ChannelFlagsResolvable[]} ChannelFlagsResolvable
+ */

package/src/util/Channels.ts

@@ -0,0 +1,165 @@
+import { lazy  } from '@ovencord/util';
+import { ChannelType  } from 'discord-api-types/v10';
+
+const getCategoryChannel = lazy(() => require('../structures/CategoryChannel.js').CategoryChannel);
+const getDMChannel = lazy(() => require('../structures/DMChannel.js').DMChannel);
+const getAnnouncementChannel = lazy(() => require('../structures/AnnouncementChannel.js').AnnouncementChannel);
+const getStageChannel = lazy(() => require('../structures/StageChannel.js').StageChannel);
+const getTextChannel = lazy(() => require('../structures/TextChannel.js').TextChannel);
+const getThreadChannel = lazy(() => require('../structures/ThreadChannel.js').ThreadChannel);
+const getVoiceChannel = lazy(() => require('../structures/VoiceChannel.js').VoiceChannel);
+const getDirectoryChannel = lazy(() => require('../structures/DirectoryChannel.js').DirectoryChannel);
+const getPartialGroupDMChannel = lazy(() => require('../structures/PartialGroupDMChannel.js').PartialGroupDMChannel);
+const getForumChannel = lazy(() => require('../structures/ForumChannel.js').ForumChannel);
+const getMediaChannel = lazy(() => require('../structures/MediaChannel.js').MediaChannel);
+
+/**
+ * Extra options for creating a channel.
+ *
+ * @typedef {Object} CreateChannelOptions
+ * @property {boolean} [allowFromUnknownGuild] Whether to allow creating a channel from an unknown guild
+ * @private
+ */
+
+/**
+ * Creates a discord.js channel from data received from the API.
+ *
+ * @param {Client} client The client
+ * @param {APIChannel} data The data of the channel to create
+ * @param {Guild} [guild] The guild where this channel belongs
+ * @param {CreateChannelOptions} [extras] Extra information to supply for creating this channel
+ * @returns {BaseChannel} Any kind of channel.
+ * @ignore
+ */
+export function createChannel(client, data, guild, { allowUnknownGuild } = {}) {
+  let channel;
+  const resolvedGuild = guild ?? client.guilds.cache.get(data.guild_id);
+
+  if (!data.guild_id && !resolvedGuild) {
+    if ((data.recipients && data.type !== ChannelType.GroupDM) || data.type === ChannelType.DM) {
+      channel = new (getDMChannel())(client, data);
+    } else if (data.type === ChannelType.GroupDM) {
+      channel = new (getPartialGroupDMChannel())(client, data);
+    }
+  } else if (resolvedGuild || allowUnknownGuild) {
+    switch (data.type) {
+      case ChannelType.GuildText: {
+        channel = new (getTextChannel())(resolvedGuild, data, client);
+        break;
+      }
+
+      case ChannelType.GuildVoice: {
+        channel = new (getVoiceChannel())(resolvedGuild, data, client);
+        break;
+      }
+
+      case ChannelType.GuildCategory: {
+        channel = new (getCategoryChannel())(resolvedGuild, data, client);
+        break;
+      }
+
+      case ChannelType.GuildAnnouncement: {
+        channel = new (getAnnouncementChannel())(resolvedGuild, data, client);
+        break;
+      }
+
+      case ChannelType.GuildStageVoice: {
+        channel = new (getStageChannel())(resolvedGuild, data, client);
+        break;
+      }
+
+      case ChannelType.AnnouncementThread:
+      case ChannelType.PublicThread:
+      case ChannelType.PrivateThread: {
+        channel = new (getThreadChannel())(resolvedGuild, data, client);
+        if (!allowUnknownGuild) channel.parent?.threads.cache.set(channel.id, channel);
+        break;
+      }
+
+      case ChannelType.GuildDirectory:
+        channel = new (getDirectoryChannel())(resolvedGuild, data, client);
+        break;
+      case ChannelType.GuildForum:
+        channel = new (getForumChannel())(resolvedGuild, data, client);
+        break;
+      case ChannelType.GuildMedia:
+        channel = new (getMediaChannel())(resolvedGuild, data, client);
+        break;
+      default:
+        break;
+    }
+
+    if (channel && !allowUnknownGuild) resolvedGuild.channels?.cache.set(channel.id, channel);
+  }
+
+  return channel;
+}
+
+/**
+ * Transforms an API guild forum tag to camel-cased guild forum tag.
+ *
+ * @param {APIGuildForumTag} tag The tag to transform
+ * @returns {GuildForumTag}
+ * @ignore
+ */
+export function transformAPIGuildForumTag(tag) {
+  return {
+    id: tag.id,
+    name: tag.name,
+    moderated: tag.moderated,
+    emoji:
+      (tag.emoji_id ?? tag.emoji_name)
+        ? {
+            id: tag.emoji_id,
+            name: tag.emoji_name,
+          }
+        : null,
+  };
+}
+
+/**
+ * Transforms a camel-cased guild forum tag to an API guild forum tag.
+ *
+ * @param {GuildForumTag} tag The tag to transform
+ * @returns {APIGuildForumTag}
+ * @ignore
+ */
+export function transformGuildForumTag(tag) {
+  return {
+    id: tag.id,
+    name: tag.name,
+    moderated: tag.moderated,
+    emoji_id: tag.emoji?.id ?? null,
+    emoji_name: tag.emoji?.name ?? null,
+  };
+}
+
+/**
+ * Transforms an API guild forum default reaction object to a
+ * camel-cased guild forum default reaction object.
+ *
+ * @param {APIGuildForumDefaultReactionEmoji} defaultReaction The default reaction to transform
+ * @returns {DefaultReactionEmoji}
+ * @ignore
+ */
+export function transformAPIGuildDefaultReaction(defaultReaction) {
+  return {
+    id: defaultReaction.emoji_id,
+    name: defaultReaction.emoji_name,
+  };
+}
+
+/**
+ * Transforms a camel-cased guild forum default reaction object to an
+ * API guild forum default reaction object.
+ *
+ * @param {DefaultReactionEmoji} defaultReaction The default reaction to transform
+ * @returns {APIGuildForumDefaultReactionEmoji}
+ * @ignore
+ */
+export function transformGuildDefaultReaction(defaultReaction) {
+  return {
+    emoji_id: defaultReaction.id,
+    emoji_name: defaultReaction.name,
+  };
+}

package/src/util/Colors.ts

@@ -0,0 +1,72 @@
+
+/**
+ * @typedef {Object} Colors
+ * @property {number} Aqua 0x1ABC9C | rgb(26,188,156)
+ * @property {number} Blue 0x3498DB | rgb(52,152,219)
+ * @property {number} Blurple 0x5865F2 | rgb(88,101,242)
+ * @property {number} DarkAqua 0x11806A | rgb(17,128,106)
+ * @property {number} DarkBlue 0x206694 | rgb(32,102,148)
+ * @property {number} DarkButNotBlack 0x2C2F33 | rgb(44,47,51)
+ * @property {number} DarkerGrey 0x7F8C8D | rgb(127,140,141)
+ * @property {number} DarkGold 0xC27C0E | rgb(194,124,14)
+ * @property {number} DarkGreen 0x1F8B4C | rgb(31,139,76)
+ * @property {number} DarkGrey 0x979C9F | rgb(151,156,159)
+ * @property {number} DarkNavy 0x2C3E50 | rgb(44,62,80)
+ * @property {number} DarkOrange 0xA84300 | rgb(168,67,0)
+ * @property {number} DarkPurple 0x71368A | rgb(113,54,138)
+ * @property {number} DarkRed 0x992D22 | rgb(153,45,34)
+ * @property {number} DarkVividPink 0xAD1457 | rgb(173,20,87)
+ * @property {number} Default 0x000000 | rgb(0,0,0)
+ * @property {number} Fuchsia 0xEB459E | rgb(235,69,158)
+ * @property {number} Gold 0xF1C40F | rgb(241,196,15)
+ * @property {number} Green 0x57F287 | rgb(87,242,135)
+ * @property {number} Grey 0x95A5A6 | rgb(149,165,166)
+ * @property {number} Greyple 0x99AAb5 | rgb(153,170,181)
+ * @property {number} LightGrey 0xBCC0C0 | rgb(188,192,192)
+ * @property {number} LuminousVividPink 0xE91E63 | rgb(233,30,99)
+ * @property {number} Navy 0x34495E | rgb(52,73,94)
+ * @property {number} NotQuiteBlack 0x23272A | rgb(35,39,42)
+ * @property {number} Orange 0xE67E22 | rgb(230,126,34)
+ * @property {number} Purple 0x9B59B6 | rgb(155,89,182)
+ * @property {number} Red 0xED4245 | rgb(237,66,69)
+ * @property {number} White 0xFFFFFF | rgb(255,255,255)
+ * @property {number} Yellow 0xFEE75C | rgb(254,231,92)
+ */
+
+// JSDoc for IntelliSense purposes
+/**
+ * @type {Colors}
+ * @ignore
+ */
+export const Colors = {
+  Aqua: 0x1abc9c,
+  Blue: 0x3498db,
+  Blurple: 0x5865f2,
+  DarkAqua: 0x11806a,
+  DarkBlue: 0x206694,
+  DarkButNotBlack: 0x2c2f33,
+  DarkerGrey: 0x7f8c8d,
+  DarkGold: 0xc27c0e,
+  DarkGreen: 0x1f8b4c,
+  DarkGrey: 0x979c9f,
+  DarkNavy: 0x2c3e50,
+  DarkOrange: 0xa84300,
+  DarkPurple: 0x71368a,
+  DarkRed: 0x992d22,
+  DarkVividPink: 0xad1457,
+  Default: 0x000000,
+  Fuchsia: 0xeb459e,
+  Gold: 0xf1c40f,
+  Green: 0x57f287,
+  Grey: 0x95a5a6,
+  Greyple: 0x99aab5,
+  LightGrey: 0xbcc0c0,
+  LuminousVividPink: 0xe91e63,
+  Navy: 0x34495e,
+  NotQuiteBlack: 0x23272a,
+  Orange: 0xe67e22,
+  Purple: 0x9b59b6,
+  Red: 0xed4245,
+  White: 0xffffff,
+  Yellow: 0xfee75c,
+};