@deffa5556/bail 1.0.6 → 1.0.7

package/cjs/lib/Discord/structures/Message.cjs

@@ -0,0 +1,553 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function (o, m, k, k2) {
+    if (k2 === undefined)
+        k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function () { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function (o, m, k, k2) {
+    if (k2 === undefined)
+        k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function (o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function (o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function (o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o)
+                if (Object.prototype.hasOwnProperty.call(o, k))
+                    ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule)
+            return mod;
+        var result = {};
+        if (mod != null)
+            for (var k = ownKeys(mod), i = 0; i < k.length; i++)
+                if (k[i] !== "default")
+                    __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** @module Message */
+const Base_1 = __importDefault(require("./Base"));
+const Attachment_1 = __importDefault(require("./Attachment"));
+const User_1 = __importDefault(require("./User"));
+const PartialApplication_1 = __importDefault(require("./PartialApplication"));
+const GuildChannel_1 = __importDefault(require("./GuildChannel"));
+const Poll_1 = __importDefault(require("./Poll"));
+const TypedCollection_1 = __importDefault(require("../util/TypedCollection"));
+const Constants_1 = require("../Constants");
+const Routes = __importStar(require("../util/Routes"));
+const Errors_1 = require("../util/Errors");
+/** Represents a message. */
+class Message extends Base_1.default {
+    constructor(data, client) {
+        super(data.id, client);
+        this.attachments = new TypedCollection_1.default(Attachment_1.default, client);
+        this.channelID = data.channel_id;
+        this.components = [];
+        this.content = data.content ?? "";
+        this.editedTimestamp = null;
+        this.embeds = [];
+        this.flags = 0;
+        this.guildID = (data.guild_id === undefined ? null : data.guild_id);
+        this.member = (data.member === undefined ? undefined : this.client.util.updateMember(data.guild_id, data.author.id, { ...data.member, user: data.author }));
+        this.mentions = {
+            channels: [],
+            everyone: false,
+            members: [],
+            roles: [],
+            users: []
+        };
+        this.pinned = !!data.pinned;
+        this.poll = data.poll ? new Poll_1.default(data.poll, client, this) : undefined;
+        this.reactions = [];
+        // message updates can be missing a timestamp
+        this.timestamp = data.timestamp === undefined ? Base_1.default.getCreatedAt(this.id) : new Date(data.timestamp);
+        this.tts = !!data.tts;
+        this.type = data.type;
+        this.webhookID = data.webhook_id;
+        this.update(data);
+        // don't add webhook users to the cache
+        this.author = data.webhook_id === undefined ? client.users.update(data.author) : new User_1.default(data.author, client);
+        if (data.application_id === undefined) {
+            this.applicationID = null;
+        }
+        else {
+            if (client["_application"] && client.application.id === data.application_id) {
+                if (data.application) {
+                    client.application["update"](data.application);
+                }
+                this.application = client.application;
+            }
+            else {
+                this.application = data.application ? new PartialApplication_1.default(data.application, client) : undefined;
+            }
+            this.applicationID = data.application_id;
+        }
+    }
+    update(data) {
+        if (data.mention_everyone !== undefined) {
+            this.mentions.everyone = data.mention_everyone;
+        }
+        if (data.mention_roles !== undefined) {
+            this.mentions.roles = data.mention_roles;
+        }
+        if (data.mentions !== undefined) {
+            const members = [];
+            this.mentions.users = data.mentions.map(user => {
+                if (this.channel && "guildID" in this.channel && user.member) {
+                    members.push(this.client.util.updateMember(this.channel.guildID, user.id, { ...user.member, user }));
+                }
+                return this.client.users.update(user);
+            });
+            this.mentions.members = members;
+        }
+        if (data.activity !== undefined) {
+            this.activity = data.activity;
+        }
+        if (data.attachments !== undefined) {
+            if (this.attachments.size !== 0) {
+                for (const id of this.attachments.keys()) {
+                    if (!data.attachments.some(attachment => attachment.id === id)) {
+                        this.attachments.delete(id);
+                    }
+                }
+            }
+            for (const attachment of data.attachments) {
+                this.attachments.update(attachment);
+            }
+        }
+        if (data.call !== undefined) {
+            this.call = {
+                endedTimestamp: data.call.ended_timestamp ? new Date(data.call.ended_timestamp) : null,
+                participants: data.call.participants
+            };
+        }
+        if (data.components !== undefined) {
+            this.components = this.client.util.componentsToParsed(data.components);
+        }
+        if (data.content !== undefined) {
+            this.content = data.content;
+            this.mentions.channels = (data.content.match(/<#\d{17,21}>/g) ?? []).map(mention => mention.slice(2, -1));
+        }
+        if (data.edited_timestamp !== undefined) {
+            this.editedTimestamp = data.edited_timestamp ? new Date(data.edited_timestamp) : null;
+        }
+        if (data.embeds !== undefined) {
+            this.embeds = this.client.util.embedsToParsed(data.embeds);
+            const pollResultEmbed = this.embeds.find(embed => embed.type === "poll_result");
+            if (pollResultEmbed) {
+                const questionText = pollResultEmbed.fields.find(field => field.name === "poll_question_text").value;
+                const totalVotes = pollResultEmbed.fields.find(field => field.name === "total_votes").value;
+                const victorAnswerID = pollResultEmbed.fields.find(field => field.name === "victor_answer_id")?.value;
+                const victorAnswerText = pollResultEmbed.fields.find(field => field.name === "victor_answer_text")?.value;
+                const victorAnswerVotes = pollResultEmbed.fields.find(field => field.name === "victor_answer_votes").value;
+                this.pollResults = {
+                    questionText,
+                    totalVotes: Number(totalVotes),
+                    victorAnswerID: victorAnswerID === undefined ? undefined : Number(victorAnswerID),
+                    victorAnswerText: victorAnswerText === undefined ? undefined : victorAnswerText,
+                    victorAnswerVotes: Number(victorAnswerVotes)
+                };
+            }
+        }
+        if (data.flags !== undefined) {
+            this.flags = data.flags;
+        }
+        if (data.interaction !== undefined) {
+            let member;
+            if (data.interaction.member) {
+                member = {
+                    ...data.interaction.member,
+                    user: data.interaction.user
+                };
+            }
+            this.interaction = {
+                id: data.interaction.id,
+                member: member ? this.client.util.updateMember(data.guild_id, member.user.id, member) : undefined,
+                name: data.interaction.name,
+                type: data.interaction.type,
+                user: this.client.users.update(data.interaction.user)
+            };
+        }
+        if (data.interaction_metadata !== undefined) {
+            this.interactionMetadata = {
+                authorizingIntegrationOwners: data.interaction_metadata.authorizing_integration_owners,
+                id: data.interaction_metadata.id,
+                interactedMessageID: data.interaction_metadata.interacted_message_id,
+                name: data.interaction_metadata.name,
+                originalResponseMessageID: data.interaction_metadata.original_response_message_id,
+                targetMessageID: data.interaction_metadata.target_message_id,
+                targetUser: data.interaction_metadata.target_user ? this.client.users.update(data.interaction_metadata.target_user) : undefined,
+                type: data.interaction_metadata.type,
+                user: this.client.users.update(data.interaction_metadata.user),
+                triggeringInteractionMetadata: data.interaction_metadata.triggering_interaction_metadata === undefined ? undefined : {
+                    authorizingIntegrationOwners: data.interaction_metadata.triggering_interaction_metadata.authorizing_integration_owners,
+                    id: data.interaction_metadata.triggering_interaction_metadata.id,
+                    interactedMessageID: data.interaction_metadata.triggering_interaction_metadata.interacted_message_id,
+                    originalResponseMessageID: data.interaction_metadata.triggering_interaction_metadata.original_response_message_id,
+                    targetMessageID: data.interaction_metadata.triggering_interaction_metadata.target_message_id,
+                    targetUser: data.interaction_metadata.triggering_interaction_metadata.target_user ? this.client.users.update(data.interaction_metadata.triggering_interaction_metadata.target_user) : undefined,
+                    type: data.interaction_metadata.triggering_interaction_metadata.type,
+                    user: this.client.users.update(data.interaction_metadata.triggering_interaction_metadata.user)
+                }
+            };
+        }
+        if (data.message_reference) {
+            this.messageReference = {
+                channelID: data.message_reference.channel_id,
+                failIfNotExists: data.message_reference.fail_if_not_exists,
+                guildID: data.message_reference.guild_id,
+                messageID: data.message_reference.message_id
+            };
+        }
+        if (data.message_snapshots) {
+            this.messageSnapshots = data.message_snapshots.map(s => ({
+                message: {
+                    attachments: s.message.attachments.map(a => new Attachment_1.default(a, this.client)),
+                    components: s.message.components ? this.client.util.componentsToParsed(s.message.components) : [],
+                    content: s.message.content,
+                    editedTimestamp: s.message.edited_timestamp ? new Date(s.message.edited_timestamp) : null,
+                    embeds: this.client.util.embedsToParsed(s.message.embeds),
+                    flags: s.message.flags ?? 0,
+                    mentions: {
+                        channels: (s.message.content.match(/<#\d{17,21}>/g) ?? []).map(mention => mention.slice(2, -1)),
+                        roles: s.message.mention_roles,
+                        users: s.message.mentions.map(u => this.client.users.update(u))
+                    },
+                    stickerItems: s.message.sticker_items ?? [],
+                    timestamp: new Date(s.message.timestamp),
+                    type: s.message.type
+                }
+            }));
+        }
+        if (data.nonce !== undefined) {
+            this.nonce = data.nonce;
+        }
+        if (data.pinned !== undefined) {
+            this.pinned = data.pinned;
+        }
+        if (data.position !== undefined) {
+            this.position = data.position;
+        }
+        if (data.reactions) {
+            this.reactions = data.reactions.map(r => ({
+                burstColors: r.burst_colors,
+                count: r.count,
+                countDetails: r.count_details,
+                emoji: r.emoji,
+                me: r.me,
+                meBurst: r.me_burst
+            }));
+        }
+        if (data.referenced_message !== undefined) {
+            if (data.referenced_message === null) {
+                this.referencedMessage = null;
+            }
+            else {
+                this.referencedMessage = this.channel ? this.channel.messages?.update(data.referenced_message) : new Message(data.referenced_message, this.client);
+            }
+        }
+        if (data.role_subscription_data !== undefined) {
+            this.roleSubscriptionData = {
+                isRenewal: data.role_subscription_data.is_renewal,
+                roleSubscriptionListingID: data.role_subscription_data.role_subscription_listing_id,
+                tierName: data.role_subscription_data.tier_name,
+                totalMonthsSubscribed: data.role_subscription_data.total_months_subscribed
+            };
+        }
+        if (data.sticker_items !== undefined) {
+            this.stickerItems = data.sticker_items;
+        }
+        if (data.thread !== undefined) {
+            this.thread = this.client.util.updateThread(data.thread);
+        }
+    }
+    /** The channel this message was created in. */
+    get channel() {
+        return this._cachedChannel ?? (this._cachedChannel = this.client.getChannel(this.channelID));
+    }
+    /** The guild this message is in. This will throw an error if the guild is not cached. */
+    get guild() {
+        if (this.guildID !== null && this._cachedGuild !== null) {
+            this._cachedGuild ?? (this._cachedGuild = this.client.guilds.get(this.guildID));
+            if (!this._cachedGuild) {
+                if (this.client.options.restMode) {
+                    throw new Errors_1.UncachedError(`${this.constructor.name}#guild is not present when rest mode is enabled.`);
+                }
+                if (!this.client.shards.connected) {
+                    throw new Errors_1.UncachedError(`${this.constructor.name}#guild is not present without a gateway connection.`);
+                }
+                throw new Errors_1.UncachedError(`${this.constructor.name}#guild is not present.`);
+            }
+            return this._cachedGuild;
+        }
+        return this._cachedGuild === null ? this._cachedGuild : (this._cachedGuild = null);
+    }
+    /** A link to this message. */
+    get jumpLink() {
+        return `${Constants_1.BASE_URL}${Routes.MESSAGE_LINK(this.guildID ?? "@me", this.channelID, this.id)}`;
+    }
+    /**
+     * Add a reaction to this message.
+     * @param emoji The reaction to add to the message. `name:id` for custom emojis, and the unicode codepoint for default emojis.
+     */
+    async createReaction(emoji) {
+        return this.client.rest.channels.createReaction(this.channelID, this.id, emoji);
+    }
+    /**
+     * Crosspost this message in an announcement channel.
+     */
+    async crosspost() {
+        return this.client.rest.channels.crosspostMessage(this.channelID, this.id);
+    }
+    /**
+     * Delete this message.
+     * @param reason The reason for deleting the message.
+     */
+    async delete(reason) {
+        return this.client.rest.channels.deleteMessage(this.channelID, this.id, reason);
+    }
+    /**
+     * Remove a reaction from this message.
+     * @param emoji The reaction to remove from the message. `name:id` for custom emojis, and the unicode codepoint for default emojis.
+     * @param user The user to remove the reaction from, `@me` for the current user (default).
+     */
+    async deleteReaction(emoji, user = "@me") {
+        return this.client.rest.channels.deleteReaction(this.channelID, this.id, emoji, user);
+    }
+    /**
+     * Remove all, or a specific emoji's reactions from this message.
+     * @param emoji The reaction to remove from the message. `name:id` for custom emojis, and the unicode codepoint for default emojis. Omit to remove all reactions.
+     */
+    async deleteReactions(emoji) {
+        return this.client.rest.channels.deleteReactions(this.channelID, this.id, emoji);
+    }
+    /**
+     * Delete this message as a webhook.
+     * @param token The token of the webhook.
+     * @param options Options for deleting the message.
+     */
+    async deleteWebhook(token, options) {
+        if (!this.webhookID) {
+            throw new TypeError("This message is not a webhook message.");
+        }
+        return this.client.rest.webhooks.deleteMessage(this.webhookID, token, this.id, options);
+    }
+    async edit(content, options) {
+        if (typeof content === "string") {
+            options = {
+                ...options,
+                content
+            };
+        }
+        else
+            options = content;
+        return this.client.rest.channels.editMessage(this.channelID, this.id, options);
+    }
+    async editWebhook(token, content, options) {
+        if (typeof content === "string") {
+            options = {
+                ...options,
+                content
+            };
+        }
+        else
+            options = content;
+        if (!this.webhookID) {
+            throw new TypeError("This message is not a webhook message.");
+        }
+        return this.client.rest.webhooks.editMessage(this.webhookID, token, this.id, options);
+    }
+    /** End the poll on this message now. */
+    async expire() {
+        if (this.poll === undefined) {
+            throw new TypeError("Message does not have a poll.");
+        }
+        await this.poll.expire();
+    }
+    async forward(channelID, content, options) {
+        if (typeof content === "string") {
+            options = {
+                ...options,
+                content
+            };
+        }
+        else
+            options = content;
+        return this.client.rest.channels.createMessage(channelID, {
+            ...options,
+            messageReference: {
+                channelID: this.channelID,
+                messageID: this.id,
+                type: Constants_1.MessageReferenceType.FORWARD
+            }
+        });
+    }
+    /**
+     * Get the users that voted on a poll answer.
+     * @param answerID The ID of the poll answer to get voters for.
+     * @param options The options for getting the voters.
+     */
+    async getPollAnswerUsers(answerID, options) {
+        if (this.poll === undefined) {
+            throw new TypeError("Message does not have a poll.");
+        }
+        return this.poll.getAnswerUsers(answerID, options);
+    }
+    /**
+     * Get the users who reacted with a specific emoji on this message.
+     * @param emoji The reaction to remove from the message. `name:id` for custom emojis, and the unicode codepoint for default emojis.
+     * @param options The options for getting the reactions.
+     */
+    async getReactions(emoji, options) {
+        return this.client.rest.channels.getReactions(this.channelID, this.id, emoji, options);
+    }
+    /** Whether this message belongs to a cached guild channel. The only difference on using this method over a simple if statement is to easily update all the message properties typing definitions based on the channel it belongs to. */
+    inCachedGuildChannel() {
+        return this.channel instanceof GuildChannel_1.default;
+    }
+    /** Whether this message belongs to a direct message channel (PrivateChannel or uncached). The only difference on using this method over a simple if statement is to easily update all the message properties typing definitions based on the channel it belongs to. */
+    inDirectMessageChannel() {
+        return this.guildID === null;
+    }
+    /**
+     * Pin this message.
+     * @param reason The reason for pinning the message.
+     */
+    async pin(reason) {
+        return this.client.rest.channels.pinMessage(this.channelID, this.id, reason);
+    }
+    async reply(content, options) {
+        if (typeof content === "string") {
+            options = {
+                ...options,
+                content
+            };
+        }
+        else
+            options = content;
+        return this.client.rest.channels.createMessage(this.channelID, {
+            ...options,
+            messageReference: {
+                messageID: this.id,
+                type: Constants_1.MessageReferenceType.DEFAULT
+            }
+        });
+    }
+    /**
+     * Create a thread from this message.
+     * @param options The options for creating the thread.
+     */
+    async startThread(options) {
+        return this.client.rest.channels.startThreadFromMessage(this.channelID, this.id, options);
+    }
+    toJSON() {
+        const im = this.interactionMetadata;
+        return {
+            ...super.toJSON(),
+            activity: this.activity,
+            applicationID: this.applicationID ?? undefined,
+            attachments: this.attachments.map(attachment => attachment.toJSON()),
+            author: this.author.toJSON(),
+            channelID: this.channelID,
+            components: this.components,
+            content: this.content,
+            editedTimestamp: this.editedTimestamp?.getTime() ?? null,
+            embeds: this.embeds,
+            flags: this.flags,
+            guildID: this.guildID ?? undefined,
+            interaction: this.interaction === undefined ? undefined : {
+                id: this.interaction.id,
+                member: this.interaction.member?.toJSON(),
+                name: this.interaction.name,
+                type: this.interaction.type,
+                user: this.interaction.user.toJSON()
+            },
+            interactionMetadata: im === undefined ? undefined : {
+                authorizingIntegrationOwners: im.authorizingIntegrationOwners,
+                id: im.id,
+                interactedMessageID: im.interactedMessageID,
+                name: im.name,
+                originalResponseMessageID: im.originalResponseMessageID,
+                targetMessageID: im.targetMessageID,
+                targetUser: im.targetUser instanceof User_1.default ? im.targetUser.toJSON() : im.targetUser,
+                type: im.type,
+                user: im.user instanceof User_1.default ? im.user.toJSON() : im.user,
+                triggeringInteractionMetadata: im.triggeringInteractionMetadata === undefined ? undefined : {
+                    authorizingIntegrationOwners: im.triggeringInteractionMetadata.authorizingIntegrationOwners,
+                    id: im.triggeringInteractionMetadata.id,
+                    interactedMessageID: im.triggeringInteractionMetadata.interactedMessageID,
+                    originalResponseMessageID: im.triggeringInteractionMetadata.originalResponseMessageID,
+                    targetMessageID: im.triggeringInteractionMetadata.targetMessageID,
+                    targetUser: im.triggeringInteractionMetadata.targetUser instanceof User_1.default ? im.triggeringInteractionMetadata.targetUser.toJSON() : im.triggeringInteractionMetadata.targetUser,
+                    type: im.triggeringInteractionMetadata.type,
+                    user: im.triggeringInteractionMetadata.user instanceof User_1.default ? im.triggeringInteractionMetadata.user.toJSON() : im.triggeringInteractionMetadata.user
+                }
+            },
+            mentionChannels: this.mentionChannels,
+            mentions: {
+                channels: this.mentions.channels,
+                everyone: this.mentions.everyone,
+                members: this.mentions.members.map(member => member.toJSON()),
+                roles: this.mentions.roles,
+                users: this.mentions.users.map(user => user.toJSON())
+            },
+            messageReference: this.messageReference,
+            messageSnapshots: this.messageSnapshots?.map(s => ({
+                message: {
+                    attachments: s.message.attachments.map(a => a.toJSON()),
+                    content: s.message.content,
+                    editedTimestamp: s.message.editedTimestamp?.getTime() ?? null,
+                    embeds: s.message.embeds,
+                    flags: s.message.flags,
+                    mentions: {
+                        channels: s.message.mentions.channels,
+                        roles: s.message.mentions.roles,
+                        users: s.message.mentions.users.map(u => u.toJSON())
+                    },
+                    timestamp: s.message.timestamp.getTime(),
+                    type: s.message.type
+                }
+            })),
+            nonce: this.nonce,
+            pinned: this.pinned,
+            position: this.position,
+            poll: this.poll?.toJSON(),
+            pollResults: this.pollResults,
+            reactions: this.reactions,
+            referencedMessage: this.referencedMessage?.toJSON(),
+            stickerItems: this.stickerItems,
+            thread: this.thread?.toJSON(),
+            timestamp: this.timestamp.getTime(),
+            tts: this.tts,
+            type: this.type,
+            webhook: this.webhookID
+        };
+    }
+    /**
+     * Unpin this message.
+     * @param reason The reason for unpinning the message.
+     */
+    async unpin(reason) {
+        return this.client.rest.channels.unpinMessage(this.channelID, this.id, reason);
+    }
+}
+exports.default = Message;