discord-sb.js 1.0.0

package/src/client/actions/MessageCreate.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const process = require('node:process');
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+let deprecationEmitted = false;
+
+class MessageCreateAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const channel = this.getChannel({
+      id: data.channel_id,
+      author: data.author,
+      ...('guild_id' in data && { guild_id: data.guild_id }),
+    });
+    if (channel) {
+      if (!channel.isText()) return {};
+
+      const existing = channel.messages.cache.get(data.id);
+      if (existing && existing.author?.id !== this.client.user.id) return { message: existing };
+      const message = existing ?? channel.messages._add(data);
+      channel.lastMessageId = data.id;
+
+      /**
+       * Emitted whenever a message is created.
+       * @event Client#messageCreate
+       * @param {Message} message The created message
+       */
+      client.emit(Events.MESSAGE_CREATE, message);
+
+      /**
+       * Emitted whenever a message is created.
+       * @event Client#message
+       * @param {Message} message The created message
+       * @deprecated Use {@link Client#event:messageCreate} instead
+       */
+      if (client.emit('message', message) && !deprecationEmitted) {
+        deprecationEmitted = true;
+        process.emitWarning('The message event is deprecated. Use messageCreate instead', 'DeprecationWarning');
+      }
+
+      return { message };
+    }
+
+    return {};
+  }
+}
+
+module.exports = MessageCreateAction;

package/src/client/actions/MessageDelete.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const Action = require('./Action');
+const { deletedMessages } = require('../../structures/Message');
+const { Events } = require('../../util/Constants');
+
+class MessageDeleteAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const channel = this.getChannel({ id: data.channel_id, ...('guild_id' in data && { guild_id: data.guild_id }) });
+    let message;
+    if (channel) {
+      if (!channel.isText()) return {};
+
+      message = this.getMessage(data, channel);
+      if (message) {
+        channel.messages.cache.delete(message.id);
+        deletedMessages.add(message);
+        /**
+         * Emitted whenever a message is deleted.
+         * @event Client#messageDelete
+         * @param {Message} message The deleted message
+         */
+        client.emit(Events.MESSAGE_DELETE, message);
+      }
+    }
+
+    return { message };
+  }
+}
+
+module.exports = MessageDeleteAction;

package/src/client/actions/MessageDeleteBulk.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const Action = require('./Action');
+const { deletedMessages } = require('../../structures/Message');
+const { Events } = require('../../util/Constants');
+
+class MessageDeleteBulkAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const channel = client.channels.cache.get(data.channel_id);
+
+    if (channel) {
+      if (!channel.isText()) return {};
+
+      const ids = data.ids;
+      const messages = new Collection();
+      for (const id of ids) {
+        const message = this.getMessage(
+          {
+            id,
+            guild_id: data.guild_id,
+          },
+          channel,
+          false,
+        );
+        if (message) {
+          deletedMessages.add(message);
+          messages.set(message.id, message);
+          channel.messages.cache.delete(id);
+        }
+      }
+
+      /**
+       * Emitted whenever messages are deleted in bulk.
+       * @event Client#messageDeleteBulk
+       * @param {Collection<Snowflake, Message>} messages The deleted messages, mapped by their id
+       */
+      if (messages.size > 0) client.emit(Events.MESSAGE_BULK_DELETE, messages);
+      return { messages };
+    }
+    return {};
+  }
+}
+
+module.exports = MessageDeleteBulkAction;

package/src/client/actions/MessagePollVoteAdd.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class MessagePollVoteAddAction extends Action {
+  handle(data) {
+    const channel = this.getChannel(data);
+    if (!channel?.isText()) return false;
+
+    const message = this.getMessage(data, channel);
+    if (!message) return false;
+
+    const { poll } = message;
+
+    const answer = poll?.answers.get(data.answer_id);
+    if (!answer) return false;
+
+    answer.voteCount++;
+
+    /**
+     * Emitted whenever a user votes in a poll.
+     * @event Client#messagePollVoteAdd
+     * @param {PollAnswer} pollAnswer The answer that was voted on
+     * @param {Snowflake} userId The id of the user that voted
+     */
+    this.client.emit(Events.MESSAGE_POLL_VOTE_ADD, answer, data.user_id);
+
+    return { poll };
+  }
+}
+
+module.exports = MessagePollVoteAddAction;

package/src/client/actions/MessagePollVoteRemove.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class MessagePollVoteRemoveAction extends Action {
+  handle(data) {
+    const channel = this.getChannel(data);
+    if (!channel?.isText()) return false;
+
+    const message = this.getMessage(data, channel);
+    if (!message) return false;
+
+    const { poll } = message;
+
+    const answer = poll?.answers.get(data.answer_id);
+    if (!answer) return false;
+
+    answer.voteCount--;
+
+    /**
+     * Emitted whenever a user removes their vote in a poll.
+     * @event Client#messagePollVoteRemove
+     * @param {PollAnswer} pollAnswer The answer where the vote was removed
+     * @param {Snowflake} userId The id of the user that removed their vote
+     */
+    this.client.emit(Events.MESSAGE_POLL_VOTE_REMOVE, answer, data.user_id);
+
+    return { poll };
+  }
+}
+
+module.exports = MessagePollVoteRemoveAction;

package/src/client/actions/MessageReactionAdd.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+const { PartialTypes } = require('../../util/Constants');
+
+/*
+{ user_id: 'id',
+     message_id: 'id',
+     emoji: { name: '�', id: null },
+     channel_id: 'id',
+     burst: boolean
+     // If originating from a guild
+     guild_id: 'id',
+     member: { ..., user: { ... } } }
+*/
+
+class MessageReactionAdd extends Action {
+  handle(data, fromStructure = false) {
+    if (!data.emoji) return false;
+
+    const user = this.getUserFromMember(data);
+    if (!user) return false;
+
+    // Verify channel
+    const channel = this.getChannel({
+      id: data.channel_id,
+      user_id: data.user_id,
+      ...('guild_id' in data && { guild_id: data.guild_id }),
+    });
+    if (!channel || !channel.isText()) return false;
+
+    // Verify message
+    const message = this.getMessage(data, channel);
+    if (!message) return false;
+
+    // Verify reaction
+    const includePartial = this.client.options.partials.includes(PartialTypes.REACTION);
+    if (message.partial && !includePartial) return false;
+    const reaction = message.reactions._add({
+      emoji: data.emoji,
+      count: message.partial ? null : 0,
+      me: user.id === this.client.user.id,
+      ...data,
+    });
+    if (!reaction) return false;
+    reaction._add(user, data.burst);
+    if (fromStructure) return { message, reaction, user };
+    /**
+     * Provides additional information about altered reaction
+     * @typedef {Object} MessageReactionEventDetails
+     * @property {ReactionType} type The type of the reaction
+     * @property {boolean} burst Determines whether a super reaction was used
+     */
+    /**
+     * Emitted whenever a reaction is added to a cached message.
+     * @event Client#messageReactionAdd
+     * @param {MessageReaction} messageReaction The reaction object
+     * @param {User} user The user that applied the guild or reaction emoji
+     * @param {MessageReactionEventDetails} details Details of adding the reaction
+     */
+    this.client.emit(Events.MESSAGE_REACTION_ADD, reaction, user, { type: data.type, burst: data.burst });
+
+    return { message, reaction, user };
+  }
+}
+
+module.exports = MessageReactionAdd;

package/src/client/actions/MessageReactionRemove.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+/*
+{ user_id: 'id',
+     message_id: 'id',
+     emoji: { name: '�', id: null },
+     channel_id: 'id',
+     guild_id: 'id' }
+*/
+
+class MessageReactionRemove extends Action {
+  handle(data) {
+    if (!data.emoji) return false;
+
+    const user = this.getUser(data);
+    if (!user) return false;
+
+    // Verify channel
+    const channel = this.getChannel({
+      id: data.channel_id,
+      user_id: data.user_id,
+      ...('guild_id' in data && { guild_id: data.guild_id }),
+    });
+    if (!channel || !channel.isText()) return false;
+
+    // Verify message
+    const message = this.getMessage(data, channel);
+    if (!message) return false;
+
+    // Verify reaction
+    const reaction = this.getReaction(data, message, user);
+    if (!reaction) return false;
+    reaction._remove(user, data.burst);
+    /**
+     * Emitted whenever a reaction is removed from a cached message.
+     * @event Client#messageReactionRemove
+     * @param {MessageReaction} messageReaction The reaction object
+     * @param {User} user The user whose emoji or reaction emoji was removed
+     * @param {MessageReactionEventDetails} details Details of removing the reaction
+     */
+    this.client.emit(Events.MESSAGE_REACTION_REMOVE, reaction, user, { type: data.type, burst: data.burst });
+
+    return { message, reaction, user };
+  }
+}
+
+module.exports = MessageReactionRemove;

package/src/client/actions/MessageReactionRemoveAll.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class MessageReactionRemoveAll extends Action {
+  handle(data) {
+    // Verify channel
+    const channel = this.getChannel({ id: data.channel_id, ...('guild_id' in data && { guild_id: data.guild_id }) });
+    if (!channel || !channel.isText()) return false;
+
+    // Verify message
+    const message = this.getMessage(data, channel);
+    if (!message) return false;
+
+    // Copy removed reactions to emit for the event.
+    const removed = message.reactions.cache.clone();
+
+    message.reactions.cache.clear();
+    this.client.emit(Events.MESSAGE_REACTION_REMOVE_ALL, message, removed);
+
+    return { message };
+  }
+}
+
+/**
+ * Emitted whenever all reactions are removed from a cached message.
+ * @event Client#messageReactionRemoveAll
+ * @param {Message} message The message the reactions were removed from
+ * @param {Collection<string|Snowflake, MessageReaction>} reactions The cached message reactions that were removed.
+ */
+
+module.exports = MessageReactionRemoveAll;

package/src/client/actions/MessageReactionRemoveEmoji.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class MessageReactionRemoveEmoji extends Action {
+  handle(data) {
+    const channel = this.getChannel({ id: data.channel_id, ...('guild_id' in data && { guild_id: data.guild_id }) });
+    if (!channel || !channel.isText()) return false;
+
+    const message = this.getMessage(data, channel);
+    if (!message) return false;
+
+    const reaction = this.getReaction(data, message);
+    if (!reaction) return false;
+    if (!message.partial) message.reactions.cache.delete(reaction.emoji.id ?? reaction.emoji.name);
+
+    /**
+     * Emitted when a bot removes an emoji reaction from a cached message.
+     * @event Client#messageReactionRemoveEmoji
+     * @param {MessageReaction} reaction The reaction that was removed
+     */
+    this.client.emit(Events.MESSAGE_REACTION_REMOVE_EMOJI, reaction);
+    return { reaction };
+  }
+}
+
+module.exports = MessageReactionRemoveEmoji;

package/src/client/actions/MessageUpdate.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const Action = require('./Action');
+
+class MessageUpdateAction extends Action {
+  handle(data) {
+    const channel = this.getChannel({ id: data.channel_id, ...('guild_id' in data && { guild_id: data.guild_id }) });
+    if (channel) {
+      if (!channel.isText()) return {};
+
+      const { id, channel_id, guild_id, author, timestamp, type } = data;
+      const message = this.getMessage({ id, channel_id, guild_id, author, timestamp, type }, channel);
+      if (message) {
+        const old = message._update(data);
+        return {
+          old,
+          updated: message,
+        };
+      }
+    }
+
+    return {};
+  }
+}
+
+module.exports = MessageUpdateAction;

package/src/client/actions/PresenceUpdate.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+const { PartialTypes } = require('../../util/Constants');
+
+class PresenceUpdateAction extends Action {
+  handle(data) {
+    let user = this.client.users.cache.get(data.user.id);
+    if (!user && data.user?.username) user = this.client.users._add(data.user);
+    if (!user && ('username' in data.user || this.client.options.partials.includes(PartialTypes.USER))) {
+      user = this.client.users._add(data.user);
+    }
+    if (!user) return;
+
+    if (data.user?.username) {
+      if (!user._equals(data.user)) this.client.actions.UserUpdate.handle(data.user);
+    }
+
+    const guild = this.client.guilds.cache.get(data.guild_id);
+
+    if (guild) {
+      let member = guild.members.cache.get(user.id);
+      if (!member && data.status !== 'offline') {
+        member = guild.members._add({
+          user,
+          deaf: false,
+          mute: false,
+        });
+        this.client.emit(Events.GUILD_MEMBER_AVAILABLE, member);
+      }
+    }
+
+    const oldPresence = (guild || this.client).presences.cache.get(user.id)?._clone() ?? null;
+
+    const newPresence = (guild || this.client).presences._add(Object.assign(data, { guild }));
+
+    if (this.client.listenerCount(Events.PRESENCE_UPDATE) && !newPresence.equals(oldPresence)) {
+      /**
+       * Emitted whenever a guild member's presence (e.g. status, activity) is changed.
+       * @event Client#presenceUpdate
+       * @param {?Presence} oldPresence The presence before the update, if one at all
+       * @param {Presence} newPresence The presence after the update
+       */
+      this.client.emit(Events.PRESENCE_UPDATE, oldPresence, newPresence);
+    }
+  }
+}
+
+module.exports = PresenceUpdateAction;

package/src/client/actions/StageInstanceCreate.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class StageInstanceCreateAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const channel = this.getChannel({ id: data.channel_id, guild_id: data.guild_id });
+
+    if (channel) {
+      const stageInstance = channel.guild.stageInstances._add(data);
+
+      /**
+       * Emitted whenever a stage instance is created.
+       * @event Client#stageInstanceCreate
+       * @param {StageInstance} stageInstance The created stage instance
+       */
+      client.emit(Events.STAGE_INSTANCE_CREATE, stageInstance);
+
+      return { stageInstance };
+    }
+
+    return {};
+  }
+}
+
+module.exports = StageInstanceCreateAction;

package/src/client/actions/StageInstanceDelete.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const Action = require('./Action');
+const { deletedStageInstances } = require('../../structures/StageInstance');
+const { Events } = require('../../util/Constants');
+
+class StageInstanceDeleteAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const channel = this.getChannel({ id: data.channel_id, guild_id: data.guild_id });
+
+    if (channel) {
+      const stageInstance = channel.guild.stageInstances._add(data);
+      if (stageInstance) {
+        channel.guild.stageInstances.cache.delete(stageInstance.id);
+        deletedStageInstances.add(stageInstance);
+
+        /**
+         * Emitted whenever a stage instance is deleted.
+         * @event Client#stageInstanceDelete
+         * @param {StageInstance} stageInstance The deleted stage instance
+         */
+        client.emit(Events.STAGE_INSTANCE_DELETE, stageInstance);
+
+        return { stageInstance };
+      }
+    }
+
+    return {};
+  }
+}
+
+module.exports = StageInstanceDeleteAction;

package/src/client/actions/StageInstanceUpdate.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class StageInstanceUpdateAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const channel = this.getChannel({ id: data.channel_id, guild_id: data.guild_id });
+
+    if (channel) {
+      const oldStageInstance = channel.guild.stageInstances.cache.get(data.id)?._clone() ?? null;
+      const newStageInstance = channel.guild.stageInstances._add(data);
+
+      /**
+       * Emitted whenever a stage instance gets updated - e.g. change in topic or privacy level
+       * @event Client#stageInstanceUpdate
+       * @param {?StageInstance} oldStageInstance The stage instance before the update
+       * @param {StageInstance} newStageInstance The stage instance after the update
+       */
+      client.emit(Events.STAGE_INSTANCE_UPDATE, oldStageInstance, newStageInstance);
+
+      return { oldStageInstance, newStageInstance };
+    }
+
+    return {};
+  }
+}
+
+module.exports = StageInstanceUpdateAction;

package/src/client/actions/ThreadCreate.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class ThreadCreateAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const existing = client.channels.cache.has(data.id);
+    const thread = client.channels._add(data);
+    if (!existing && thread) {
+      /**
+       * Emitted whenever a thread is created or when the client user is added to a thread.
+       * @event Client#threadCreate
+       * @param {ThreadChannel} thread The thread that was created
+       * @param {boolean} newlyCreated Whether the thread was newly created
+       */
+      client.emit(Events.THREAD_CREATE, thread, data.newly_created ?? false);
+    }
+    return { thread };
+  }
+}
+
+module.exports = ThreadCreateAction;

package/src/client/actions/ThreadDelete.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const Action = require('./Action');
+const { deletedChannels } = require('../../structures/Channel');
+const { deletedMessages } = require('../../structures/Message');
+const { Events } = require('../../util/Constants');
+
+class ThreadDeleteAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const thread = client.channels.cache.get(data.id);
+
+    if (thread) {
+      client.channels._remove(thread.id);
+      deletedChannels.add(thread);
+      for (const message of thread.messages.cache.values()) {
+        deletedMessages.add(message);
+      }
+
+      /**
+       * Emitted whenever a thread is deleted.
+       * @event Client#threadDelete
+       * @param {ThreadChannel} thread The thread that was deleted
+       */
+      client.emit(Events.THREAD_DELETE, thread);
+    }
+
+    return { thread };
+  }
+}
+
+module.exports = ThreadDeleteAction;

package/src/client/actions/ThreadListSync.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class ThreadListSyncAction extends Action {
+  handle(data) {
+    const client = this.client;
+
+    const guild = client.guilds.cache.get(data.guild_id);
+    if (!guild) return {};
+
+    if (data.channel_ids) {
+      for (const id of data.channel_ids) {
+        const channel = client.channels.cache.get(id);
+        if (channel) this.removeStale(channel);
+      }
+    } else {
+      for (const channel of guild.channels.cache.values()) {
+        this.removeStale(channel);
+      }
+    }
+
+    const syncedThreads = data.threads.reduce((coll, rawThread) => {
+      const thread = client.channels._add(rawThread);
+      return coll.set(thread.id, thread);
+    }, new Collection());
+
+    for (const rawMember of Object.values(data.members || {})) {
+      // Discord sends the thread id as id in this object
+      const thread = client.channels.cache.get(rawMember.id);
+      if (thread) {
+        thread.members._add(rawMember);
+      }
+    }
+
+    /**
+     * Emitted whenever the client user gains access to a text or news channel that contains threads
+     * @event Client#threadListSync
+     * @param {Collection<Snowflake, ThreadChannel>} threads The threads that were synced
+     */
+    client.emit(Events.THREAD_LIST_SYNC, syncedThreads);
+
+    return {
+      syncedThreads,
+    };
+  }
+
+  removeStale(channel) {
+    channel.threads?.cache.forEach(thread => {
+      if (!thread.archived) {
+        this.client.channels._remove(thread.id);
+      }
+    });
+  }
+}
+
+module.exports = ThreadListSyncAction;