rockcord 4.0.0-dev.4

package/src/util/APITypes.js

@@ -0,0 +1,59 @@
+/**
+ * @external APIGuildScheduledEventRecurrenceRule
+ * @see {@link https://discord-api-types.dev/api/discord-api-types-v10/interface/APIGuildScheduledEventRecurrenceRule}
+ */
+
+/**
+ * @external APIIncidentsData
+ * @see {@link https://discord-api-types.dev/api/discord-api-types-v10/interface/APIIncidentsData}
+ */
+
+/**
+ * @external GuildScheduledEventRecurrenceRuleFrequency
+ * @see {@link https://discord-api-types.dev/api/discord-api-types-v10/enum/GuildScheduledEventRecurrenceRuleFrequency}
+ */
+
+/**
+ * @external GuildScheduledEventRecurrenceRuleMonth
+ * @see {@link https://discord-api-types.dev/api/discord-api-types-v10/enum/GuildScheduledEventRecurrenceRuleMonth}
+ */
+
+/**
+ * @external GuildScheduledEventRecurrenceRuleWeekday
+ * @see {@link https://discord-api-types.dev/api/discord-api-types-v10/enum/GuildScheduledEventRecurrenceRuleWeekday}
+ */
+
+/**
+ * @external MessageActivityType
+ * @see {@link https://discord-api-types.dev/api/discord-api-types-v10/enum/MessageActivityType}
+ */
+
+/**
+ * @external NameplatePalette
+ * @see {@link https://discord-api-types.dev/api/discord-api-types-v10/enum/NameplatePalette}
+ */
+
+/**
+ * @external PollLayoutType
+ * @see {@link https://discord-api-types.dev/api/discord-api-types-v10/enum/PollLayoutType}
+ */
+
+/**
+ * @external ReactionType
+ * @see {@link https://discord-api-types.dev/api/discord-api-types-v10/enum/ReactionType}
+ */
+
+/**
+ * @external RtpPacket
+ * @see {@link https://github.com/shinyoshiaki/werift-webrtc/blob/develop/doc/classes/RtpPacket.md}
+ */
+
+/**
+ * @external TeamMemberRole
+ * @see {@link https://discord-api-types.dev/api/discord-api-types-v10/enum/TeamMemberRole}
+ */
+
+/**
+ * @external VoiceChannelEffectSendAnimationType
+ * @see {@link https://discord-api-types.dev/api/discord-api-types-v10/enum/VoiceChannelEffectSendAnimationType}
+ */

package/src/util/ActivityFlags.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const BitField = require('./BitField');
+
+/**
+ * Data structure that makes it easy to interact with an {@link Activity#flags} bitfield.
+ * @extends {BitField}
+ */
+class ActivityFlags extends BitField {}
+
+/**
+ * @name ActivityFlags
+ * @kind constructor
+ * @memberof ActivityFlags
+ * @param {BitFieldResolvable} [bits=0] Bit(s) to read from
+ */
+
+/**
+ * Numeric activity flags. All available properties:
+ * * `INSTANCE`
+ * * `JOIN`
+ * * `SPECTATE`
+ * * `JOIN_REQUEST`
+ * * `SYNC`
+ * * `PLAY`
+ * * `PARTY_PRIVACY_FRIENDS`
+ * * `PARTY_PRIVACY_VOICE_CHANNEL`
+ * * `EMBEDDED`
+ * @type {Object}
+ * @see {@link https://discord.com/developers/docs/topics/gateway-events#activity-object-activity-flags}
+ */
+ActivityFlags.FLAGS = {
+  INSTANCE: 1 << 0,
+  JOIN: 1 << 1,
+  SPECTATE: 1 << 2,
+  JOIN_REQUEST: 1 << 3,
+  SYNC: 1 << 4,
+  PLAY: 1 << 5,
+  PARTY_PRIVACY_FRIENDS: 1 << 6,
+  PARTY_PRIVACY_VOICE_CHANNEL: 1 << 7,
+  EMBEDDED: 1 << 8,
+};
+
+module.exports = ActivityFlags;

package/src/util/ApplicationFlags.js

@@ -0,0 +1,76 @@
+'use strict';
+
+const BitField = require('./BitField');
+
+/**
+ * Data structure that makes it easy to interact with a {@link Application#flags} bitfield.
+ * @extends {BitField}
+ */
+class ApplicationFlags extends BitField {}
+
+/**
+ * @name ApplicationFlags
+ * @kind constructor
+ * @memberof ApplicationFlags
+ * @param {BitFieldResolvable} [bits=0] Bit(s) to read from
+ */
+
+/**
+ * Bitfield of the packed bits
+ * @type {number}
+ * @name ApplicationFlags#bitfield
+ */
+
+/**
+ * Numeric application flags. All available properties:
+ * * `EMBEDDED_RELEASED`
+ * * `MANAGED_EMOJI`
+ * * `GROUP_DM_CREATE`
+ * * `RPC_PRIVATE_BETA`
+ * * `APPLICATION_AUTO_MODERATION_RULE_CREATE_BADGE`
+ * * `ALLOW_ASSETS`
+ * * `ALLOW_ACTIVITY_ACTION_SPECTATE`
+ * * `ALLOW_ACTIVITY_ACTION_JOIN_REQUEST`
+ * * `RPC_HAS_CONNECTED`
+ * * `GATEWAY_PRESENCE`
+ * * `GATEWAY_PRESENCE_LIMITED`
+ * * `GATEWAY_GUILD_MEMBERS`
+ * * `GATEWAY_GUILD_MEMBERS_LIMITED`
+ * * `VERIFICATION_PENDING_GUILD_LIMIT`
+ * * `EMBEDDED`
+ * * `GATEWAY_MESSAGE_CONTENT`
+ * * `GATEWAY_MESSAGE_CONTENT_LIMITED`
+ * * `EMBEDDED_FIRST_PARTY`
+ * * `APPLICATION_COMMAND_BADGE`
+ * * `ACTIVE`
+ * * `IFRAME_MODAL`
+ * @type {Object}
+ * @see {@link https://discord.com/developers/docs/resources/application#application-object-application-flags}
+ * @see {@link https://flags.lewistehminerz.dev/}
+ */
+ApplicationFlags.FLAGS = {
+  EMBEDDED_RELEASED: 1 << 1,
+  MANAGED_EMOJI: 1 << 2,
+  EMBEDDED_IAP: 1 << 3,
+  GROUP_DM_CREATE: 1 << 4,
+  RPC_PRIVATE_BETA: 1 << 5,
+  APPLICATION_AUTO_MODERATION_RULE_CREATE_BADGE: 1 << 6,
+  ALLOW_ASSETS: 1 << 8,
+  ALLOW_ACTIVITY_ACTION_SPECTATE: 1 << 9,
+  ALLOW_ACTIVITY_ACTION_JOIN_REQUEST: 1 << 10,
+  RPC_HAS_CONNECTED: 1 << 11,
+  GATEWAY_PRESENCE: 1 << 12,
+  GATEWAY_PRESENCE_LIMITED: 1 << 13,
+  GATEWAY_GUILD_MEMBERS: 1 << 14,
+  GATEWAY_GUILD_MEMBERS_LIMITED: 1 << 15,
+  VERIFICATION_PENDING_GUILD_LIMIT: 1 << 16,
+  EMBEDDED: 1 << 17,
+  GATEWAY_MESSAGE_CONTENT: 1 << 18,
+  GATEWAY_MESSAGE_CONTENT_LIMITED: 1 << 19,
+  EMBEDDED_FIRST_PARTY: 1 << 20,
+  APPLICATION_COMMAND_BADGE: 1 << 23,
+  ACTIVE: 1 << 24,
+  IFRAME_MODAL: 1 << 26,
+};
+
+module.exports = ApplicationFlags;

package/src/util/AttachmentFlags.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const BitField = require('./BitField');
+
+/**
+ * Data structure that makes it easy to interact with an {@link GuildMember#flags} bitfield.
+ * @extends {BitField}
+ */
+class AttachmentFlags extends BitField {}
+
+/**
+ * @name AttachmentFlags
+ * @kind constructor
+ * @memberof AttachmentFlags
+ * @param {BitFieldResolvable} [bits=0] Bit(s) to read from
+ */
+
+/* eslint-disable max-len */
+/**
+ * Numeric guild member flags. All available properties:
+ * * `IS_REMIX`
+ * @type {Object}
+ * @see {@link https://discord.com/developers/docs/resources/channel#attachment-object-attachment-structure-attachment-flags}
+ */
+AttachmentFlags.FLAGS = {
+  IS_REMIX: 1 << 2,
+};
+
+/**
+ * Data that can be resolved to give a guild attachment bitfield. This can be:
+ * * A string (see {@link AttachmentFlags.FLAGS})
+ * * A attachment flag
+ * * An instance of AttachmentFlags
+ * * An Array of AttachmentFlagsResolvable
+ * @typedef {string|number|AttachmentFlags|AttachmentFlagsResolvable[]} AttachmentFlagsResolvable
+ */
+
+module.exports = AttachmentFlags;

package/src/util/BitField.js

@@ -0,0 +1,182 @@
+'use strict';
+
+const { RangeError } = require('../errors');
+
+/**
+ * Data structure that makes it easy to interact with a bitfield.
+ */
+class BitField {
+  /**
+   * @param {BitFieldResolvable} [bits=this.constructor.defaultBit] Bit(s) to read from
+   */
+  constructor(bits = this.constructor.defaultBit) {
+    /**
+     * Bitfield of the packed bits
+     * @type {number|bigint}
+     */
+    this.bitfield = this.constructor.resolve(bits);
+  }
+
+  /**
+   * Checks whether the bitfield has a bit, or any of multiple bits.
+   * @param {BitFieldResolvable} bit Bit(s) to check for
+   * @returns {boolean}
+   */
+  any(bit) {
+    return (BigInt(this.bitfield) & BigInt(this.constructor.resolve(bit))) !== 0n;
+  }
+
+  /**
+   * Checks if this bitfield equals another
+   * @param {BitFieldResolvable} bit Bit(s) to check for
+   * @returns {boolean}
+   */
+  equals(bit) {
+    return this.bitfield === this.constructor.resolve(bit);
+  }
+
+  /**
+   * Checks whether the bitfield has a bit, or multiple bits.
+   * @param {BitFieldResolvable} bit Bit(s) to check for
+   * @returns {boolean}
+   */
+  has(bit) {
+    bit = this.constructor.resolve(bit);
+    return (BigInt(this.bitfield) & BigInt(bit)) === BigInt(bit);
+  }
+
+  /**
+   * Gets all given bits that are missing from the bitfield.
+   * @param {BitFieldResolvable} bits Bit(s) to check for
+   * @param {...*} hasParams Additional parameters for the has method, if any
+   * @returns {string[]}
+   */
+  missing(bits, ...hasParams) {
+    return new this.constructor(bits).remove(this).toArray(...hasParams);
+  }
+
+  /**
+   * Freezes these bits, making them immutable.
+   * @returns {Readonly<BitField>}
+   */
+  freeze() {
+    return Object.freeze(this);
+  }
+
+  /**
+   * Adds bits to these ones.
+   * @param {...BitFieldResolvable} [bits] Bits to add
+   * @returns {BitField} These bits or new BitField if the instance is frozen.
+   */
+  add(...bits) {
+    let total = 0n;
+    for (const bit of bits) {
+      total |= BigInt(this.constructor.resolve(bit));
+    }
+    const result = this.constructor.convert(BigInt(this.bitfield) | total);
+    if (Object.isFrozen(this)) return new this.constructor(result);
+    this.bitfield = result;
+    return this;
+  }
+
+  /**
+   * Removes bits from these.
+   * @param {...BitFieldResolvable} [bits] Bits to remove
+   * @returns {BitField} These bits or new BitField if the instance is frozen.
+   */
+  remove(...bits) {
+    let total = 0n;
+    for (const bit of bits) {
+      total |= BigInt(this.constructor.resolve(bit));
+    }
+    const result = this.constructor.convert(BigInt(this.bitfield) & ~total);
+    if (Object.isFrozen(this)) return new this.constructor(result);
+    this.bitfield = result;
+    return this;
+  }
+
+  /**
+   * Gets an object mapping field names to a {@link boolean} indicating whether the
+   * bit is available.
+   * @param {...*} hasParams Additional parameters for the has method, if any
+   * @returns {Object}
+   */
+  serialize(...hasParams) {
+    const serialized = {};
+    for (const [flag, bit] of Object.entries(this.constructor.FLAGS)) serialized[flag] = this.has(bit, ...hasParams);
+    return serialized;
+  }
+
+  /**
+   * Gets an {@link Array} of bitfield names based on the bits available.
+   * @param {...*} hasParams Additional parameters for the has method, if any
+   * @returns {string[]}
+   */
+  toArray(...hasParams) {
+    return Object.keys(this.constructor.FLAGS).filter(bit => this.has(bit, ...hasParams));
+  }
+
+  toJSON() {
+    return typeof this.bitfield === 'number' ? this.bitfield : this.bitfield.toString();
+  }
+
+  valueOf() {
+    return this.bitfield;
+  }
+
+  *[Symbol.iterator]() {
+    yield* this.toArray();
+  }
+
+  /**
+   * Data that can be resolved to give a bitfield. This can be:
+   * * A bit number (this can be a number literal or a value taken from {@link BitField.FLAGS})
+   * * A string bit number
+   * * An instance of BitField
+   * * An Array of BitFieldResolvable
+   * @typedef {number|string|bigint|BitField|BitFieldResolvable[]} BitFieldResolvable
+   */
+
+  /**
+   * Resolves bitfields to their numeric form.
+   * @param {BitFieldResolvable} [bit] bit(s) to resolve
+   * @returns {number|bigint}
+   */
+  static resolve(bit) {
+    const { defaultBit } = this;
+    if (
+      typeof defaultBit === typeof bit &&
+      bit >= defaultBit &&
+      (typeof bit === 'bigint' || Number.isSafeInteger(bit))
+    ) {
+      return bit;
+    }
+    if (bit instanceof BitField) return this.resolve(bit.bitfield);
+    if (Array.isArray(bit)) return this.convert(bit.reduce((prev, p) => prev | BigInt(this.resolve(p)), 0n));
+    if (typeof bit === 'string') {
+      if (/^\d+$/.test(bit)) return this.resolve(typeof defaultBit === 'bigint' ? BigInt(bit) : Number(bit));
+      if (this.FLAGS[bit] !== undefined) return this.FLAGS[bit];
+    }
+    throw new RangeError('BITFIELD_INVALID', bit);
+  }
+
+  static convert(bit) {
+    return this.resolve(typeof this.defaultBit === 'bigint' ? bit : Number(bit));
+  }
+}
+
+/**
+ * Numeric bitfield flags.
+ * <info>Defined in extension classes</info>
+ * @type {Object}
+ * @abstract
+ */
+BitField.FLAGS = {};
+
+/**
+ * @type {number|bigint}
+ * @private
+ */
+BitField.defaultBit = 0;
+
+module.exports = BitField;

package/src/util/ChannelFlags.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const BitField = require('./BitField');
+
+/**
+ * Data structure that makes it easy to interact with a {@link Channel#flags} bitfield.
+ * @extends {BitField}
+ */
+class ChannelFlags extends BitField {}
+
+/**
+ * Numeric guild channel flags. All available properties:
+ * * `PINNED`
+ * * `REQUIRE_TAG`
+ * @type {Object}
+ * @see {@link https://discord.com/developers/docs/resources/channel#channel-object-channel-flags}
+ */
+ChannelFlags.FLAGS = {
+  PINNED: 1 << 1,
+  REQUIRE_TAG: 1 << 4,
+};
+
+/**
+ * @name ChannelFlags
+ * @kind constructor
+ * @memberof ChannelFlags
+ * @param {BitFieldResolvable} [bits=0] Bit(s) to read from
+ */
+
+/**
+ * Bitfield of the packed bits
+ * @type {number}
+ * @name ChannelFlags#bitfield
+ */
+
+/**
+ * Data that can be resolved to give a channel flag bitfield. This can be:
+ * * A string (see {@link ChannelFlags.FLAGS})
+ * * A channel flag
+ * * An instance of ChannelFlags
+ * * An Array of ChannelFlags
+ * @typedef {string|number|ChannelFlags|ChannelFlagsResolvable[]} ChannelFlagsResolvable
+ */
+
+module.exports = ChannelFlags;