ValidReply — FiveCord

index.ts

Download

Source

src/plugins/validReply/index.ts

1/*

2 * FiveCord — a Discord client mod

4 * SPDX-License-Identifier: GPL-3.0-or-later

5 */

7import { Devs } from "@utils/constants";

8import definePlugin from "@utils/types";

9import { Channel, Message, User } from "@vencord/discord-types";

10import { findByCodeLazy } from "@webpack";

11import { FluxDispatcher, RestAPI } from "@webpack/common";

13const enum ReferencedMessageState {

14 Loaded,

15 NotLoaded,

16 Deleted

17}

19interface Reply {

20 baseAuthor: User,

21 baseMessage: Message;

22 channel: Channel;

23 referencedMessage: { state: ReferencedMessageState; };

24 compact: boolean;

25 isReplyAuthorBlocked: boolean;

26}

28const fetching = new Map<string, string>();

29let ReplyStore: any;

31const createMessageRecord = findByCodeLazy(".createFromServer(", ".isBlockedForMessage", "messageReference:");

33export default definePlugin({

34 name: "ValidReply",

35 description: 'Fixes "Message could not be loaded" upon hovering over the reply',

36 tags: ["Chat", "Utility"],

37 authors: [Devs.FiveCord],

38 patches: [

39 {

40 // Same find as in ReplyTimestamp

41 find: "#{intl::REPLY_QUOTE_MESSAGE_NOT_LOADED}",

42 replacement: {

43 match: /#{intl::REPLY_QUOTE_MESSAGE_NOT_LOADED}\)/,

44 replace: "$&,onMouseEnter:()=>$self.fetchReply(arguments[0])"

45 }

46 },

47 {

48 find: "ReferencedMessageStore",

49 replacement: [

50 {

51 match: /_channelCaches=new Map;/,

52 replace: "$&_=$self.setReplyStore(this);"

53 }

54 ]

55 }

56 ],

58 setReplyStore(store: any) {

59 ReplyStore = store;

60 },

62 async fetchReply(reply: Reply) {

63 const { channel_id: channelId, message_id: messageId } = reply.baseMessage.messageReference!;

65 if (fetching.has(messageId)) {

66 return;

67 }

68 fetching.set(messageId, channelId);

70 RestAPI.get({

71 url: `/channels/${channelId}/messages`,

72 query: {

73 limit: 1,

74 around: messageId

75 },

76 retries: 2

77 })

78 .then(res => {

79 const reply: Message | undefined = res?.body?.[0];

80 if (!reply) return;

82 if (reply.id !== messageId) {

83 ReplyStore.set(channelId, messageId, {

84 state: ReferencedMessageState.Deleted

85 });

87 FluxDispatcher.dispatch({

88 type: "MESSAGE_DELETE",

89 channelId: channelId,

90 message: messageId

91 });

92 } else {

93 ReplyStore.set(reply.channel_id, reply.id, {

94 state: ReferencedMessageState.Loaded,

95 message: createMessageRecord(reply)

96 });

98 FluxDispatcher.dispatch({

99 type: "MESSAGE_UPDATE",

100 message: reply

101 });

102 }

103 })

104 .catch(() => { })

105 .finally(() => {

106 fetching.delete(messageId);

107 });

108 }

109});

110

/*
 * FiveCord — a Discord client mod
 * Copyright (c) 2025 FiveCord
 * SPDX-License-Identifier: GPL-3.0-or-later
 */

import { Devs } from "@utils/constants";
import definePlugin from "@utils/types";
import { Channel, Message, User } from "@vencord/discord-types";
import { findByCodeLazy } from "@webpack";
import { FluxDispatcher, RestAPI } from "@webpack/common";

const enum ReferencedMessageState {
    Loaded,
    NotLoaded,
    Deleted
}

interface Reply {
    baseAuthor: User,
    baseMessage: Message;
    channel: Channel;
    referencedMessage: { state: ReferencedMessageState; };
    compact: boolean;
    isReplyAuthorBlocked: boolean;
}

const fetching = new Map<string, string>();
let ReplyStore: any;

const createMessageRecord = findByCodeLazy(".createFromServer(", ".isBlockedForMessage", "messageReference:");

export default definePlugin({
    name: "ValidReply",
    description: 'Fixes "Message could not be loaded" upon hovering over the reply',
    tags: ["Chat", "Utility"],
    authors: [Devs.FiveCord],
    patches: [
        {
            // Same find as in ReplyTimestamp
            find: "#{intl::REPLY_QUOTE_MESSAGE_NOT_LOADED}",
            replacement: {
                match: /#{intl::REPLY_QUOTE_MESSAGE_NOT_LOADED}\)/,
                replace: "$&,onMouseEnter:()=>$self.fetchReply(arguments[0])"
            }
        },
        {
            find: "ReferencedMessageStore",
            replacement: [
                {
                    match: /_channelCaches=new Map;/,
                    replace: "$&_=$self.setReplyStore(this);"
                }
            ]
        }
    ],

    setReplyStore(store: any) {
        ReplyStore = store;
    },

    async fetchReply(reply: Reply) {
        const { channel_id: channelId, message_id: messageId } = reply.baseMessage.messageReference!;

        if (fetching.has(messageId)) {
            return;
        }
        fetching.set(messageId, channelId);

        RestAPI.get({
            url: `/channels/${channelId}/messages`,
            query: {
                limit: 1,
                around: messageId
            },
            retries: 2
        })
            .then(res => {
                const reply: Message | undefined = res?.body?.[0];
                if (!reply) return;

                if (reply.id !== messageId) {
                    ReplyStore.set(channelId, messageId, {
                        state: ReferencedMessageState.Deleted
                    });

                    FluxDispatcher.dispatch({
                        type: "MESSAGE_DELETE",
                        channelId: channelId,
                        message: messageId
                    });
                } else {
                    ReplyStore.set(reply.channel_id, reply.id, {
                        state: ReferencedMessageState.Loaded,
                        message: createMessageRecord(reply)
                    });

                    FluxDispatcher.dispatch({
                        type: "MESSAGE_UPDATE",
                        message: reply
                    });
                }
            })
            .catch(() => { })
            .finally(() => {
                fetching.delete(messageId);
            });
    }
});

Source

FiveCord for Windows