@velliajs/discord 1.0.0

package/src/client/actions/GuildIntegrationsUpdate.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const Action = require('./Action');
+const Events = require('../../util/Events');
+
+class GuildIntegrationsUpdate extends Action {
+  handle(data) {
+    const client = this.client;
+    const guild = client.guilds.cache.get(data.guild_id);
+    /**
+     * Emitted whenever a guild integration is updated
+     * @event Client#guildIntegrationsUpdate
+     * @param {Guild} guild The guild whose integrations were updated
+     */
+    if (guild) client.emit(Events.GuildIntegrationsUpdate, guild);
+  }
+}
+
+module.exports = GuildIntegrationsUpdate;

package/src/client/actions/GuildMemberRemove.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const Action = require('./Action');
+const Events = require('../../util/Events');
+const Status = require('../../util/Status');
+
+class GuildMemberRemoveAction extends Action {
+  handle(data, shard) {
+    const client = this.client;
+    const guild = client.guilds.cache.get(data.guild_id);
+    let member = null;
+    if (guild) {
+      member = this.getMember({ user: data.user }, guild);
+      guild.memberCount--;
+      if (member) {
+        guild.members.cache.delete(member.id);
+        /**
+         * Emitted whenever a member leaves a guild, or is kicked.
+         * @event Client#guildMemberRemove
+         * @param {GuildMember} member The member that has left/been kicked from the guild
+         */
+        if (shard.status === Status.Ready) client.emit(Events.GuildMemberRemove, member);
+      }
+      guild.presences.cache.delete(data.user.id);
+      guild.voiceStates.cache.delete(data.user.id);
+    }
+    return { guild, member };
+  }
+}
+
+module.exports = GuildMemberRemoveAction;

package/src/client/actions/GuildMemberUpdate.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const Action = require('./Action');
+const Events = require('../../util/Events');
+const Status = require('../../util/Status');
+
+class GuildMemberUpdateAction extends Action {
+  handle(data, shard) {
+    const { client } = this;
+    if (data.user.username) {
+      const user = client.users.cache.get(data.user.id);
+      if (!user) {
+        client.users._add(data.user);
+      } else if (!user._equals(data.user)) {
+        client.actions.UserUpdate.handle(data.user);
+      }
+    }
+
+    const guild = client.guilds.cache.get(data.guild_id);
+    if (guild) {
+      const member = this.getMember({ user: data.user }, guild);
+      if (member) {
+        const old = member._update(data);
+        /**
+         * Emitted whenever a guild member changes - i.e. new role, removed role, nickname.
+         * @event Client#guildMemberUpdate
+         * @param {GuildMember} oldMember The member before the update
+         * @param {GuildMember} newMember The member after the update
+         */
+        if (shard.status === Status.Ready && !member.equals(old)) client.emit(Events.GuildMemberUpdate, old, member);
+      } else {
+        const newMember = guild.members._add(data);
+        /**
+         * Emitted whenever a member becomes available.
+         * @event Client#guildMemberAvailable
+         * @param {GuildMember} member The member that became available
+         */
+        this.client.emit(Events.GuildMemberAvailable, newMember);
+      }
+    }
+  }
+}
+
+module.exports = GuildMemberUpdateAction;

package/src/client/actions/GuildRoleCreate.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const Action = require('./Action');
+const Events = require('../../util/Events');
+
+class GuildRoleCreate extends Action {
+  handle(data) {
+    const client = this.client;
+    const guild = client.guilds.cache.get(data.guild_id);
+    let role;
+    if (guild) {
+      const already = guild.roles.cache.has(data.role.id);
+      role = guild.roles._add(data.role);
+      /**
+       * Emitted whenever a role is created.
+       * @event Client#roleCreate
+       * @param {Role} role The role that was created
+       */
+      if (!already) client.emit(Events.GuildRoleCreate, role);
+    }
+    return { role };
+  }
+}
+
+module.exports = GuildRoleCreate;

package/src/client/actions/GuildRoleDelete.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const Action = require('./Action');
+const Events = require('../../util/Events');
+
+class GuildRoleDeleteAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const guild = client.guilds.cache.get(data.guild_id);
+    let role;
+
+    if (guild) {
+      role = guild.roles.cache.get(data.role_id);
+      if (role) {
+        guild.roles.cache.delete(data.role_id);
+        /**
+         * Emitted whenever a guild role is deleted.
+         * @event Client#roleDelete
+         * @param {Role} role The role that was deleted
+         */
+        client.emit(Events.GuildRoleDelete, role);
+      }
+    }
+
+    return { role };
+  }
+}
+
+module.exports = GuildRoleDeleteAction;

package/src/client/actions/GuildRoleUpdate.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const Action = require('./Action');
+const Events = require('../../util/Events');
+
+class GuildRoleUpdateAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const guild = client.guilds.cache.get(data.guild_id);
+
+    if (guild) {
+      let old = null;
+
+      const role = guild.roles.cache.get(data.role.id);
+      if (role) {
+        old = role._update(data.role);
+        /**
+         * Emitted whenever a guild role is updated.
+         * @event Client#roleUpdate
+         * @param {Role} oldRole The role before the update
+         * @param {Role} newRole The role after the update
+         */
+        client.emit(Events.GuildRoleUpdate, old, role);
+      }
+
+      return {
+        old,
+        updated: role,
+      };
+    }
+
+    return {
+      old: null,
+      updated: null,
+    };
+  }
+}
+
+module.exports = GuildRoleUpdateAction;

package/src/client/actions/GuildRolesPositionUpdate.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const Action = require('./Action');
+
+class GuildRolesPositionUpdate extends Action {
+  handle(data) {
+    const client = this.client;
+
+    const guild = client.guilds.cache.get(data.guild_id);
+    if (guild) {
+      for (const partialRole of data.roles) {
+        const role = guild.roles.cache.get(partialRole.id);
+        if (role) role.rawPosition = partialRole.position;
+      }
+    }
+
+    return { guild };
+  }
+}
+
+module.exports = GuildRolesPositionUpdate;

package/src/client/actions/GuildScheduledEventCreate.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const Action = require('./Action');
+const Events = require('../../util/Events');
+
+class GuildScheduledEventCreateAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const guild = client.guilds.cache.get(data.guild_id);
+    if (guild) {
+      const guildScheduledEvent = guild.scheduledEvents._add(data);
+
+      /**
+       * Emitted whenever a guild scheduled event is created.
+       * @event Client#guildScheduledEventCreate
+       * @param {GuildScheduledEvent} guildScheduledEvent The created guild scheduled event
+       */
+      client.emit(Events.GuildScheduledEventCreate, guildScheduledEvent);
+
+      return { guildScheduledEvent };
+    }
+
+    return {};
+  }
+}
+
+module.exports = GuildScheduledEventCreateAction;

package/src/client/actions/GuildScheduledEventDelete.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const Action = require('./Action');
+const Events = require('../../util/Events');
+
+class GuildScheduledEventDeleteAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const guild = client.guilds.cache.get(data.guild_id);
+
+    if (guild) {
+      const guildScheduledEvent = this.getScheduledEvent(data, guild);
+      if (guildScheduledEvent) {
+        guild.scheduledEvents.cache.delete(guildScheduledEvent.id);
+
+        /**
+         * Emitted whenever a guild scheduled event is deleted.
+         * @event Client#guildScheduledEventDelete
+         * @param {GuildScheduledEvent} guildScheduledEvent The deleted guild scheduled event
+         */
+        client.emit(Events.GuildScheduledEventDelete, guildScheduledEvent);
+
+        return { guildScheduledEvent };
+      }
+    }
+
+    return {};
+  }
+}
+
+module.exports = GuildScheduledEventDeleteAction;

package/src/client/actions/GuildScheduledEventUpdate.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const Action = require('./Action');
+const Events = require('../../util/Events');
+
+class GuildScheduledEventUpdateAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const guild = client.guilds.cache.get(data.guild_id);
+
+    if (guild) {
+      const oldGuildScheduledEvent = guild.scheduledEvents.cache.get(data.id)?._clone() ?? null;
+      const newGuildScheduledEvent = guild.scheduledEvents._add(data);
+
+      /**
+       * Emitted whenever a guild scheduled event gets updated.
+       * @event Client#guildScheduledEventUpdate
+       * @param {?GuildScheduledEvent} oldGuildScheduledEvent The guild scheduled event object before the update
+       * @param {GuildScheduledEvent} newGuildScheduledEvent The guild scheduled event object after the update
+       */
+      client.emit(Events.GuildScheduledEventUpdate, oldGuildScheduledEvent, newGuildScheduledEvent);
+
+      return { oldGuildScheduledEvent, newGuildScheduledEvent };
+    }
+
+    return {};
+  }
+}
+
+module.exports = GuildScheduledEventUpdateAction;

package/src/client/actions/GuildScheduledEventUserAdd.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const Action = require('./Action');
+const Events = require('../../util/Events');
+
+class GuildScheduledEventUserAddAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const guild = client.guilds.cache.get(data.guild_id);
+
+    if (guild) {
+      const guildScheduledEvent = this.getScheduledEvent(data, guild);
+      const user = this.getUser(data);
+
+      if (guildScheduledEvent && user) {
+        /**
+         * Emitted whenever a user subscribes to a guild scheduled event
+         * @event Client#guildScheduledEventUserAdd
+         * @param {GuildScheduledEvent} guildScheduledEvent The guild scheduled event
+         * @param {User} user The user who subscribed
+         */
+        client.emit(Events.GuildScheduledEventUserAdd, guildScheduledEvent, user);
+
+        return { guildScheduledEvent, user };
+      }
+    }
+
+    return {};
+  }
+}
+
+module.exports = GuildScheduledEventUserAddAction;

package/src/client/actions/GuildScheduledEventUserRemove.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const Action = require('./Action');
+const Events = require('../../util/Events');
+
+class GuildScheduledEventUserRemoveAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const guild = client.guilds.cache.get(data.guild_id);
+
+    if (guild) {
+      const guildScheduledEvent = this.getScheduledEvent(data, guild);
+      const user = this.getUser(data);
+
+      if (guildScheduledEvent && user) {
+        /**
+         * Emitted whenever a user unsubscribes from a guild scheduled event
+         * @event Client#guildScheduledEventUserRemove
+         * @param {GuildScheduledEvent} guildScheduledEvent The guild scheduled event
+         * @param {User} user The user who unsubscribed
+         */
+        client.emit(Events.GuildScheduledEventUserRemove, guildScheduledEvent, user);
+
+        return { guildScheduledEvent, user };
+      }
+    }
+
+    return {};
+  }
+}
+
+module.exports = GuildScheduledEventUserRemoveAction;

package/src/client/actions/GuildStickerCreate.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const Action = require('./Action');
+const Events = require('../../util/Events');
+
+class GuildStickerCreateAction extends Action {
+  handle(guild, createdSticker) {
+    const already = guild.stickers.cache.has(createdSticker.id);
+    const sticker = guild.stickers._add(createdSticker);
+    /**
+     * Emitted whenever a custom sticker is created in a guild.
+     * @event Client#stickerCreate
+     * @param {Sticker} sticker The sticker that was created
+     */
+    if (!already) this.client.emit(Events.GuildStickerCreate, sticker);
+    return { sticker };
+  }
+}
+
+module.exports = GuildStickerCreateAction;

package/src/client/actions/GuildStickerDelete.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const Action = require('./Action');
+const Events = require('../../util/Events');
+
+class GuildStickerDeleteAction extends Action {
+  handle(sticker) {
+    sticker.guild.stickers.cache.delete(sticker.id);
+    /**
+     * Emitted whenever a custom sticker is deleted in a guild.
+     * @event Client#stickerDelete
+     * @param {Sticker} sticker The sticker that was deleted
+     */
+    this.client.emit(Events.GuildStickerDelete, sticker);
+    return { sticker };
+  }
+}
+
+module.exports = GuildStickerDeleteAction;

package/src/client/actions/GuildStickerUpdate.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const Action = require('./Action');
+const Events = require('../../util/Events');
+
+class GuildStickerUpdateAction extends Action {
+  handle(current, data) {
+    const old = current._update(data);
+    /**
+     * Emitted whenever a custom sticker is updated in a guild.
+     * @event Client#stickerUpdate
+     * @param {Sticker} oldSticker The old sticker
+     * @param {Sticker} newSticker The new sticker
+     */
+    this.client.emit(Events.GuildStickerUpdate, old, current);
+    return { sticker: current };
+  }
+}
+
+module.exports = GuildStickerUpdateAction;

package/src/client/actions/GuildStickersUpdate.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const Action = require('./Action');
+
+class GuildStickersUpdateAction extends Action {
+  handle(data) {
+    const guild = this.client.guilds.cache.get(data.guild_id);
+    if (!guild?.stickers) return;
+
+    const deletions = new Map(guild.stickers.cache);
+
+    for (const sticker of data.stickers) {
+      // Determine type of sticker event
+      const cachedSticker = guild.stickers.cache.get(sticker.id);
+      if (cachedSticker) {
+        deletions.delete(sticker.id);
+        if (!cachedSticker.equals(sticker)) {
+          // Sticker updated
+          this.client.actions.GuildStickerUpdate.handle(cachedSticker, sticker);
+        }
+      } else {
+        // Sticker added
+        this.client.actions.GuildStickerCreate.handle(guild, sticker);
+      }
+    }
+
+    for (const sticker of deletions.values()) {
+      // Sticker deleted
+      this.client.actions.GuildStickerDelete.handle(sticker);
+    }
+  }
+}
+
+module.exports = GuildStickersUpdateAction;

package/src/client/actions/GuildUpdate.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const Action = require('./Action');
+const Events = require('../../util/Events');
+
+class GuildUpdateAction extends Action {
+  handle(data) {
+    const client = this.client;
+
+    const guild = client.guilds.cache.get(data.id);
+    if (guild) {
+      const old = guild._update(data);
+      /**
+       * Emitted whenever a guild is updated - e.g. name change.
+       * @event Client#guildUpdate
+       * @param {Guild} oldGuild The guild before the update
+       * @param {Guild} newGuild The guild after the update
+       */
+      client.emit(Events.GuildUpdate, old, guild);
+      return {
+        old,
+        updated: guild,
+      };
+    }
+
+    return {
+      old: null,
+      updated: null,
+    };
+  }
+}
+
+module.exports = GuildUpdateAction;

package/src/client/actions/InteractionCreate.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const { InteractionType, ComponentType, ApplicationCommandType } = require('discord-api-types/v10');
+const Action = require('./Action');
+const AutocompleteInteraction = require('../../structures/AutocompleteInteraction');
+const ButtonInteraction = require('../../structures/ButtonInteraction');
+const ChannelSelectMenuInteraction = require('../../structures/ChannelSelectMenuInteraction');
+const ChatInputCommandInteraction = require('../../structures/ChatInputCommandInteraction');
+const MentionableSelectMenuInteraction = require('../../structures/MentionableSelectMenuInteraction');
+const MessageContextMenuCommandInteraction = require('../../structures/MessageContextMenuCommandInteraction');
+const ModalSubmitInteraction = require('../../structures/ModalSubmitInteraction');
+const RoleSelectMenuInteraction = require('../../structures/RoleSelectMenuInteraction');
+const StringSelectMenuInteraction = require('../../structures/StringSelectMenuInteraction');
+const UserContextMenuCommandInteraction = require('../../structures/UserContextMenuCommandInteraction');
+const UserSelectMenuInteraction = require('../../structures/UserSelectMenuInteraction');
+const Events = require('../../util/Events');
+
+class InteractionCreateAction extends Action {
+  handle(data) {
+    const client = this.client;
+
+    // Resolve and cache partial channels for Interaction#channel getter
+    const channel = data.channel && this.getChannel(data.channel);
+
+    // Do not emit this for interactions that cache messages that are non-text-based.
+    let InteractionClass;
+
+    switch (data.type) {
+      case InteractionType.ApplicationCommand:
+        switch (data.data.type) {
+          case ApplicationCommandType.ChatInput:
+            InteractionClass = ChatInputCommandInteraction;
+            break;
+          case ApplicationCommandType.User:
+            InteractionClass = UserContextMenuCommandInteraction;
+            break;
+          case ApplicationCommandType.Message:
+            if (channel && !channel.isTextBased()) return;
+            InteractionClass = MessageContextMenuCommandInteraction;
+            break;
+          default:
+            client.emit(
+              Events.Debug,
+              `[INTERACTION] Received application command interaction with unknown type: ${data.data.type}`,
+            );
+            return;
+        }
+        break;
+      case InteractionType.MessageComponent:
+        if (channel && !channel.isTextBased()) return;
+
+        switch (data.data.component_type) {
+          case ComponentType.Button:
+            InteractionClass = ButtonInteraction;
+            break;
+          case ComponentType.StringSelect:
+            InteractionClass = StringSelectMenuInteraction;
+            break;
+          case ComponentType.UserSelect:
+            InteractionClass = UserSelectMenuInteraction;
+            break;
+          case ComponentType.RoleSelect:
+            InteractionClass = RoleSelectMenuInteraction;
+            break;
+          case ComponentType.MentionableSelect:
+            InteractionClass = MentionableSelectMenuInteraction;
+            break;
+          case ComponentType.ChannelSelect:
+            InteractionClass = ChannelSelectMenuInteraction;
+            break;
+          default:
+            client.emit(
+              Events.Debug,
+              `[INTERACTION] Received component interaction with unknown type: ${data.data.component_type}`,
+            );
+            return;
+        }
+        break;
+      case InteractionType.ApplicationCommandAutocomplete:
+        InteractionClass = AutocompleteInteraction;
+        break;
+      case InteractionType.ModalSubmit:
+        InteractionClass = ModalSubmitInteraction;
+        break;
+      default:
+        client.emit(Events.Debug, `[INTERACTION] Received interaction with unknown type: ${data.type}`);
+        return;
+    }
+
+    const interaction = new InteractionClass(client, data);
+
+    /**
+     * Emitted when an interaction is created.
+     * @event Client#interactionCreate
+     * @param {BaseInteraction} interaction The interaction which was created
+     */
+    client.emit(Events.InteractionCreate, interaction);
+  }
+}
+
+module.exports = InteractionCreateAction;

package/src/client/actions/InviteCreate.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const Action = require('./Action');
+const Events = require('../../util/Events');
+
+class InviteCreateAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const channel = client.channels.cache.get(data.channel_id);
+    const guild = client.guilds.cache.get(data.guild_id);
+    if (!channel) return false;
+
+    const inviteData = Object.assign(data, { channel, guild });
+    const invite = guild.invites._add(inviteData);
+
+    /**
+     * Emitted when an invite is created.
+     * <info>This event requires either the {@link PermissionFlagsBits.ManageGuild} permission or the
+     * {@link PermissionFlagsBits.ManageChannels} permission for the channel.</info>
+     * @event Client#inviteCreate
+     * @param {Invite} invite The invite that was created
+     */
+    client.emit(Events.InviteCreate, invite);
+    return { invite };
+  }
+}
+
+module.exports = InviteCreateAction;

package/src/client/actions/InviteDelete.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const Action = require('./Action');
+const Invite = require('../../structures/Invite');
+const Events = require('../../util/Events');
+
+class InviteDeleteAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const channel = client.channels.cache.get(data.channel_id);
+    const guild = client.guilds.cache.get(data.guild_id);
+    if (!channel) return false;
+
+    const inviteData = Object.assign(data, { channel, guild });
+    const invite = new Invite(client, inviteData);
+    guild.invites.cache.delete(invite.code);
+
+    /**
+     * Emitted when an invite is deleted.
+     * <info>This event requires either the {@link PermissionFlagsBits.ManageGuild} permission or the
+     * {@link PermissionFlagsBits.ManageChannels} permission for the channel.</info>
+     * @event Client#inviteDelete
+     * @param {Invite} invite The invite that was deleted
+     */
+    client.emit(Events.InviteDelete, invite);
+    return { invite };
+  }
+}
+
+module.exports = InviteDeleteAction;