@river-build/sdk/dist/tags.js

For more details, visit the following resources:

import { GroupMentionType, MessageInteractionType, } from '@river-build/proto';
import { addressFromUserId } from './id';
import { bin_fromHexString, check } from '@river-build/dlog';
import { isDefined } from './check';
import { bytesToHex } from 'ethereum-cryptography/utils';
export function makeTags(message, streamView) {
    return {
        messageInteractionType: getMessageInteractionType(message),
        groupMentionTypes: getGroupMentionTypes(message),
        mentionedUserAddresses: getMentionedUserAddresses(message),
        participatingUserAddresses: getParticipatingUserAddresses(message, streamView),
        threadId: getThreadId(message, streamView),
    };
}
export function makeTipTags(event, toUserId, streamView) {
    check(isDefined(streamView), 'stream not found');
    return {
        messageInteractionType: MessageInteractionType.TIP,
        groupMentionTypes: [],
        mentionedUserAddresses: [],
        participatingUserAddresses: [addressFromUserId(toUserId)],
        threadId: getParentThreadId(event.messageId, streamView),
    };
}
export function makeTransferTags(event, streamView) {
    check(isDefined(streamView), 'stream not found');
    return {
        messageInteractionType: MessageInteractionType.TRADE,
        groupMentionTypes: [],
        mentionedUserAddresses: [],
        participatingUserAddresses: [],
        threadId: getParentThreadId(bytesToHex(event.messageId), streamView),
    };
}
function getThreadId(message, streamView) {
    switch (message.payload.case) {
        case 'post':
            if (message.payload.value.threadId) {
                return bin_fromHexString(message.payload.value.threadId);
            }
            break;
        case 'reaction':
            return getParentThreadId(message.payload.value.refEventId, streamView);
        case 'edit':
            return getParentThreadId(message.payload.value.refEventId, streamView);
        case 'redaction':
            return getParentThreadId(message.payload.value.refEventId, streamView);
        default:
            break;
    }
    return undefined;
}
function getMessageInteractionType(message) {
    switch (message.payload.case) {
        case 'reaction':
            return MessageInteractionType.REACTION;
        case 'post':
            if (message.payload.value.threadId) {
                return MessageInteractionType.REPLY;
            }
            else if (message.payload.value.replyId) {
                return MessageInteractionType.REPLY;
            }
            else {
                return MessageInteractionType.POST;
            }
        case 'edit':
            return MessageInteractionType.EDIT;
        case 'redaction':
            return MessageInteractionType.REDACTION;
        default:
            return MessageInteractionType.UNSPECIFIED;
    }
}
function getGroupMentionTypes(message) {
    const types = [];
    if (message.payload.case === 'post' &&
        message.payload.value.content.case === 'text' &&
        message.payload.value.content.value.mentions.find((m) => m.mentionBehavior.case === 'atChannel')) {
        types.push(GroupMentionType.AT_CHANNEL);
    }
    return types;
}
function getMentionedUserAddresses(message) {
    if (message.payload.case === 'post' && message.payload.value.content.case === 'text') {
        return message.payload.value.content.value.mentions
            .filter((m) => m.mentionBehavior.case === undefined && m.userId.length > 0)
            .map((m) => addressFromUserId(m.userId));
    }
    return [];
}
function getParticipatingUserAddresses(message, streamView) {
    switch (message.payload.case) {
        case 'reaction': {
            const event = streamView.events.get(message.payload.value.refEventId);
            if (event && event.remoteEvent?.event.creatorAddress) {
                return [event.remoteEvent.event.creatorAddress];
            }
            return [];
        }
        case 'post': {
            const participating = new Set();
            const parentId = message.payload.value.threadId || message.payload.value.replyId;
            if (parentId) {
                const parentEvent = streamView.events.get(parentId);
                if (parentEvent && parentEvent.remoteEvent?.event.creatorAddress) {
                    participating.add(parentEvent.remoteEvent.event.creatorAddress);
                }
                streamView.timeline.forEach((event) => {
                    if (event.decryptedContent?.kind === 'channelMessage' &&
                        event.decryptedContent.content.payload.case === 'post' &&
                        event.decryptedContent.content.payload.value.threadId === parentId &&
                        event.remoteEvent?.event.creatorAddress) {
                        participating.add(event.remoteEvent.event.creatorAddress);
                    }
                });
            }
            return Array.from(participating);
        }
        default:
            return [];
    }
}
function getParentThreadId(eventId, streamView) {
    if (!eventId) {
        return undefined;
    }
    const event = streamView.events.get(eventId);
    if (!event) {
        return undefined;
    }
    if (event.decryptedContent?.kind === 'channelMessage' &&
        event.decryptedContent.content.payload.case === 'post') {
        if (event.decryptedContent.content.payload.value.threadId) {
            return bin_fromHexString(event.decryptedContent.content.payload.value.threadId);
        }
    }
    return undefined;
}
//# sourceMappingURL=tags.js.map