@towns-protocol/sdk 0.0.241 → 0.0.244

package/dist/{sync-agent/timeline/models/timelineEvent.js → streams-view/timelineEvents.js}

@@ -1,15 +1,15 @@
-import { bin_toHexString } from '@towns-protocol/dlog';
-import { MembershipOp, ChannelMessage_Post_AttachmentSchema, ChannelMessage_PostSchema, } from '@towns-protocol/proto';
-import { isDefined, logNever, checkNever } from '../../../check';
-import { EventStatus, MessageType, Membership, RiverTimelineEvent, } from './timeline-types';
-import { userIdFromAddress, streamIdFromBytes, streamIdAsString } from '../../../id';
-import { isLocalEvent, isRemoteEvent, isCiphertext, } from '../../../types';
+import { MembershipOp, } from '@towns-protocol/proto';
+import { EventStatus, RiverTimelineEvent, MessageType, Membership, } from '../sync-agent/timeline/models/timeline-types';
+import { checkNever, isDefined, logNever } from '../check';
+import { isLocalEvent, isRemoteEvent, } from '../types';
+import { streamIdAsString, streamIdFromBytes, userIdFromAddress } from '../id';
+import { getIsMentioned, getReactionParentId, getReplyParentId, getThreadParentId, } from './timelinesViewModel';
+import { bin_toHexString, dlogger } from '@towns-protocol/dlog';
 import { getSpaceReviewEventDataBin } from '@towns-protocol/web3';
-import { create } from '@bufbuild/protobuf';
-export function toEventSA(timelineEvent, userId) {
+const logger = dlogger('csb:timeline');
+export function toEvent(timelineEvent, userId) {
     const eventId = timelineEvent.hashStr;
-    const senderId = timelineEvent.creatorUserId;
-    // TODO: get sender metadata from store
+    const senderId = getSenderId(timelineEvent);
     const sender = {
         id: senderId,
     };
@@ -23,7 +23,9 @@ export function toEventSA(timelineEvent, userId) {
             payload.value.content.case !== 'message') {
             return undefined;
         }
-        return payload.value.content.value.sessionId;
+        return payload.value.content.value.sessionIdBytes.length > 0
+            ? bin_toHexString(payload.value.content.value.sessionIdBytes)
+            : payload.value.content.value.sessionId;
     }
     const sessionId = extractSessionId(timelineEvent);
     return {
@@ -51,6 +53,14 @@ export function toEventSA(timelineEvent, userId) {
         sessionId,
     };
 }
+function getSenderId(timelineEvent) {
+    const payload = timelineEvent.remoteEvent?.event.payload;
+    if (payload?.case === 'memberPayload' &&
+        payload?.value.content.case === 'memberBlockchainTransaction') {
+        return userIdFromAddress(payload.value.content.value.fromUserAddress);
+    }
+    return timelineEvent.creatorUserId;
+}
 function toTownsContent(timelineEvent) {
     if (isLocalEvent(timelineEvent)) {
         return toTownsContent_FromChannelMessage(timelineEvent.localEvent.channelMessage, 'local event', timelineEvent.hashStr);
@@ -101,15 +111,15 @@ function toTownsContent_fromParsedEvent(eventId, timelineEvent) {
             return toTownsContent_SpacePayload(eventId, message, message.event.payload.value, description);
         case 'userMetadataPayload':
             return {
-                error: `${description} userMetadataPayload not supported?`,
+                error: `${description} userMetadataPayload not implemented`,
             };
         case 'userSettingsPayload':
             return {
-                error: `${description} userSettingsPayload not supported?`,
+                error: `${description} userSettingsPayload not implemented`,
             };
         case 'userInboxPayload':
             return {
-                error: `${description} userInboxPayload not supported?`,
+                error: `${description} userInboxPayload not implemented`,
             };
         case 'miniblockHeader':
             return toTownsContent_MiniblockHeader(eventId, message, message.event.payload.value, description);
@@ -119,6 +129,10 @@ function toTownsContent_fromParsedEvent(eventId, timelineEvent) {
             };
         case 'memberPayload':
             return toTownsContent_MemberPayload(timelineEvent, message, message.event.payload.value, description);
+        case 'metadataPayload':
+            return {
+                error: `${description} metadataPayload not supported for timeline events`,
+            };
         case undefined:
             return { error: `Undefined payload case: ${description}` };
         default:
@@ -219,24 +233,17 @@ function toTownsContent_MemberPayload(event, message, value, description) {
                     unpinnedEventId: bin_toHexString(value.content.value.eventId),
                 },
             };
-        case 'encryptionAlgorithm':
-            return {
-                content: {
-                    kind: RiverTimelineEvent.StreamEncryptionAlgorithm,
-                    algorithm: value.content.value.algorithm,
-                },
-            };
         case 'memberBlockchainTransaction': {
             const fromUserAddress = value.content.value.fromUserAddress;
             const transaction = value.content.value.transaction;
             if (!transaction) {
                 return { error: `${description} no transaction` };
             }
-            if (!transaction.receipt?.transactionHash) {
-                return { error: `${description} no transactionHash` };
-            }
             switch (transaction.content.case) {
                 case 'tip': {
+                    if (!transaction.receipt?.transactionHash) {
+                        return { error: `${description} no transactionHash` };
+                    }
                     const tipContent = transaction.content.value;
                     if (!tipContent.event) {
                         return { error: `${description} no event in tip` };
@@ -253,17 +260,6 @@ function toTownsContent_MemberPayload(event, message, value, description) {
                         },
                     };
                 }
-                case 'tokenTransfer':
-                    return {
-                        content: {
-                            kind: RiverTimelineEvent.TokenTransfer,
-                            transaction: transaction,
-                            transfer: transaction.content.value,
-                            fromUserId: userIdFromAddress(fromUserAddress),
-                            createdAtEpochMs: event.createdAtEpochMs,
-                            threadParentId: bin_toHexString(transaction.content.value.messageId),
-                        },
-                    };
                 case 'spaceReview': {
                     if (!transaction.receipt) {
                         return { error: `${description} no receipt` };
@@ -283,6 +279,19 @@ function toTownsContent_MemberPayload(event, message, value, description) {
                         },
                     };
                 }
+                case 'tokenTransfer': {
+                    const transferContent = transaction.content.value;
+                    return {
+                        content: {
+                            kind: RiverTimelineEvent.TokenTransfer,
+                            transaction: transaction,
+                            transfer: transferContent,
+                            fromUserId: userIdFromAddress(fromUserAddress),
+                            createdAtEpochMs: event.createdAtEpochMs,
+                            threadParentId: bin_toHexString(transferContent.messageId),
+                        },
+                    };
+                }
                 case undefined:
                     return {
                         content: {
@@ -296,6 +305,10 @@ function toTownsContent_MemberPayload(event, message, value, description) {
                     return { error: `${description} unknown transaction content` };
             }
         }
+        case 'encryptionAlgorithm':
+            return {
+                error: `Encryption Algorithm not supported: ${description}`,
+            };
         case undefined:
             return { error: `Undefined payload case: ${description}` };
         default:
@@ -342,20 +355,18 @@ function toTownsContent_UserPayload(event, message, value, description) {
             };
         }
         case 'blockchainTransaction': {
-            const payload = value.content.value;
             return {
                 content: {
                     kind: RiverTimelineEvent.UserBlockchainTransaction,
-                    transaction: payload,
+                    transaction: value.content.value,
                 },
             };
         }
         case 'receivedBlockchainTransaction': {
-            const payload = value.content.value;
             return {
                 content: {
                     kind: RiverTimelineEvent.UserReceivedBlockchainTransaction,
-                    receivedTransaction: payload,
+                    receivedTransaction: value.content.value,
                 },
             };
         }
@@ -449,28 +460,24 @@ function toTownsContent_FromChannelMessage(channelMessage, description, eventId)
         }
     }
 }
-function toTownsContent_ChannelPayload_Message(timelineEvent, payload, description) {
-    if (isCiphertext(payload.ciphertext)) {
-        if (payload.refEventId) {
-            return {
-                content: {
-                    kind: RiverTimelineEvent.ChannelMessageEncryptedWithRef,
-                    refEventId: payload.refEventId,
-                },
-            };
-        }
+function toTownsContent_ChannelPayload_Message(timelineEvent, payload, _description) {
+    if (payload.refEventId) {
         return {
-            // if payload is an EncryptedData message, than it is encrypted content kind
             content: {
-                kind: RiverTimelineEvent.ChannelMessageEncrypted,
-                error: timelineEvent.decryptedContentError,
+                kind: RiverTimelineEvent.ChannelMessageEncryptedWithRef,
+                refEventId: payload.refEventId,
             },
         };
     }
-    // do not handle non-encrypted messages that should be encrypted
-    return { error: `${description} message text invalid channel message` };
+    return {
+        // if payload is an EncryptedData message, than it is encrypted content kind
+        content: {
+            kind: RiverTimelineEvent.ChannelMessageEncrypted,
+            error: timelineEvent.decryptedContentError,
+        },
+    };
 }
-function toTownsContent_ChannelPayload_ChannelProperties(timelineEvent, payload, description) {
+function toTownsContent_ChannelPayload_ChannelProperties(timelineEvent, _payload, _description) {
     if (timelineEvent.decryptedContent?.kind === 'channelProperties') {
         return {
             content: {
@@ -480,7 +487,12 @@ function toTownsContent_ChannelPayload_ChannelProperties(timelineEvent, payload,
         };
     }
     // If the payload is encrypted, we display nothing.
-    return { error: `${description} encrypted channel properties` };
+    return {
+        content: {
+            kind: RiverTimelineEvent.EncryptedChannelProperties,
+            error: timelineEvent.decryptedContentError,
+        },
+    };
 }
 function toTownsContent_ChannelPayload_Message_Post(value, eventId, editsEventId, description) {
     switch (value.content.case) {
@@ -552,12 +564,12 @@ function toTownsContent_SpacePayload(eventId, message, value, description) {
         }
         case 'channel': {
             const payload = value.content.value;
-            const channelId = streamIdAsString(payload.channelId);
+            const childId = streamIdAsString(payload.channelId);
             return {
                 content: {
                     kind: RiverTimelineEvent.ChannelCreate,
                     creatorId: message.creatorUserId,
-                    channelId,
+                    channelId: childId,
                     channelOp: payload.op,
                     channelSettings: payload.settings,
                 },
@@ -620,6 +632,7 @@ function getEventStatus(timelineEvent) {
         }
     }
     else {
+        logger.error('$$$ timelineStoreEvents unknown event status', { timelineEvent });
         return EventStatus.NOT_SENT;
     }
 }
@@ -634,6 +647,9 @@ function toAttachment(attachment, parentEventId, index) {
         case 'chunkedMedia': {
             const info = attachment.content.value.info;
             if (!info) {
+                logger.error('$$$ timelineStoreEvents invalid chunkedMedia attachment', {
+                    attachment,
+                });
                 return undefined;
             }
             const thumbnailInfo = attachment.content.value.thumbnail?.info;
@@ -648,6 +664,9 @@ function toAttachment(attachment, parentEventId, index) {
                 ? attachment.content.value.encryption.value
                 : undefined;
             if (!encryption) {
+                logger.error('$$$ timelineStoreEvents invalid chunkedMedia encryption', {
+                    attachment,
+                });
                 return undefined;
             }
             return {
@@ -705,10 +724,172 @@ function toAttachment(attachment, parentEventId, index) {
                 id,
             };
         }
+        case 'ticker': {
+            const content = attachment.content.value;
+            return {
+                id,
+                type: 'ticker',
+                address: content.address,
+                chainId: content.chainId,
+            };
+        }
         default:
             return undefined;
     }
 }
+/// fill in the event with the decrypted content
+/// i don't love this since it duplicates code, but it makes it so that we don't have to keep the
+/// original RemoteTimelineEvent around in memory
+export function toDecryptedEvent(event, decryptedContent, userId) {
+    if (!event.content) {
+        logger.error('$$$ timelineStoreEvents invalid event in toDecryptedEvent', {
+            event,
+            decryptedContent,
+        });
+        return event;
+    }
+    switch (event.content.kind) {
+        case RiverTimelineEvent.ChannelMessageEncrypted:
+        case RiverTimelineEvent.ChannelMessageEncryptedWithRef: {
+            if (decryptedContent.kind === 'channelMessage') {
+                const { content, error } = toTownsContent_FromChannelMessage(decryptedContent.content, `ChannelMessage: ${event.eventId}`, event.eventId);
+                if (error) {
+                    return event;
+                }
+                return {
+                    ...event,
+                    content,
+                    threadParentId: getThreadParentId(content),
+                    replyParentId: getReplyParentId(content),
+                    reactionParentId: getReactionParentId(content),
+                    isMentioned: getIsMentioned(content, userId),
+                };
+            }
+            else {
+                logger.error('$$$ timelineStoreEvents invalid channelMessageEncrypted', {
+                    event,
+                    decryptedContent,
+                });
+                return event;
+            }
+        }
+        case RiverTimelineEvent.SpaceDisplayName: {
+            if (decryptedContent.kind === 'text') {
+                return {
+                    ...event,
+                    content: {
+                        ...event.content,
+                        displayName: decryptedContent.content,
+                    },
+                };
+            }
+            else {
+                logger.error('$$$ timelineStoreEvents invalid spaceDisplayName', {
+                    event,
+                    decryptedContent,
+                });
+                return event;
+            }
+        }
+        case RiverTimelineEvent.SpaceUsername: {
+            if (decryptedContent.kind === 'text') {
+                return {
+                    ...event,
+                    content: {
+                        ...event.content,
+                        username: decryptedContent.content,
+                    },
+                };
+            }
+            else {
+                logger.error('$$$ timelineStoreEvents invalid spaceUsername', {
+                    event,
+                    decryptedContent,
+                });
+                return event;
+            }
+        }
+        case RiverTimelineEvent.EncryptedChannelProperties: {
+            if (decryptedContent.kind === 'channelProperties') {
+                return {
+                    ...event,
+                    content: {
+                        kind: RiverTimelineEvent.ChannelProperties,
+                        properties: decryptedContent.content,
+                    },
+                };
+            }
+            else {
+                logger.error('$$$ timelineStoreEvents invalid encryptedChannelProperties', {
+                    event,
+                    decryptedContent,
+                });
+                return event;
+            }
+        }
+        case RiverTimelineEvent.ChannelCreate:
+        case RiverTimelineEvent.ChannelMessage:
+        case RiverTimelineEvent.ChannelMessageMissing:
+        case RiverTimelineEvent.ChannelProperties:
+        case RiverTimelineEvent.Inception:
+        case RiverTimelineEvent.KeySolicitation:
+        case RiverTimelineEvent.Fulfillment:
+        case RiverTimelineEvent.MemberBlockchainTransaction:
+        case RiverTimelineEvent.MiniblockHeader:
+        case RiverTimelineEvent.Pin:
+        case RiverTimelineEvent.Reaction:
+        case RiverTimelineEvent.RedactedEvent:
+        case RiverTimelineEvent.RedactionActionEvent:
+        case RiverTimelineEvent.SpaceEnsAddress:
+        case RiverTimelineEvent.SpaceNft:
+        case RiverTimelineEvent.SpaceReview:
+        case RiverTimelineEvent.TokenTransfer:
+        case RiverTimelineEvent.TipEvent:
+        case RiverTimelineEvent.SpaceUpdateAutojoin:
+        case RiverTimelineEvent.SpaceUpdateHideUserJoinLeaves:
+        case RiverTimelineEvent.SpaceImage:
+        case RiverTimelineEvent.StreamEncryptionAlgorithm:
+        case RiverTimelineEvent.StreamMembership:
+        case RiverTimelineEvent.Unpin:
+        case RiverTimelineEvent.UserBlockchainTransaction:
+        case RiverTimelineEvent.UserReceivedBlockchainTransaction:
+            return event;
+        default:
+            logNever(event.content);
+            return event;
+    }
+}
+export function toDecryptedContentErrorEvent(event, error) {
+    switch (event.content?.kind) {
+        case RiverTimelineEvent.ChannelMessageEncrypted:
+        case RiverTimelineEvent.EncryptedChannelProperties:
+            return {
+                ...event,
+                content: {
+                    ...event.content,
+                    error,
+                },
+            };
+            break;
+    }
+    return event;
+}
+export function toMembership(membershipOp) {
+    switch (membershipOp) {
+        case MembershipOp.SO_JOIN:
+            return Membership.Join;
+        case MembershipOp.SO_INVITE:
+            return Membership.Invite;
+        case MembershipOp.SO_LEAVE:
+            return Membership.Leave;
+        case MembershipOp.SO_UNSPECIFIED:
+            return Membership.None;
+        case undefined:
+            return Membership.None;
+        default:
+            checkNever(membershipOp);
+    }
+}
 export function getFallbackContent(senderDisplayName, content, error) {
     if (error) {
         return error;
@@ -803,248 +984,4 @@ function getFallbackContent_BlockchainTransaction(transaction) {
             return `kind: ${transaction.content.case ?? 'unspecified'}`;
     }
 }
-export function transformAttachments(attachments) {
-    if (!attachments) {
-        return [];
-    }
-    return attachments
-        .map((attachment) => {
-        switch (attachment.type) {
-            case 'chunked_media':
-                return create(ChannelMessage_Post_AttachmentSchema, {
-                    content: {
-                        case: 'chunkedMedia',
-                        value: {
-                            info: attachment.info,
-                            streamId: attachment.streamId,
-                            encryption: {
-                                case: 'aesgcm',
-                                value: attachment.encryption,
-                            },
-                            thumbnail: {
-                                info: attachment.thumbnail?.info,
-                                content: attachment.thumbnail?.content,
-                            },
-                        },
-                    },
-                });
-            case 'embedded_media':
-                return create(ChannelMessage_Post_AttachmentSchema, {
-                    content: {
-                        case: 'embeddedMedia',
-                        value: {
-                            info: attachment.info,
-                            content: attachment.content,
-                        },
-                    },
-                });
-            case 'image':
-                return create(ChannelMessage_Post_AttachmentSchema, {
-                    content: {
-                        case: 'image',
-                        value: {
-                            info: attachment.info,
-                        },
-                    },
-                });
-            case 'embedded_message': {
-                const { channelMessageEvent, ...content } = attachment;
-                if (!channelMessageEvent) {
-                    return;
-                }
-                const post = create(ChannelMessage_PostSchema, {
-                    threadId: channelMessageEvent.threadId,
-                    threadPreview: channelMessageEvent.threadPreview,
-                    content: {
-                        case: 'text',
-                        value: {
-                            ...channelMessageEvent,
-                            attachments: transformAttachments(channelMessageEvent.attachments),
-                        },
-                    },
-                });
-                const value = create(ChannelMessage_Post_AttachmentSchema, {
-                    content: {
-                        case: 'embeddedMessage',
-                        value: {
-                            ...content,
-                            post,
-                        },
-                    },
-                });
-                return value;
-            }
-            case 'unfurled_link':
-                return create(ChannelMessage_Post_AttachmentSchema, {
-                    content: {
-                        case: 'unfurledUrl',
-                        value: {
-                            url: attachment.url,
-                            title: attachment.title,
-                            description: attachment.description,
-                            image: attachment.image
-                                ? {
-                                    height: attachment.image.height,
-                                    width: attachment.image.width,
-                                    url: attachment.image.url,
-                                }
-                                : undefined,
-                        },
-                    },
-                });
-            case 'ticker':
-                return create(ChannelMessage_Post_AttachmentSchema, {
-                    content: {
-                        case: 'ticker',
-                        value: {
-                            chainId: attachment.chainId,
-                            address: attachment.address,
-                        },
-                    },
-                });
-            default:
-                logNever(attachment);
-                return undefined;
-        }
-    })
-        .filter(isDefined);
-}
-function getThreadParentId(content) {
-    return content?.kind === RiverTimelineEvent.ChannelMessage ? content.threadId : undefined;
-}
-function getReplyParentId(content) {
-    return content?.kind === RiverTimelineEvent.ChannelMessage ? content.replyId : undefined;
-}
-function getReactionParentId(content) {
-    return content?.kind === RiverTimelineEvent.Reaction ? content.targetEventId : undefined;
-}
-function getIsMentioned(content, userId) {
-    //TODO: comparison below should be changed as soon as this HNT-1576 will be resolved
-    return content?.kind === RiverTimelineEvent.ChannelMessage
-        ? content.mentions.findIndex((x) => (x.userId ?? '')
-            .toLowerCase()
-            .localeCompare(userId.toLowerCase(), undefined, { sensitivity: 'base' }) == 0) >= 0
-        : false;
-}
-export function toMembership(membershipOp) {
-    switch (membershipOp) {
-        case MembershipOp.SO_JOIN:
-            return Membership.Join;
-        case MembershipOp.SO_INVITE:
-            return Membership.Invite;
-        case MembershipOp.SO_LEAVE:
-            return Membership.Leave;
-        case MembershipOp.SO_UNSPECIFIED:
-            return Membership.None;
-        case undefined:
-            return Membership.None;
-        default:
-            checkNever(membershipOp);
-    }
-}
-export function toReplacedMessageEvent(prev, next) {
-    if (!canReplaceEvent(prev, next)) {
-        return prev;
-    }
-    else if (next.content?.kind === RiverTimelineEvent.ChannelMessage &&
-        prev.content?.kind === RiverTimelineEvent.ChannelMessage) {
-        // when we replace an event, we copy the content up to the root event
-        // so we keep the prev id, but use the next content
-        const isLocalId = prev.eventId.startsWith('~');
-        const eventId = !isLocalId ? prev.eventId : next.eventId;
-        return {
-            ...next,
-            eventId: eventId,
-            eventNum: prev.eventNum,
-            latestEventId: next.eventId,
-            latestEventNum: next.eventNum,
-            confirmedEventNum: prev.confirmedEventNum ?? next.confirmedEventNum,
-            confirmedInBlockNum: prev.confirmedInBlockNum ?? next.confirmedInBlockNum,
-            createdAtEpochMs: prev.createdAtEpochMs,
-            updatedAtEpochMs: next.createdAtEpochMs,
-            content: {
-                ...next.content,
-                threadId: prev.content.threadId,
-            },
-            threadParentId: prev.threadParentId,
-            reactionParentId: prev.reactionParentId,
-            sender: prev.sender,
-        };
-    }
-    else if (next.content?.kind === RiverTimelineEvent.RedactedEvent) {
-        // for redacted events, carry over previous pointers to content
-        // we don't want to lose thread info
-        return {
-            ...next,
-            eventId: prev.eventId,
-            eventNum: prev.eventNum,
-            latestEventId: next.eventId,
-            latestEventNum: next.eventNum,
-            confirmedEventNum: prev.confirmedEventNum ?? next.confirmedEventNum,
-            confirmedInBlockNum: prev.confirmedInBlockNum ?? next.confirmedInBlockNum,
-            createdAtEpochMs: prev.createdAtEpochMs,
-            updatedAtEpochMs: next.createdAtEpochMs,
-            threadParentId: prev.threadParentId,
-            reactionParentId: prev.reactionParentId,
-        };
-    }
-    else if (prev.content?.kind === RiverTimelineEvent.RedactedEvent) {
-        // replacing a redacted event should maintain the redacted state
-        return {
-            ...prev,
-            latestEventId: next.eventId,
-            latestEventNum: next.eventNum,
-            confirmedEventNum: prev.confirmedEventNum ?? next.confirmedEventNum,
-            confirmedInBlockNum: prev.confirmedInBlockNum ?? next.confirmedInBlockNum,
-        };
-    }
-    else {
-        // make sure we carry the createdAtEpochMs of the previous event
-        // so we don't end up with a timeline that has events out of order.
-        return {
-            ...next,
-            eventId: prev.eventId,
-            eventNum: prev.eventNum,
-            latestEventId: next.eventId,
-            latestEventNum: next.eventNum,
-            confirmedEventNum: prev.confirmedEventNum ?? next.confirmedEventNum,
-            confirmedInBlockNum: prev.confirmedInBlockNum ?? next.confirmedInBlockNum,
-            createdAtEpochMs: prev.createdAtEpochMs,
-            updatedAtEpochMs: next.createdAtEpochMs,
-        };
-    }
-}
-function canReplaceEvent(prev, next) {
-    if (next.content?.kind === RiverTimelineEvent.RedactedEvent && next.content.isAdminRedaction) {
-        return true;
-    }
-    if (next.sender.id === prev.sender.id) {
-        return true;
-    }
-    return false;
-}
-export function makeRedactionEvent(redactionAction) {
-    if (redactionAction.content?.kind !== RiverTimelineEvent.RedactionActionEvent) {
-        throw new Error('makeRedactionEvent called with non-redaction action event');
-    }
-    const newContent = {
-        kind: RiverTimelineEvent.RedactedEvent,
-        isAdminRedaction: redactionAction.content.adminRedaction,
-    };
-    return {
-        ...redactionAction,
-        content: newContent,
-        fallbackContent: getFallbackContent('', newContent),
-        isRedacted: true,
-    };
-}
-export function getMessageSenderId(event) {
-    if (!getChannelMessageContent(event)) {
-        return undefined;
-    }
-    return event.sender.id;
-}
-export function getChannelMessageContent(event) {
-    return event?.content?.kind === RiverTimelineEvent.ChannelMessage ? event.content : undefined;
-}
-//# sourceMappingURL=timelineEvent.js.map
+//# sourceMappingURL=timelineEvents.js.map