@ovencord/discord.js 14.16.3

package/src/client/websocket/handlers/USER_UPDATE.ts

@@ -0,0 +1,4 @@
+
+module.exports = (client, packet) => {
+  client.actions.UserUpdate.handle(packet.d);
+};

package/src/client/websocket/handlers/VOICE_CHANNEL_EFFECT_SEND.ts

@@ -0,0 +1,16 @@
+
+import { VoiceChannelEffect  } from '../../../structures/VoiceChannelEffect.js';
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+  if (!guild) return;
+
+  /**
+   * Emitted when someone sends an effect, such as an emoji reaction, in a voice channel the client is connected to.
+   *
+   * @event Client#voiceChannelEffectSend
+   * @param {VoiceChannelEffect} voiceChannelEffect The sent voice channel effect
+   */
+  client.emit(Events.VoiceChannelEffectSend, new VoiceChannelEffect(data, guild));
+};

package/src/client/websocket/handlers/VOICE_SERVER_UPDATE.ts

@@ -0,0 +1,5 @@
+
+module.exports = (client, packet) => {
+  client.emit('debug', `[VOICE] received voice server: ${JSON.stringify(packet)}`);
+  client.voice.onVoiceServer(packet.d);
+};

package/src/client/websocket/handlers/VOICE_STATE_UPDATE.ts

@@ -0,0 +1,37 @@
+
+import { VoiceState  } from '../../../structures/VoiceState.js';
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+  if (!guild) return;
+
+  // Update the state
+  const oldState =
+    guild.voiceStates.cache.get(data.user_id)?._clone() ?? new VoiceState(guild, { user_id: data.user_id });
+
+  const newState = guild.voiceStates._add(data);
+
+  // Get the member
+  let member = guild.members.cache.get(data.user_id);
+  if (member && data.member) {
+    member._patch(data.member);
+  } else if (data.member?.user && data.member.joined_at) {
+    member = guild.members._add(data.member);
+  }
+
+  // Emit event
+  if (member?.user.id === client.user.id) {
+    client.emit('debug', `[VOICE] received voice state update: ${JSON.stringify(data)}`);
+    client.voice.onVoiceStateUpdate(data);
+  }
+
+  /**
+   * Emitted whenever a member changes voice state - e.g. joins/leaves a channel, mutes/unmutes.
+   *
+   * @event Client#voiceStateUpdate
+   * @param {VoiceState} oldState The voice state before the update
+   * @param {VoiceState} newState The voice state after the update
+   */
+  client.emit(Events.VoiceStateUpdate, oldState, newState);
+};

package/src/client/websocket/handlers/WEBHOOKS_UPDATE.ts

@@ -0,0 +1,16 @@
+
+import { Events  } from '../../../util/Events.js';
+
+module.exports = (client, { d: data }) => {
+  const channel = client.channels.cache.get(data.channel_id);
+  if (!channel) return;
+
+  /**
+   * Emitted whenever a channel has its webhooks changed.
+   *
+   * @event Client#webhooksUpdate
+   * @param {TextChannel|AnnouncementChannel|VoiceChannel|StageChannel|ForumChannel|MediaChannel} channel
+   * The channel that had a webhook update
+   */
+  client.emit(Events.WebhooksUpdate, channel);
+};

package/src/client/websocket/handlers/index.ts

@@ -0,0 +1,74 @@
+const PacketHandlers = Object.fromEntries([
+  ['APPLICATION_COMMAND_PERMISSIONS_UPDATE', require('./APPLICATION_COMMAND_PERMISSIONS_UPDATE.js')],
+  ['AUTO_MODERATION_ACTION_EXECUTION', require('./AUTO_MODERATION_ACTION_EXECUTION.js')],
+  ['AUTO_MODERATION_RULE_CREATE', require('./AUTO_MODERATION_RULE_CREATE.js')],
+  ['AUTO_MODERATION_RULE_DELETE', require('./AUTO_MODERATION_RULE_DELETE.js')],
+  ['AUTO_MODERATION_RULE_UPDATE', require('./AUTO_MODERATION_RULE_UPDATE.js')],
+  ['CHANNEL_CREATE', require('./CHANNEL_CREATE.js')],
+  ['CHANNEL_DELETE', require('./CHANNEL_DELETE.js')],
+  ['CHANNEL_PINS_UPDATE', require('./CHANNEL_PINS_UPDATE.js')],
+  ['CHANNEL_UPDATE', require('./CHANNEL_UPDATE.js')],
+  ['ENTITLEMENT_CREATE', require('./ENTITLEMENT_CREATE.js')],
+  ['ENTITLEMENT_DELETE', require('./ENTITLEMENT_DELETE.js')],
+  ['ENTITLEMENT_UPDATE', require('./ENTITLEMENT_UPDATE.js')],
+  ['GUILD_AUDIT_LOG_ENTRY_CREATE', require('./GUILD_AUDIT_LOG_ENTRY_CREATE.js')],
+  ['GUILD_BAN_ADD', require('./GUILD_BAN_ADD.js')],
+  ['GUILD_BAN_REMOVE', require('./GUILD_BAN_REMOVE.js')],
+  ['GUILD_CREATE', require('./GUILD_CREATE.js')],
+  ['GUILD_DELETE', require('./GUILD_DELETE.js')],
+  ['GUILD_EMOJIS_UPDATE', require('./GUILD_EMOJIS_UPDATE.js')],
+  ['GUILD_INTEGRATIONS_UPDATE', require('./GUILD_INTEGRATIONS_UPDATE.js')],
+  ['GUILD_MEMBERS_CHUNK', require('./GUILD_MEMBERS_CHUNK.js')],
+  ['GUILD_MEMBER_ADD', require('./GUILD_MEMBER_ADD.js')],
+  ['GUILD_MEMBER_REMOVE', require('./GUILD_MEMBER_REMOVE.js')],
+  ['GUILD_MEMBER_UPDATE', require('./GUILD_MEMBER_UPDATE.js')],
+  ['GUILD_ROLE_CREATE', require('./GUILD_ROLE_CREATE.js')],
+  ['GUILD_ROLE_DELETE', require('./GUILD_ROLE_DELETE.js')],
+  ['GUILD_ROLE_UPDATE', require('./GUILD_ROLE_UPDATE.js')],
+  ['GUILD_SCHEDULED_EVENT_CREATE', require('./GUILD_SCHEDULED_EVENT_CREATE.js')],
+  ['GUILD_SCHEDULED_EVENT_DELETE', require('./GUILD_SCHEDULED_EVENT_DELETE.js')],
+  ['GUILD_SCHEDULED_EVENT_UPDATE', require('./GUILD_SCHEDULED_EVENT_UPDATE.js')],
+  ['GUILD_SCHEDULED_EVENT_USER_ADD', require('./GUILD_SCHEDULED_EVENT_USER_ADD.js')],
+  ['GUILD_SCHEDULED_EVENT_USER_REMOVE', require('./GUILD_SCHEDULED_EVENT_USER_REMOVE.js')],
+  ['GUILD_SOUNDBOARD_SOUNDS_UPDATE', require('./GUILD_SOUNDBOARD_SOUNDS_UPDATE.js')],
+  ['GUILD_SOUNDBOARD_SOUND_CREATE', require('./GUILD_SOUNDBOARD_SOUND_CREATE.js')],
+  ['GUILD_SOUNDBOARD_SOUND_DELETE', require('./GUILD_SOUNDBOARD_SOUND_DELETE.js')],
+  ['GUILD_SOUNDBOARD_SOUND_UPDATE', require('./GUILD_SOUNDBOARD_SOUND_UPDATE.js')],
+  ['GUILD_STICKERS_UPDATE', require('./GUILD_STICKERS_UPDATE.js')],
+  ['GUILD_UPDATE', require('./GUILD_UPDATE.js')],
+  ['INTERACTION_CREATE', require('./INTERACTION_CREATE.js')],
+  ['INVITE_CREATE', require('./INVITE_CREATE.js')],
+  ['INVITE_DELETE', require('./INVITE_DELETE.js')],
+  ['MESSAGE_CREATE', require('./MESSAGE_CREATE.js')],
+  ['MESSAGE_DELETE', require('./MESSAGE_DELETE.js')],
+  ['MESSAGE_DELETE_BULK', require('./MESSAGE_DELETE_BULK.js')],
+  ['MESSAGE_POLL_VOTE_ADD', require('./MESSAGE_POLL_VOTE_ADD.js')],
+  ['MESSAGE_POLL_VOTE_REMOVE', require('./MESSAGE_POLL_VOTE_REMOVE.js')],
+  ['MESSAGE_REACTION_ADD', require('./MESSAGE_REACTION_ADD.js')],
+  ['MESSAGE_REACTION_REMOVE', require('./MESSAGE_REACTION_REMOVE.js')],
+  ['MESSAGE_REACTION_REMOVE_ALL', require('./MESSAGE_REACTION_REMOVE_ALL.js')],
+  ['MESSAGE_REACTION_REMOVE_EMOJI', require('./MESSAGE_REACTION_REMOVE_EMOJI.js')],
+  ['MESSAGE_UPDATE', require('./MESSAGE_UPDATE.js')],
+  ['PRESENCE_UPDATE', require('./PRESENCE_UPDATE.js')],
+  ['RATE_LIMITED', require('./RATE_LIMITED.js')],
+  ['READY', require('./READY.js')],
+  ['SOUNDBOARD_SOUNDS', require('./SOUNDBOARD_SOUNDS.js')],
+  ['STAGE_INSTANCE_CREATE', require('./STAGE_INSTANCE_CREATE.js')],
+  ['STAGE_INSTANCE_DELETE', require('./STAGE_INSTANCE_DELETE.js')],
+  ['STAGE_INSTANCE_UPDATE', require('./STAGE_INSTANCE_UPDATE.js')],
+  ['SUBSCRIPTION_CREATE', require('./SUBSCRIPTION_CREATE.js')],
+  ['SUBSCRIPTION_DELETE', require('./SUBSCRIPTION_DELETE.js')],
+  ['SUBSCRIPTION_UPDATE', require('./SUBSCRIPTION_UPDATE.js')],
+  ['THREAD_CREATE', require('./THREAD_CREATE.js')],
+  ['THREAD_DELETE', require('./THREAD_DELETE.js')],
+  ['THREAD_LIST_SYNC', require('./THREAD_LIST_SYNC.js')],
+  ['THREAD_MEMBERS_UPDATE', require('./THREAD_MEMBERS_UPDATE.js')],
+  ['THREAD_MEMBER_UPDATE', require('./THREAD_MEMBER_UPDATE.js')],
+  ['THREAD_UPDATE', require('./THREAD_UPDATE.js')],
+  ['TYPING_START', require('./TYPING_START.js')],
+  ['USER_UPDATE', require('./USER_UPDATE.js')],
+  ['VOICE_CHANNEL_EFFECT_SEND', require('./VOICE_CHANNEL_EFFECT_SEND.js')],
+  ['VOICE_SERVER_UPDATE', require('./VOICE_SERVER_UPDATE.js')],
+  ['VOICE_STATE_UPDATE', require('./VOICE_STATE_UPDATE.js')],
+  ['WEBHOOKS_UPDATE', require('./WEBHOOKS_UPDATE.js')],
+]);

package/src/errors/DJSError.ts

@@ -0,0 +1,50 @@
+// Heavily inspired by node's `internal/errors` module
+import { ErrorCodes  } from './ErrorCodes.js';
+import { Messages  } from './Messages.js';
+
+/**
+ * Extend an error of some sort into a DiscordjsError.
+ *
+ * @param {Error} Base Base error to extend
+ * @returns {DiscordjsError}
+ * @ignore
+ */
+export function makeDiscordjsError(Base) {
+  return class extends Base {
+    static {
+      Object.defineProperty(this, 'name', { value: `Discordjs${Base.name}` });
+    }
+
+    constructor(code, ...args) {
+      super(message(code, args));
+      this.code = code;
+      Error.captureStackTrace(this, this.constructor);
+    }
+
+    get name() {
+      return `${this.constructor.name} [${this.code}]`;
+    }
+  };
+}
+
+/**
+ * Format the message for an error.
+ *
+ * @param {string} code The error code
+ * @param {Array<*>} args Arguments to pass for util format or as function args
+ * @returns {string} Formatted string
+ * @ignore
+ */
+export function message(code, args) {
+  if (!(code in ErrorCodes)) throw new Error('Error code must be a valid DiscordjsErrorCodes');
+  const msg = Messages[code];
+  if (!msg) throw new Error(`No message associated with error code: ${code}.`);
+  if (typeof msg === 'function') return msg(...args);
+  if (!args?.length) return msg;
+  args.unshift(msg);
+  return String(...args);
+}
+
+exports.DiscordjsError = makeDiscordjsError(Error);
+exports.DiscordjsTypeError = makeDiscordjsError(TypeError);
+exports.DiscordjsRangeError = makeDiscordjsError(RangeError);

package/src/errors/ErrorCodes.ts

@@ -0,0 +1,277 @@
+/* eslint-disable jsdoc/tag-lines, jsdoc/require-property-description */
+
+/**
+ * @typedef {Object} DiscordjsErrorCodes
+ * @property {'ClientInvalidOption'} ClientInvalidOption
+ * @property {'ClientInvalidProvidedShards'} ClientInvalidProvidedShards
+ * @property {'ClientMissingIntents'} ClientMissingIntents
+ * @property {'ClientNotReady'} ClientNotReady
+ *
+ * @property {'TokenInvalid'} TokenInvalid
+ * @property {'TokenMissing'} TokenMissing
+ * @property {'ApplicationCommandPermissionsTokenMissing'} ApplicationCommandPermissionsTokenMissing
+ *
+ * @property {'BitFieldInvalid'} BitFieldInvalid
+ *
+ * @property {'ShardingNoShards'} ShardingNoShards
+ * @property {'ShardingInProcess'} ShardingInProcess
+ * @property {'ShardingInvalidEvalBroadcast'} ShardingInvalidEvalBroadcast
+ * @property {'ShardingShardNotFound'} ShardingShardNotFound
+ * @property {'ShardingAlreadySpawned'} ShardingAlreadySpawned
+ * @property {'ShardingProcessExists'} ShardingProcessExists
+ * @property {'ShardingWorkerExists'} ShardingWorkerExists
+ * @property {'ShardingReadyTimeout'} ShardingReadyTimeout
+ * @property {'ShardingReadyDisconnected'} ShardingReadyDisconnected
+ * @property {'ShardingReadyDied'} ShardingReadyDied
+ * @property {'ShardingNoChildExists'} ShardingNoChildExists
+ * @property {'ShardingShardMiscalculation'} ShardingShardMiscalculation
+ *
+ * @property {'ColorRange'} ColorRange
+ * @property {'ColorConvert'} ColorConvert
+ *
+ * @property {'InviteOptionsMissingChannel'} InviteOptionsMissingChannel
+ *
+ * @property {'InteractionCollectorError'} InteractionCollectorError
+ *
+ * @property {'FileNotFound'} FileNotFound
+ *
+ * @property {'UserNoDMChannel'} UserNoDMChannel
+ *
+ * @property {'VoiceNotStageChannel'} VoiceNotStageChannel
+ *
+ * @property {'VoiceStateNotOwn'} VoiceStateNotOwn
+ * @property {'VoiceStateInvalidType'} VoiceStateInvalidType
+ *
+ * @property {'ReqResourceType'} ReqResourceType
+ *
+ * @property {'MessageBulkDeleteType'} MessageBulkDeleteType
+ * @property {'MessageContentType'} MessageContentType
+ * @property {'MessageNonceRequired'} MessageNonceRequired
+ * @property {'MessageNonceType'} MessageNonceType
+ *
+ * @property {'BanResolveId'} BanResolveId
+ * @property {'FetchBanResolveId'} FetchBanResolveId
+ *
+ * @property {'PruneDaysType'} PruneDaysType
+ *
+ * @property {'GuildChannelResolve'} GuildChannelResolve
+ * @property {'GuildVoiceChannelResolve'} GuildVoiceChannelResolve
+ * @property {'GuildChannelOrphan'} GuildChannelOrphan
+ * @property {'GuildChannelUnowned'} GuildChannelUnowned
+ * @property {'GuildMembersTimeout'} GuildMembersTimeout
+ * @property {'GuildSoundboardSoundsTimeout'} GuildSoundboardSoundsTimeout
+ * @property {'GuildUncachedMe'} GuildUncachedMe
+ * @property {'ChannelNotCached'} ChannelNotCached
+ * @property {'StageChannelResolve'} StageChannelResolve
+ * @property {'GuildScheduledEventResolve'} GuildScheduledEventResolve
+ * @property {'FetchOwnerId'} FetchOwnerId
+ *
+ * @property {'InvalidType'} InvalidType
+ * @property {'InvalidElement'} InvalidElement
+ *
+ * @property {'MessageThreadParent'} MessageThreadParent
+ * @property {'MessageExistingThread'} MessageExistingThread
+ * @property {'ThreadInvitableType'} ThreadInvitableType
+ * @property {'NotAThreadOfParent'} NotAThreadOfParent
+ *
+ * @property {'WebhookMessage'} WebhookMessage
+ * @property {'WebhookTokenUnavailable'} WebhookTokenUnavailable
+ * @property {'WebhookApplication'} WebhookApplication
+ *
+ * @property {'MessageReferenceMissing'} MessageReferenceMissing
+ *
+ * @property {'EmojiType'} EmojiType
+ * @property {'EmojiManaged'} EmojiManaged
+ * @property {'MissingGuildExpressionsPermission'} MissingGuildExpressionsPermission
+ *
+ * @property {'NotGuildSoundboardSound'} NotGuildSoundboardSound
+ * @property {'NotGuildSticker'} NotGuildSticker
+ *
+ * @property {'ReactionResolveUser'} ReactionResolveUser
+ *
+ * @property {'InviteResolveCode'} InviteResolveCode
+ * @property {'InviteNotFound'} InviteNotFound
+ *
+ * @property {'DeleteGroupDMChannel'} DeleteGroupDMChannel
+ * @property {'FetchGroupDMChannel'} FetchGroupDMChannel
+ *
+ * @property {'MemberFetchNonceLength'} MemberFetchNonceLength
+ *
+ * @property {'GlobalCommandPermissions'} GlobalCommandPermissions
+ * @property {'GuildUncachedEntityResolve'} GuildUncachedEntityResolve
+ *
+ * @property {'InteractionAlreadyReplied'} InteractionAlreadyReplied
+ * @property {'InteractionNotReplied'} InteractionNotReplied
+ *
+ * @property {'CommandInteractionOptionNotFound'} CommandInteractionOptionNotFound
+ * @property {'CommandInteractionOptionType'} CommandInteractionOptionType
+ * @property {'CommandInteractionOptionEmpty'} CommandInteractionOptionEmpty
+ * @property {'CommandInteractionOptionNoSubcommand'} CommandInteractionOptionNoSubcommand
+ * @property {'CommandInteractionOptionNoSubcommandGroup'} CommandInteractionOptionNoSubcommandGroup
+ * @property {'CommandInteractionOptionInvalidChannelType'} CommandInteractionOptionInvalidChannelType
+ * @property {'AutocompleteInteractionOptionNoFocusedOption'} AutocompleteInteractionOptionNoFocusedOption
+ *
+ * @property {'ModalSubmitInteractionComponentNotFound'} ModalSubmitInteractionComponentNotFound
+ * @property {'ModalSubmitInteractionComponentType'} ModalSubmitInteractionComponentType
+ * @property {'ModalSubmitInteractionComponentEmpty'} ModalSubmitInteractionComponentEmpty
+ * @property {'ModalSubmitInteractionComponentInvalidChannelType'} ModalSubmitInteractionComponentInvalidChannelType
+ *
+ * @property {'InvalidMissingScopes'} InvalidMissingScopes
+ * @property {'InvalidScopesWithPermissions'} InvalidScopesWithPermissions
+ *
+ * @property {'NotImplemented'} NotImplemented
+ *
+ * @property {'GuildForumMessageRequired'} GuildForumMessageRequired
+ *
+ * @property {'SweepFilterReturn'} SweepFilterReturn
+ *
+ * @property {'EntitlementCreateInvalidOwner'} EntitlementCreateInvalidOwner
+ *
+ * @property {'BulkBanUsersOptionEmpty'} BulkBanUsersOptionEmpty
+ *
+ * @property {'PollAlreadyExpired'} PollAlreadyExpired
+ *
+ * @property {'PermissionOverwritesTypeMandatory'} PermissionOverwritesTypeMandatory
+ * @property {'PermissionOverwritesTypeMismatch'} PermissionOverwritesTypeMismatch
+ */
+
+const keys = [
+  'ClientInvalidOption',
+  'ClientInvalidProvidedShards',
+  'ClientMissingIntents',
+  'ClientNotReady',
+
+  'TokenInvalid',
+  'TokenMissing',
+  'ApplicationCommandPermissionsTokenMissing',
+
+  'BitFieldInvalid',
+
+  'ShardingNoShards',
+  'ShardingInProcess',
+  'ShardingInvalidEvalBroadcast',
+  'ShardingShardNotFound',
+  'ShardingAlreadySpawned',
+  'ShardingProcessExists',
+  'ShardingWorkerExists',
+  'ShardingReadyTimeout',
+  'ShardingReadyDisconnected',
+  'ShardingReadyDied',
+  'ShardingNoChildExists',
+  'ShardingShardMiscalculation',
+
+  'ColorRange',
+  'ColorConvert',
+
+  'InviteOptionsMissingChannel',
+
+  'InteractionCollectorError',
+
+  'FileNotFound',
+
+  'UserNoDMChannel',
+
+  'VoiceNotStageChannel',
+
+  'VoiceStateNotOwn',
+  'VoiceStateInvalidType',
+
+  'ReqResourceType',
+
+  'MessageBulkDeleteType',
+  'MessageContentType',
+  'MessageNonceRequired',
+  'MessageNonceType',
+
+  'BanResolveId',
+  'FetchBanResolveId',
+
+  'PruneDaysType',
+
+  'GuildChannelResolve',
+  'GuildVoiceChannelResolve',
+  'GuildChannelOrphan',
+  'GuildChannelUnowned',
+  'GuildMembersTimeout',
+  'GuildSoundboardSoundsTimeout',
+  'GuildUncachedMe',
+  'ChannelNotCached',
+  'StageChannelResolve',
+  'GuildScheduledEventResolve',
+  'FetchOwnerId',
+
+  'InvalidType',
+  'InvalidElement',
+
+  'MessageThreadParent',
+  'MessageExistingThread',
+  'ThreadInvitableType',
+  'NotAThreadOfParent',
+
+  'WebhookMessage',
+  'WebhookTokenUnavailable',
+  'WebhookApplication',
+
+  'MessageReferenceMissing',
+
+  'EmojiType',
+  'EmojiManaged',
+  'MissingGuildExpressionsPermission',
+
+  'NotGuildSoundboardSound',
+  'NotGuildSticker',
+
+  'ReactionResolveUser',
+
+  'InviteResolveCode',
+  'InviteNotFound',
+
+  'DeleteGroupDMChannel',
+  'FetchGroupDMChannel',
+
+  'MemberFetchNonceLength',
+
+  'GlobalCommandPermissions',
+  'GuildUncachedEntityResolve',
+
+  'InteractionAlreadyReplied',
+  'InteractionNotReplied',
+
+  'CommandInteractionOptionNotFound',
+  'CommandInteractionOptionType',
+  'CommandInteractionOptionEmpty',
+  'CommandInteractionOptionNoSubcommand',
+  'CommandInteractionOptionNoSubcommandGroup',
+  'CommandInteractionOptionInvalidChannelType',
+  'AutocompleteInteractionOptionNoFocusedOption',
+
+  'ModalSubmitInteractionComponentNotFound',
+  'ModalSubmitInteractionComponentType',
+  'ModalSubmitInteractionComponentEmpty',
+  'ModalSubmitInteractionComponentInvalidChannelType',
+
+  'InvalidMissingScopes',
+  'InvalidScopesWithPermissions',
+
+  'NotImplemented',
+
+  'SweepFilterReturn',
+
+  'GuildForumMessageRequired',
+
+  'EntitlementCreateInvalidOwner',
+
+  'BulkBanUsersOptionEmpty',
+
+  'PollAlreadyExpired',
+
+  'PermissionOverwritesTypeMandatory',
+  'PermissionOverwritesTypeMismatch',
+];
+
+// JSDoc for IntelliSense purposes
+/**
+ * @type {DiscordjsErrorCodes}
+ * @ignore
+ */
+const ErrorCodes = Object.fromEntries(keys.map(key => [key, key]));

package/src/errors/Messages.ts

@@ -0,0 +1,155 @@
+import { ErrorCodes  } from './ErrorCodes.js';
+
+const Messages = {
+  [ErrorCodes.ClientInvalidOption]: (prop, must) => `The ${prop} option must be ${must}`,
+  [ErrorCodes.ClientInvalidProvidedShards]: 'None of the provided shards were valid.',
+  [ErrorCodes.ClientMissingIntents]: 'Valid intents must be provided for the Client.',
+  [ErrorCodes.ClientNotReady]: action => `The client needs to be logged in to ${action}.`,
+
+  [ErrorCodes.TokenInvalid]: 'An invalid token was provided.',
+  [ErrorCodes.TokenMissing]: 'Request to use token, but token was unavailable to the client.',
+  [ErrorCodes.ApplicationCommandPermissionsTokenMissing]:
+    'Editing application command permissions requires an OAuth2 bearer token, but none was provided.',
+
+  [ErrorCodes.BitFieldInvalid]: bit => `Invalid bitfield flag or number: ${bit}.`,
+
+  [ErrorCodes.ShardingNoShards]: 'No shards have been spawned.',
+  [ErrorCodes.ShardingInProcess]: 'Shards are still being spawned.',
+  [ErrorCodes.ShardingInvalidEvalBroadcast]: 'Script to evaluate must be a function',
+  [ErrorCodes.ShardingShardNotFound]: id => `Shard ${id} could not be found.`,
+  [ErrorCodes.ShardingAlreadySpawned]: count => `Already spawned ${count} shards.`,
+  [ErrorCodes.ShardingProcessExists]: id => `Shard ${id} already has an active process.`,
+  [ErrorCodes.ShardingWorkerExists]: id => `Shard ${id} already has an active worker.`,
+  [ErrorCodes.ShardingReadyTimeout]: id => `Shard ${id}'s Client took too long to become ready.`,
+  [ErrorCodes.ShardingReadyDisconnected]: id => `Shard ${id}'s Client disconnected before becoming ready.`,
+  [ErrorCodes.ShardingReadyDied]: id => `Shard ${id}'s process exited before its Client became ready.`,
+  [ErrorCodes.ShardingNoChildExists]: id => `Shard ${id} has no active process or worker.`,
+  [ErrorCodes.ShardingShardMiscalculation]: (shard, guild, count) =>
+    `Calculated invalid shard ${shard} for guild ${guild} with ${count} shards.`,
+
+  [ErrorCodes.ColorRange]: 'Color must be within the range 0 - 16777215 (0xFFFFFF).',
+  [ErrorCodes.ColorConvert]: color => `Unable to convert "${color}" to a number.`,
+
+  [ErrorCodes.InviteOptionsMissingChannel]:
+    'A valid guild channel must be provided when GuildScheduledEvent is EXTERNAL.',
+
+  [ErrorCodes.InteractionCollectorError]: reason =>
+    `Collector received no interactions before ending with reason: ${reason}`,
+
+  [ErrorCodes.FileNotFound]: file => `File could not be found: ${file}`,
+
+  [ErrorCodes.UserNoDMChannel]: 'No DM Channel exists!',
+
+  [ErrorCodes.VoiceNotStageChannel]: 'You are only allowed to do this in stage channels.',
+
+  [ErrorCodes.VoiceStateNotOwn]:
+    'You cannot self-deafen/mute/request to speak on VoiceStates that do not belong to the ClientUser.',
+  [ErrorCodes.VoiceStateInvalidType]: name => `${name} must be a boolean.`,
+
+  [ErrorCodes.ReqResourceType]: 'The resource must be a string, Buffer or a valid file stream.',
+
+  [ErrorCodes.MessageBulkDeleteType]: 'The messages must be an Array, Collection, or number.',
+  [ErrorCodes.MessageContentType]: 'Message content must be a string.',
+  [ErrorCodes.MessageNonceRequired]: 'Message nonce is required when enforceNonce is true.',
+  [ErrorCodes.MessageNonceType]: 'Message nonce must be an integer or a string.',
+
+  [ErrorCodes.BanResolveId]: (ban = false) => `Couldn't resolve the user id to ${ban ? 'ban' : 'unban'}.`,
+  [ErrorCodes.FetchBanResolveId]: "Couldn't resolve the user id to fetch the ban.",
+
+  [ErrorCodes.PruneDaysType]: 'Days must be a number',
+
+  [ErrorCodes.GuildChannelResolve]: 'Could not resolve channel to a guild channel.',
+  [ErrorCodes.GuildVoiceChannelResolve]: 'Could not resolve channel to a guild voice channel.',
+  [ErrorCodes.GuildChannelOrphan]: 'Could not find a parent to this guild channel.',
+  [ErrorCodes.GuildChannelUnowned]: "The fetched channel does not belong to this manager's guild.",
+  [ErrorCodes.GuildMembersTimeout]: "Members didn't arrive in time.",
+  [ErrorCodes.GuildSoundboardSoundsTimeout]: "Soundboard sounds didn't arrive in time.",
+  [ErrorCodes.GuildUncachedMe]: 'The client user as a member of this guild is uncached.',
+  [ErrorCodes.ChannelNotCached]: 'Could not find the channel where this message came from in the cache!',
+  [ErrorCodes.StageChannelResolve]: 'Could not resolve channel to a stage channel.',
+  [ErrorCodes.GuildScheduledEventResolve]: 'Could not resolve the guild scheduled event.',
+  [ErrorCodes.FetchOwnerId]: type => `Couldn't resolve the ${type} ownerId to fetch the ${type} member.`,
+
+  [ErrorCodes.InvalidType]: (name, expected, an = false) => `Supplied ${name} is not a${an ? 'n' : ''} ${expected}.`,
+  [ErrorCodes.InvalidElement]: (type, name, elem) => `Supplied ${type} ${name} includes an invalid element: ${elem}`,
+
+  [ErrorCodes.MessageThreadParent]: 'The message was not sent in a guild text or announcement channel',
+  [ErrorCodes.MessageExistingThread]: 'The message already has a thread',
+  [ErrorCodes.ThreadInvitableType]: type => `Invitable cannot be edited on ${type}`,
+  [ErrorCodes.NotAThreadOfParent]: 'Provided ThreadChannelResolvable is not a thread of the parent channel.',
+
+  [ErrorCodes.WebhookMessage]: 'The message was not sent by a webhook.',
+  [ErrorCodes.WebhookTokenUnavailable]: 'This action requires a webhook token, but none is available.',
+  [ErrorCodes.WebhookApplication]: 'This message webhook belongs to an application and cannot be fetched.',
+
+  [ErrorCodes.MessageReferenceMissing]: 'The message does not reference another message',
+
+  [ErrorCodes.EmojiType]: 'Emoji must be a string or GuildEmoji/ReactionEmoji',
+  [ErrorCodes.EmojiManaged]: 'Emoji is managed and has no Author.',
+  [ErrorCodes.MissingGuildExpressionsPermission]: guild =>
+    `Client must have Create Guild Expressions or Manage Guild Expressions permission in guild ${guild} to see emoji authors.`,
+
+  [ErrorCodes.NotGuildSoundboardSound]: action =>
+    `Soundboard sound is a default (non-guild) soundboard sound and can't be ${action}.`,
+  [ErrorCodes.NotGuildSticker]: 'Sticker is a standard (non-guild) sticker and has no author.',
+
+  [ErrorCodes.ReactionResolveUser]: "Couldn't resolve the user id to remove from the reaction.",
+
+  [ErrorCodes.InviteResolveCode]: 'Could not resolve the code to fetch the invite.',
+  [ErrorCodes.InviteNotFound]: 'Could not find the requested invite.',
+
+  [ErrorCodes.DeleteGroupDMChannel]: "Bots don't have access to Group DM Channels and cannot delete them",
+  [ErrorCodes.FetchGroupDMChannel]: "Bots don't have access to Group DM Channels and cannot fetch them",
+
+  [ErrorCodes.MemberFetchNonceLength]: 'Nonce length must not exceed 32 characters.',
+
+  [ErrorCodes.GlobalCommandPermissions]:
+    'Permissions for global commands may only be fetched or modified by providing a GuildResolvable ' +
+    "or from a guild's application command manager.",
+  [ErrorCodes.GuildUncachedEntityResolve]: type =>
+    `Cannot resolve ${type} from an arbitrary guild, provide an id instead`,
+
+  [ErrorCodes.InteractionAlreadyReplied]: 'The reply to this interaction has already been sent or deferred.',
+  [ErrorCodes.InteractionNotReplied]: 'The reply to this interaction has not been sent or deferred.',
+
+  [ErrorCodes.CommandInteractionOptionNotFound]: name => `Required option "${name}" not found.`,
+  [ErrorCodes.CommandInteractionOptionType]: (name, type, expected) =>
+    `Option "${name}" is of type: ${type}; expected ${expected}.`,
+  [ErrorCodes.CommandInteractionOptionEmpty]: (name, type) =>
+    `Required option "${name}" is of type: ${type}; expected a non-empty value.`,
+  [ErrorCodes.CommandInteractionOptionNoSubcommand]: 'No subcommand specified for interaction.',
+  [ErrorCodes.CommandInteractionOptionNoSubcommandGroup]: 'No subcommand group specified for interaction.',
+  [ErrorCodes.CommandInteractionOptionInvalidChannelType]: (name, type, expected) =>
+    `The type of channel of the option "${name}" is: ${type}; expected ${expected}.`,
+  [ErrorCodes.AutocompleteInteractionOptionNoFocusedOption]: 'No focused option for autocomplete interaction.',
+
+  [ErrorCodes.ModalSubmitInteractionComponentNotFound]: customId =>
+    `Required component with custom id "${customId}" not found.`,
+  [ErrorCodes.ModalSubmitInteractionComponentType]: (customId, type, expected) =>
+    `Component with custom id "${customId}" is of type: ${type}; expected ${expected}.`,
+  [ErrorCodes.ModalSubmitInteractionComponentEmpty]: (customId, type) =>
+    `Required component with custom id "${customId}" is of type: ${type}; expected a non-empty value.`,
+  [ErrorCodes.ModalSubmitInteractionComponentInvalidChannelType]: (customId, type, expected) =>
+    `The type of channel of the component with custom id "${customId}" is: ${type}; expected ${expected}.`,
+
+  [ErrorCodes.InvalidMissingScopes]: 'At least one valid scope must be provided for the invite',
+  [ErrorCodes.InvalidScopesWithPermissions]: 'Permissions cannot be set without the bot scope.',
+
+  [ErrorCodes.NotImplemented]: (what, name) => `Method ${what} not implemented on ${name}.`,
+
+  [ErrorCodes.SweepFilterReturn]: 'The return value of the sweepFilter function was not false or a Function',
+
+  [ErrorCodes.GuildForumMessageRequired]: 'You must provide a message to create a guild forum thread',
+
+  [ErrorCodes.EntitlementCreateInvalidOwner]:
+    'You must provide either a guild or a user to create an entitlement, but not both',
+
+  [ErrorCodes.BulkBanUsersOptionEmpty]: 'Option "users" array or collection is empty',
+
+  [ErrorCodes.PollAlreadyExpired]: 'This poll has already expired.',
+
+  [ErrorCodes.PermissionOverwritesTypeMandatory]: '"overwrite.type" is mandatory if "overwrite.id" is a Snowflake',
+  [ErrorCodes.PermissionOverwritesTypeMismatch]: expected =>
+    `"overwrite.id" is a ${expected.toLowerCase()} object, ` +
+    `but "overwrite.type" is defined and not equal to OverwriteType.${expected}`,
+};

package/src/errors/index.ts

@@ -0,0 +1,6 @@
+
+export { DiscordjsError } from './DJSError.js';
+export { DiscordjsTypeError } from './DJSError.js';
+export { DiscordjsRangeError } from './DJSError.js';
+export { ErrorCodes } from './ErrorCodes.js';
+export { Messages } from './Messages.js';