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

For more details, visit the following resources:

import { MembershipOp, } from '@river-build/proto';
import { StreamStateView_AbstractContent } from './streamStateView_AbstractContent';
import { bin_toHexString, check } from '@river-build/dlog';
import { logNever } from './check';
import { streamIdFromBytes } from './id';
import { utils } from 'ethers';
export class StreamStateView_User extends StreamStateView_AbstractContent {
    streamId;
    streamMemberships = {};
    tipsSent = {};
    tipsReceived = {};
    constructor(streamId) {
        super();
        this.streamId = streamId;
    }
    applySnapshot(snapshot, content, encryptionEmitter) {
        // initialize memberships
        for (const payload of content.memberships) {
            this.addUserPayload_userMembership(payload, encryptionEmitter);
        }
        this.tipsSent = { ...content.tipsSent };
        this.tipsReceived = { ...content.tipsReceived };
    }
    prependEvent(event, _cleartext, _encryptionEmitter, _stateEmitter) {
        check(event.remoteEvent.event.payload.case === 'userPayload');
        const payload = event.remoteEvent.event.payload.value;
        switch (payload.content.case) {
            case 'inception':
                break;
            case 'userMembership':
                // memberships are handled in the snapshot
                break;
            case 'userMembershipAction':
                break;
            case 'blockchainTransaction':
                break;
            case 'receivedBlockchainTransaction':
                break;
            case undefined:
                break;
            default:
                logNever(payload.content);
        }
    }
    appendEvent(event, cleartext, _encryptionEmitter, stateEmitter) {
        check(event.remoteEvent.event.payload.case === 'userPayload');
        const payload = event.remoteEvent.event.payload.value;
        switch (payload.content.case) {
            case 'inception':
                break;
            case 'userMembership':
                this.addUserPayload_userMembership(payload.content.value, stateEmitter);
                break;
            case 'userMembershipAction':
                break;
            case 'blockchainTransaction': {
                const transactionContent = payload.content.value.content;
                switch (transactionContent?.case) {
                    case undefined:
                        break;
                    case 'tip': {
                        const event = transactionContent.value.event;
                        if (!event) {
                            return;
                        }
                        const currency = utils.getAddress(bin_toHexString(event.currency));
                        this.tipsSent[currency] = this.tipsSent[currency] ?? 0n + event.amount;
                        stateEmitter?.emit('userTipSent', this.streamId, currency, event.amount);
                        break;
                    }
                    case 'tokenTransfer':
                        break;
                    case 'spaceReview': {
                        // user left a review on a space
                        break;
                    }
                    default:
                        logNever(transactionContent);
                        break;
                }
                break;
            }
            case 'receivedBlockchainTransaction': {
                const transactionContent = payload.content.value.transaction?.content;
                switch (transactionContent?.case) {
                    case undefined:
                        break;
                    case 'tip': {
                        const event = transactionContent.value.event;
                        if (!event) {
                            return;
                        }
                        const currency = utils.getAddress(bin_toHexString(event.currency));
                        this.tipsReceived[currency] =
                            this.tipsReceived[currency] ?? 0n + event.amount;
                        stateEmitter?.emit('userTipReceived', this.streamId, currency, event.amount);
                        break;
                    }
                    case 'tokenTransfer':
                        break;
                    case 'spaceReview': {
                        // user left a review on a space
                        break;
                    }
                    default:
                        logNever(transactionContent);
                        break;
                }
                break;
            }
            case undefined:
                break;
            default:
                logNever(payload.content);
        }
    }
    addUserPayload_userMembership(payload, emitter) {
        const { op, streamId: inStreamId } = payload;
        const streamId = streamIdFromBytes(inStreamId);
        const wasInvited = this.streamMemberships[streamId]?.op === MembershipOp.SO_INVITE;
        const wasJoined = this.streamMemberships[streamId]?.op === MembershipOp.SO_JOIN;
        this.streamMemberships[streamId] = payload;
        switch (op) {
            case MembershipOp.SO_INVITE:
                emitter?.emit('userInvitedToStream', streamId);
                emitter?.emit('userStreamMembershipChanged', streamId, payload);
                break;
            case MembershipOp.SO_JOIN:
                emitter?.emit('userJoinedStream', streamId);
                emitter?.emit('userStreamMembershipChanged', streamId, payload);
                break;
            case MembershipOp.SO_LEAVE:
                if (wasInvited || wasJoined) {
                    emitter?.emit('userLeftStream', streamId);
                    emitter?.emit('userStreamMembershipChanged', streamId, payload);
                }
                break;
            case MembershipOp.SO_UNSPECIFIED:
                break;
            default:
                logNever(op);
        }
    }
    getMembership(streamId) {
        return this.streamMemberships[streamId];
    }
    isMember(streamId, membership) {
        return this.getMembership(streamId)?.op === membership;
    }
    isJoined(streamId) {
        return this.isMember(streamId, MembershipOp.SO_JOIN);
    }
}
//# sourceMappingURL=streamStateView_User.js.map