2023-04-25 20:06:08 +00:00
// @ts-check
2023-06-28 12:06:56 +00:00
const assert = require ( "assert" ) . strict
2023-04-25 20:06:08 +00:00
const markdown = require ( "discord-markdown" )
2023-07-13 05:36:20 +00:00
const pb = require ( "prettier-bytes" )
2023-07-11 04:51:30 +00:00
const DiscordTypes = require ( "discord-api-types/v10" )
2023-04-25 20:06:08 +00:00
2023-05-12 05:35:37 +00:00
const passthrough = require ( "../../passthrough" )
2023-09-14 00:32:27 +00:00
const { sync , db , discord , select , from } = passthrough
2023-05-12 05:35:37 +00:00
/** @type {import("../../matrix/file")} */
const file = sync . require ( "../../matrix/file" )
2023-10-07 07:58:46 +00:00
/** @type {import("./emoji-to-key")} */
const emojiToKey = sync . require ( "./emoji-to-key" )
2023-09-10 09:35:51 +00:00
/** @type {import("./lottie")} */
const lottie = sync . require ( "./lottie" )
2023-07-11 05:27:40 +00:00
const reg = require ( "../../matrix/read-registration" )
const userRegex = reg . namespaces . users . map ( u => new RegExp ( u . regex ) )
2023-05-12 05:35:37 +00:00
2023-10-13 13:15:21 +00:00
/ * *
* @ param { DiscordTypes . APIMessage } message
* @ param { DiscordTypes . APIGuild } guild
* @ param { boolean } useHTML
* /
function getDiscordParseCallbacks ( message , guild , useHTML ) {
2023-07-07 05:31:39 +00:00
return {
2023-08-16 05:03:05 +00:00
/** @param {{id: string, type: "discordUser"}} node */
2023-07-07 05:31:39 +00:00
user : node => {
2023-10-05 23:31:10 +00:00
const mxid = select ( "sim" , "mxid" , { user _id : node . id } ) . pluck ( ) . get ( )
2023-07-07 05:31:39 +00:00
const username = message . mentions . find ( ment => ment . id === node . id ) ? . username || node . id
if ( mxid && useHTML ) {
return ` <a href="https://matrix.to/#/ ${ mxid } ">@ ${ username } </a> `
} else {
return ` @ ${ username } : `
}
} ,
2023-08-16 05:03:05 +00:00
/** @param {{id: string, type: "discordChannel"}} node */
2023-07-07 05:31:39 +00:00
channel : node => {
2023-10-05 23:31:10 +00:00
const row = select ( "channel_room" , [ "room_id" , "name" , "nick" ] , { channel _id : node . id } ) . get ( )
2023-08-20 20:07:05 +00:00
if ( ! row ) {
return ` <# ${ node . id } > ` // fallback for when this channel is not bridged
} else if ( useHTML ) {
return ` <a href="https://matrix.to/#/ ${ row . room _id } "># ${ row . nick || row . name } </a> `
2023-07-07 05:31:39 +00:00
} else {
2023-08-20 20:07:05 +00:00
return ` # ${ row . nick || row . name } `
2023-07-07 05:31:39 +00:00
}
} ,
2023-08-16 05:03:05 +00:00
/** @param {{animated: boolean, name: string, id: string, type: "discordEmoji"}} node */
emoji : node => {
if ( useHTML ) {
2023-10-05 23:31:10 +00:00
const mxc = select ( "emoji" , "mxc_url" , { emoji _id : node . id } ) . pluck ( ) . get ( )
2023-09-19 05:43:57 +00:00
if ( mxc ) {
return ` <img data-mx-emoticon height="32" src=" ${ mxc } " title=": ${ node . name } :" alt=": ${ node . name } :"> `
2023-09-19 20:03:19 +00:00
} else { // We shouldn't get here since all emojis should have been added ahead of time in the messageToEvent function.
2023-09-19 05:43:57 +00:00
return ` <img src="mxc://cadence.moe/ ${ node . id } " data-mx-emoticon alt=": ${ node . name } :" title=": ${ node . name } :" height="24"> `
}
2023-08-16 05:03:05 +00:00
} else {
return ` : ${ node . name } : `
}
} ,
2023-10-13 13:15:21 +00:00
role : node => {
const role = guild . roles . find ( r => r . id === node . id )
if ( ! role ) {
return "@&" + node . id // fallback for if the cache breaks. if this happens, fix discord-packets.js to store the role info.
} else if ( useHTML && role . color ) {
return ` <font color="# ${ role . color . toString ( 16 ) } ">@ ${ role . name } </font> `
} else if ( useHTML ) {
return ` <span data-mx-color="#ffffff" data-mx-bg-color="#414eef">@ ${ role . name } </span> `
} else {
return ` @ ${ role . name } : `
}
} ,
2023-07-07 05:31:39 +00:00
everyone : node =>
"@room" ,
here : node =>
"@here"
}
}
2023-04-25 20:06:08 +00:00
/ * *
* @ param { import ( "discord-api-types/v10" ) . APIMessage } message
2023-06-28 12:06:56 +00:00
* @ param { import ( "discord-api-types/v10" ) . APIGuild } guild
2023-08-16 08:44:38 +00:00
* @ param { { includeReplyFallback ? : boolean , includeEditFallbackStar ? : boolean } } options default values :
* - includeReplyFallback : true
* - includeEditFallbackStar : false
* @ param { { api : import ( "../../matrix/api" ) } } di simple - as - nails dependency injection for the matrix API
2023-04-25 20:06:08 +00:00
* /
2023-08-16 08:44:38 +00:00
async function messageToEvent ( message , guild , options = { } , di ) {
2023-05-12 05:35:37 +00:00
const events = [ ]
2023-08-21 11:31:40 +00:00
if ( message . type === DiscordTypes . MessageType . ThreadCreated ) {
// This is the kind of message that appears when somebody makes a thread which isn't close enough to the message it's based off.
// It lacks the lines and the pill, so it looks kind of like a member join message, and it says:
// [#] NICKNAME started a thread: __THREAD NAME__. __See all threads__
// We're already bridging the THREAD_CREATED gateway event to make a comparable message, so drop this one.
return [ ]
}
if ( message . type === DiscordTypes . MessageType . ThreadStarterMessage ) {
// This is the message that appears at the top of a thread when the thread was based off an existing message.
// It's just a message reference, no content.
const ref = message . message _reference
assert ( ref )
assert ( ref . message _id )
2023-10-05 23:31:10 +00:00
const eventID = select ( "event_message" , "event_id" , { message _id : ref . message _id } ) . pluck ( ) . get ( )
const roomID = select ( "channel_room" , "room_id" , { channel _id : ref . channel _id } ) . pluck ( ) . get ( )
2023-08-28 05:32:55 +00:00
if ( ! eventID || ! roomID ) return [ ]
const event = await di . api . getEvent ( roomID , eventID )
2023-08-21 11:31:40 +00:00
return [ {
... event . content ,
$type : event . type
} ]
}
2023-07-11 04:51:30 +00:00
/ * *
@ type { { room ? : boolean , user _ids ? : string [ ] } }
We should consider the following scenarios for mentions :
2023-07-11 05:28:42 +00:00
1. A discord user rich - replies to a matrix user with a text post
2023-07-11 04:51:30 +00:00
+ The matrix user needs to be m . mentioned in the text event
+ The matrix user needs to have their name / mxid / link in the text event ( notification fallback )
- So prepend their ` @name: ` to the start of the plaintext body
2023-07-11 05:28:42 +00:00
2. A discord user rich - replies to a matrix user with an image event only
2023-07-11 04:51:30 +00:00
+ The matrix user needs to be m . mentioned in the image event
2023-07-11 05:28:42 +00:00
+ TODO The matrix user needs to have their name / mxid in the image event ' s body field , alongside the filename ( notification fallback )
2023-07-11 04:51:30 +00:00
- So append their name to the filename body , I guess ! ! !
2023-07-11 05:28:42 +00:00
3. A discord user ` @ ` s a matrix user in the text body of their text box
2023-07-11 04:51:30 +00:00
+ The matrix user needs to be m . mentioned in the text event
+ No change needed to the text event content : it already has their name
- So make sure we don ' t do anything in this case .
* /
const mentions = { }
2023-09-14 00:32:27 +00:00
let repliedToEventRow = null
2023-07-11 04:51:30 +00:00
let repliedToEventSenderMxid = null
function addMention ( mxid ) {
if ( ! mentions . user _ids ) mentions . user _ids = [ ]
2023-07-11 05:27:40 +00:00
if ( ! mentions . user _ids . includes ( mxid ) ) mentions . user _ids . push ( mxid )
2023-07-11 04:51:30 +00:00
}
// Mentions scenarios 1 and 2, part A. i.e. translate relevant message.mentions to m.mentions
// (Still need to do scenarios 1 and 2 part B, and scenario 3.)
if ( message . type === DiscordTypes . MessageType . Reply && message . message _reference ? . message _id ) {
2023-09-14 00:32:27 +00:00
const row = from ( "event_message" ) . join ( "message_channel" , "message_id" ) . join ( "channel_room" , "channel_id" ) . select ( "event_id" , "room_id" , "source" ) . and ( "WHERE message_id = ? AND part = 0" ) . get ( message . message _reference . message _id )
2023-07-11 04:51:30 +00:00
if ( row ) {
2023-09-14 00:32:27 +00:00
repliedToEventRow = row
2023-07-11 04:51:30 +00:00
}
}
2023-09-14 00:32:27 +00:00
if ( repliedToEventRow && repliedToEventRow . source === 0 ) { // reply was originally from Matrix
2023-07-11 04:51:30 +00:00
// Need to figure out who sent that event...
2023-09-14 00:32:27 +00:00
const event = await di . api . getEvent ( repliedToEventRow . room _id , repliedToEventRow . event _id )
2023-07-11 04:51:30 +00:00
repliedToEventSenderMxid = event . sender
// Need to add the sender to m.mentions
addMention ( repliedToEventSenderMxid )
}
2023-10-01 10:55:42 +00:00
async function addTextEvent ( content , msgtype , { scanMentions } ) {
2023-07-10 20:01:11 +00:00
content = content . replace ( /https:\/\/(?:ptb\.|canary\.|www\.)?discord(?:app)?\.com\/channels\/([0-9]+)\/([0-9]+)\/([0-9]+)/ , ( whole , guildID , channelID , messageID ) => {
2023-10-05 23:31:10 +00:00
const eventID = select ( "event_message" , "event_id" , { message _id : messageID } ) . pluck ( ) . get ( )
const roomID = select ( "channel_room" , "room_id" , { channel _id : channelID } ) . pluck ( ) . get ( )
2023-08-28 05:32:55 +00:00
if ( eventID && roomID ) {
return ` https://matrix.to/#/ ${ roomID } / ${ eventID } `
2023-07-10 20:01:11 +00:00
} else {
return ` ${ whole } [event not found] `
}
} )
2023-09-20 13:39:09 +00:00
// Handling emojis that we don't know about. The emoji has to be present in the DB for it to be picked up in the emoji markdown converter.
// So we scan the message ahead of time for all its emojis and ensure they are in the DB.
2023-09-27 10:24:31 +00:00
const emojiMatches = [ ... content . matchAll ( /<(a?):([^:>]{2,64}):([0-9]+)>/g ) ]
2023-10-07 07:58:46 +00:00
await Promise . all ( emojiMatches . map ( match => {
2023-09-20 13:39:09 +00:00
const id = match [ 3 ]
const name = match [ 2 ]
2023-10-07 07:58:46 +00:00
const animated = match [ 1 ]
return emojiToKey . emojiToKey ( { id , name , animated } ) // Register the custom emoji if needed
} ) )
2023-09-20 13:39:09 +00:00
2023-07-11 04:51:30 +00:00
let html = markdown . toHTML ( content , {
2023-10-13 13:15:21 +00:00
discordCallback : getDiscordParseCallbacks ( message , guild , true )
2023-07-01 13:41:31 +00:00
} , null , null )
2023-07-07 05:31:39 +00:00
2023-07-11 04:51:30 +00:00
let body = markdown . toHTML ( content , {
2023-10-13 13:15:21 +00:00
discordCallback : getDiscordParseCallbacks ( message , guild , false ) ,
2023-07-07 05:31:39 +00:00
discordOnly : true ,
escapeHTML : false ,
} , null , null )
2023-08-17 06:17:53 +00:00
// Mentions scenario 3: scan the message content for written @mentions of matrix users. Allows for up to one space between @ and mention.
2023-10-01 10:55:42 +00:00
if ( scanMentions ) {
const matches = [ ... content . matchAll ( /@ ?([a-z0-9._]+)\b/gi ) ]
if ( matches . length && matches . some ( m => m [ 1 ] . match ( /[a-z]/i ) ) ) {
const writtenMentionsText = matches . map ( m => m [ 1 ] . toLowerCase ( ) )
2023-10-05 23:31:10 +00:00
const roomID = select ( "channel_room" , "room_id" , { channel _id : message . channel _id } ) . pluck ( ) . get ( )
2023-10-01 10:55:42 +00:00
assert ( roomID )
const { joined } = await di . api . getJoinedMembers ( roomID )
for ( const [ mxid , member ] of Object . entries ( joined ) ) {
if ( ! userRegex . some ( rx => mxid . match ( rx ) ) ) {
const localpart = mxid . match ( /@([^:]*)/ )
assert ( localpart )
2023-10-04 10:23:57 +00:00
const displayName = member . display _name || localpart [ 1 ]
2023-10-01 10:55:42 +00:00
if ( writtenMentionsText . includes ( localpart [ 1 ] . toLowerCase ( ) ) || writtenMentionsText . includes ( displayName . toLowerCase ( ) ) ) addMention ( mxid )
}
2023-07-11 05:27:40 +00:00
}
}
}
2023-08-16 08:44:38 +00:00
// Star * prefix for fallback edits
if ( options . includeEditFallbackStar ) {
body = "* " + body
html = "* " + html
}
2023-10-09 22:29:27 +00:00
const flags = message . flags || 0
if ( flags & 2 ) {
body = ` [🔀 ${ message . author . username } ] \n ` + body
html = ` 🔀 <strong> ${ message . author . username } </strong><br> ` + html
}
2023-07-11 04:51:30 +00:00
// Fallback body/formatted_body for replies
2023-08-16 08:44:38 +00:00
// This branch is optional - do NOT change anything apart from the reply fallback, since it may not be run
2023-09-14 00:32:27 +00:00
if ( repliedToEventRow && options . includeReplyFallback !== false ) {
2023-07-11 04:51:30 +00:00
let repliedToDisplayName
let repliedToUserHtml
2023-09-14 00:32:27 +00:00
if ( repliedToEventRow ? . source === 0 && repliedToEventSenderMxid ) {
2023-07-11 04:51:30 +00:00
const match = repliedToEventSenderMxid . match ( /^@([^:]*)/ )
assert ( match )
repliedToDisplayName = match [ 1 ] || "a Matrix user" // grab the localpart as the display name, whatever
repliedToUserHtml = ` <a href="https://matrix.to/#/ ${ repliedToEventSenderMxid } "> ${ repliedToDisplayName } </a> `
} else {
repliedToDisplayName = message . referenced _message ? . author . global _name || message . referenced _message ? . author . username || "a Discord user"
repliedToUserHtml = repliedToDisplayName
}
2023-07-12 02:33:38 +00:00
let repliedToContent = message . referenced _message ? . content
2023-10-12 13:05:44 +00:00
if ( repliedToContent ? . startsWith ( "> <:L1:" ) ) {
// If the Discord user is replying to a Matrix user's reply, the fallback is going to contain the emojis and stuff from the bridged rep of the Matrix user's reply quote.
// Need to remove that previous reply rep from this fallback body. The fallbody body should only contain the Matrix user's actual message.
repliedToContent = repliedToContent . split ( "\n" ) . slice ( 2 ) . join ( "\n" )
}
2023-07-12 02:33:38 +00:00
if ( repliedToContent == "" ) repliedToContent = "[Media]"
else if ( ! repliedToContent ) repliedToContent = "[Replied-to message content wasn't provided by Discord]"
2023-07-11 04:51:30 +00:00
const repliedToHtml = markdown . toHTML ( repliedToContent , {
2023-10-13 13:15:21 +00:00
discordCallback : getDiscordParseCallbacks ( message , guild , true )
2023-07-11 04:51:30 +00:00
} , null , null )
const repliedToBody = markdown . toHTML ( repliedToContent , {
2023-10-13 13:15:21 +00:00
discordCallback : getDiscordParseCallbacks ( message , guild , false ) ,
2023-07-11 04:51:30 +00:00
discordOnly : true ,
escapeHTML : false ,
} , null , null )
2023-09-14 00:32:27 +00:00
html = ` <mx-reply><blockquote><a href="https://matrix.to/#/ ${ repliedToEventRow . room _id } / ${ repliedToEventRow . event _id } ">In reply to</a> ${ repliedToUserHtml } `
2023-07-11 04:51:30 +00:00
+ ` <br> ${ repliedToHtml } </blockquote></mx-reply> `
+ html
body = ( ` ${ repliedToDisplayName } : ` // scenario 1 part B for mentions
+ repliedToBody ) . split ( "\n" ) . map ( line => "> " + line ) . join ( "\n" )
+ "\n\n" + body
}
const newTextMessageEvent = {
$type : "m.room.message" ,
"m.mentions" : mentions ,
2023-08-19 10:54:23 +00:00
msgtype ,
2023-07-11 04:51:30 +00:00
body : body
}
2023-07-01 13:41:31 +00:00
const isPlaintext = body === html
2023-07-07 05:31:39 +00:00
2023-07-11 04:51:30 +00:00
if ( ! isPlaintext ) {
Object . assign ( newTextMessageEvent , {
2023-07-01 13:41:31 +00:00
format : "org.matrix.custom.html" ,
formatted _body : html
} )
2023-05-12 05:35:37 +00:00
}
2023-07-11 04:51:30 +00:00
events . push ( newTextMessageEvent )
2023-04-25 20:06:08 +00:00
}
2023-05-12 05:35:37 +00:00
2023-10-01 10:55:42 +00:00
let msgtype = "m.text"
// Handle message type 4, channel name changed
if ( message . type === DiscordTypes . MessageType . ChannelNameChange ) {
msgtype = "m.emote"
message . content = "changed the channel name to **" + message . content + "**"
}
// Text content appears first
if ( message . content ) {
await addTextEvent ( message . content , msgtype , { scanMentions : true } )
}
2023-05-12 05:35:37 +00:00
// Then attachments
const attachmentEvents = await Promise . all ( message . attachments . map ( async attachment => {
2023-07-13 05:36:20 +00:00
const emoji =
attachment . content _type ? . startsWith ( "image/jp" ) ? "📸"
: attachment . content _type ? . startsWith ( "image/" ) ? "🖼️"
: attachment . content _type ? . startsWith ( "video/" ) ? "🎞️"
: attachment . content _type ? . startsWith ( "text/" ) ? "📝"
: attachment . content _type ? . startsWith ( "audio/" ) ? "🎶"
: "📄"
2023-09-02 09:44:54 +00:00
// no native media spoilers in Element, so we'll post a link instead, forcing it to not preview using a blockquote
if ( attachment . filename . startsWith ( "SPOILER_" ) ) {
return {
$type : "m.room.message" ,
"m.mentions" : mentions ,
msgtype : "m.text" ,
body : ` ${ emoji } Uploaded SPOILER file: ${ attachment . url } ( ${ pb ( attachment . size ) } ) ` ,
format : "org.matrix.custom.html" ,
formatted _body : ` <blockquote> ${ emoji } Uploaded SPOILER file: <span data-mx-spoiler><a href=" ${ attachment . url } ">View</a></span> ( ${ pb ( attachment . size ) } )</blockquote> `
}
}
2023-07-13 05:36:20 +00:00
// for large files, always link them instead of uploading so I don't use up all the space in the content repo
2023-09-02 09:44:54 +00:00
else if ( attachment . size > reg . ooye . max _file _size ) {
2023-07-13 05:36:20 +00:00
return {
$type : "m.room.message" ,
"m.mentions" : mentions ,
msgtype : "m.text" ,
body : ` ${ emoji } Uploaded file: ${ attachment . url } ( ${ pb ( attachment . size ) } ) ` ,
format : "org.matrix.custom.html" ,
formatted _body : ` ${ emoji } Uploaded file: <a href=" ${ attachment . url } "> ${ attachment . filename } </a> ( ${ pb ( attachment . size ) } ) `
}
} else if ( attachment . content _type ? . startsWith ( "image/" ) && attachment . width && attachment . height ) {
2023-05-12 05:35:37 +00:00
return {
$type : "m.room.message" ,
2023-07-11 04:51:30 +00:00
"m.mentions" : mentions ,
2023-05-12 05:35:37 +00:00
msgtype : "m.image" ,
url : await file . uploadDiscordFileToMxc ( attachment . url ) ,
external _url : attachment . url ,
body : attachment . filename ,
2023-08-29 12:38:33 +00:00
filename : attachment . filename ,
2023-05-12 05:35:37 +00:00
info : {
mimetype : attachment . content _type ,
w : attachment . width ,
h : attachment . height ,
size : attachment . size
}
}
2023-08-19 10:54:23 +00:00
} else if ( attachment . content _type ? . startsWith ( "video/" ) && attachment . width && attachment . height ) {
return {
$type : "m.room.message" ,
"m.mentions" : mentions ,
msgtype : "m.video" ,
url : await file . uploadDiscordFileToMxc ( attachment . url ) ,
external _url : attachment . url ,
body : attachment . description || attachment . filename ,
filename : attachment . filename ,
info : {
mimetype : attachment . content _type ,
w : attachment . width ,
h : attachment . height ,
size : attachment . size
}
}
2023-08-29 05:08:00 +00:00
} else if ( attachment . content _type ? . startsWith ( "audio/" ) ) {
return {
$type : "m.room.message" ,
"m.mentions" : mentions ,
msgtype : "m.audio" ,
url : await file . uploadDiscordFileToMxc ( attachment . url ) ,
external _url : attachment . url ,
body : attachment . description || attachment . filename ,
filename : attachment . filename ,
info : {
mimetype : attachment . content _type ,
size : attachment . size ,
duration : attachment . duration _secs ? attachment . duration _secs * 1000 : undefined
}
}
2023-05-12 05:35:37 +00:00
} else {
return {
$type : "m.room.message" ,
2023-07-11 04:51:30 +00:00
"m.mentions" : mentions ,
2023-08-29 05:08:00 +00:00
msgtype : "m.file" ,
url : await file . uploadDiscordFileToMxc ( attachment . url ) ,
external _url : attachment . url ,
body : attachment . filename ,
2023-08-29 12:38:33 +00:00
filename : attachment . filename ,
2023-08-29 05:08:00 +00:00
info : {
mimetype : attachment . content _type ,
size : attachment . size
}
2023-05-12 05:35:37 +00:00
}
}
} ) )
events . push ( ... attachmentEvents )
2023-10-01 10:55:42 +00:00
// Then embeds
for ( const embed of message . embeds || [ ] ) {
if ( embed . type === "image" ) {
continue // Matrix already does a fine enough job of providing image embeds.
}
// Start building up a replica ("rep") of the embed in Discord-markdown format, which we will convert into both plaintext and formatted body at once
let repParagraphs = [ ]
const makeUrlTitle = ( text , url ) =>
( text && url ? ` [** ${ text } **]( ${ url } ) `
: text ? ` ** ${ text } ** `
: url ? ` ** ${ url } ** `
: "" )
let authorNameText = embed . author ? . name || ""
if ( authorNameText && embed . author ? . icon _url ) authorNameText = ` ⏺️ ${ authorNameText } ` // not using the real image
let authorTitle = makeUrlTitle ( authorNameText , embed . author ? . url )
if ( authorTitle ) repParagraphs . push ( authorTitle )
let title = makeUrlTitle ( embed . title , embed . url )
if ( title ) repParagraphs . push ( title )
2023-10-02 09:42:32 +00:00
if ( embed . image ? . url ) repParagraphs . push ( ` 📸 ${ embed . image . url } ` )
if ( embed . video ? . url ) repParagraphs . push ( ` 🎞️ ${ embed . video . url } ` )
2023-10-01 10:55:42 +00:00
if ( embed . description ) repParagraphs . push ( embed . description )
for ( const field of embed . fields || [ ] ) {
repParagraphs . push ( ` ** ${ field . name } ** \n ${ field . value } ` )
}
if ( embed . footer ? . text ) repParagraphs . push ( ` — ${ embed . footer . text } ` )
const repContent = repParagraphs . join ( "\n\n" )
2023-10-02 09:26:00 +00:00
const repContentQuoted = repContent . split ( "\n" ) . map ( l => "> " + l ) . join ( "\n" )
2023-10-01 10:55:42 +00:00
// Send as m.notice to apply the usual automated/subtle appearance, showing this wasn't actually typed by the person
2023-10-02 09:26:00 +00:00
await addTextEvent ( repContentQuoted , "m.notice" , { scanMentions : false } )
2023-10-01 10:55:42 +00:00
}
2023-05-12 05:35:37 +00:00
// Then stickers
2023-06-28 12:06:56 +00:00
if ( message . sticker _items ) {
const stickerEvents = await Promise . all ( message . sticker _items . map ( async stickerItem => {
const format = file . stickerFormat . get ( stickerItem . format _type )
2023-09-10 09:35:51 +00:00
if ( format ? . mime === "lottie" ) {
try {
2023-10-04 23:32:05 +00:00
const { mxc _url , info } = await lottie . convert ( stickerItem )
2023-09-10 09:35:51 +00:00
return {
$type : "m.sticker" ,
"m.mentions" : mentions ,
body : stickerItem . name ,
info ,
2023-10-04 23:32:05 +00:00
url : mxc _url
2023-09-10 09:35:51 +00:00
}
} catch ( e ) {
return {
$type : "m.room.message" ,
"m.mentions" : mentions ,
msgtype : "m.notice" ,
body : ` Failed to convert Lottie sticker: \n ${ e . toString ( ) } \n ${ e . stack } `
}
}
} else if ( format ? . mime ) {
2023-06-28 12:06:56 +00:00
let body = stickerItem . name
const sticker = guild . stickers . find ( sticker => sticker . id === stickerItem . id )
if ( sticker && sticker . description ) body += ` - ${ sticker . description } `
return {
$type : "m.sticker" ,
2023-07-11 04:51:30 +00:00
"m.mentions" : mentions ,
2023-06-28 12:06:56 +00:00
body ,
info : {
mimetype : format . mime
} ,
url : await file . uploadDiscordFileToMxc ( file . sticker ( stickerItem ) )
}
2023-09-10 09:35:51 +00:00
}
return {
$type : "m.room.message" ,
"m.mentions" : mentions ,
msgtype : "m.notice" ,
body : ` Unsupported sticker format ${ format ? . mime } . Name: ${ stickerItem . name } `
2023-06-28 12:06:56 +00:00
}
} ) )
events . push ( ... stickerEvents )
}
2023-05-12 05:35:37 +00:00
2023-07-11 04:51:30 +00:00
// Rich replies
2023-09-14 00:32:27 +00:00
if ( repliedToEventRow ) {
2023-07-11 04:51:30 +00:00
Object . assign ( events [ 0 ] , {
"m.relates_to" : {
"m.in_reply_to" : {
2023-09-14 00:32:27 +00:00
event _id : repliedToEventRow . event _id
2023-07-11 04:51:30 +00:00
}
}
} )
}
2023-05-12 05:35:37 +00:00
return events
2023-04-25 20:06:08 +00:00
}
2023-05-05 05:29:08 +00:00
2023-05-08 11:37:51 +00:00
module . exports . messageToEvent = messageToEvent