@cloudflare/realtimekit-ui 0.0.0 → 1.0.0-staging.10

package/dist/collection/utils/breakout-rooms-manager.js

@@ -0,0 +1,299 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m")
+        throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f)
+        throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+        throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f)
+        throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+        throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s)
+        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+            t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var _BreakoutRoomsManager_instances, _BreakoutRoomsManager_hasLocalChanges, _BreakoutRoomsManager_state, _BreakoutRoomsManager_participantsNewMeetingMap, _BreakoutRoomsManager_participantsOldMeetingMap, _BreakoutRoomsManager_meetingParticipantsMap, _BreakoutRoomsManager_allParticipantsMap, _BreakoutRoomsManager_allMeetingsMap, _BreakoutRoomsManager_meetingsToUpdate, _BreakoutRoomsManager_meetingsToDelete, _BreakoutRoomsManager_init, _BreakoutRoomsManager_addNewMeetingToState, _BreakoutRoomsManager_addNewParticipantToState, _BreakoutRoomsManager_replaceDraftMeetingIds, _BreakoutRoomsManager_getMeetingParticipants;
+import { createDraftRoom, isDraftRoom, participantIdentifier, splitCollection, } from "./breakout-rooms";
+class BreakoutRoomsManager {
+    constructor() {
+        _BreakoutRoomsManager_instances.add(this);
+        _BreakoutRoomsManager_hasLocalChanges.set(this, false);
+        _BreakoutRoomsManager_state.set(this, void 0);
+        _BreakoutRoomsManager_participantsNewMeetingMap.set(this, void 0);
+        _BreakoutRoomsManager_participantsOldMeetingMap.set(this, void 0);
+        _BreakoutRoomsManager_meetingParticipantsMap.set(this, void 0);
+        _BreakoutRoomsManager_allParticipantsMap.set(this, void 0);
+        _BreakoutRoomsManager_allMeetingsMap.set(this, void 0);
+        _BreakoutRoomsManager_meetingsToUpdate.set(this, void 0);
+        _BreakoutRoomsManager_meetingsToDelete.set(this, void 0);
+    }
+    get hasLocalChanges() {
+        return __classPrivateFieldGet(this, _BreakoutRoomsManager_hasLocalChanges, "f");
+    }
+    get currentState() {
+        let parentMeeting;
+        let meetings = [];
+        Array.from(__classPrivateFieldGet(this, _BreakoutRoomsManager_meetingParticipantsMap, "f").keys()).forEach((meetingId) => {
+            const meeting = __classPrivateFieldGet(this, _BreakoutRoomsManager_allMeetingsMap, "f").get(meetingId);
+            if (meeting.isParent) {
+                parentMeeting = Object.assign(Object.assign({}, meeting), { participants: __classPrivateFieldGet(this, _BreakoutRoomsManager_instances, "m", _BreakoutRoomsManager_getMeetingParticipants).call(this, meetingId) });
+            }
+            else {
+                meetings.push(Object.assign(Object.assign({}, meeting), { participants: __classPrivateFieldGet(this, _BreakoutRoomsManager_instances, "m", _BreakoutRoomsManager_getMeetingParticipants).call(this, meetingId) }));
+            }
+        });
+        return {
+            parentMeeting,
+            meetings,
+        };
+    }
+    get allConnectedMeetings() {
+        return this.currentState.meetings.sort((a, b) => a.title.localeCompare(b.title));
+    }
+    get allParticipants() {
+        return Array.from(__classPrivateFieldGet(this, _BreakoutRoomsManager_allParticipantsMap, "f").values());
+    }
+    get unassignedParticipants() {
+        return __classPrivateFieldGet(this, _BreakoutRoomsManager_instances, "m", _BreakoutRoomsManager_getMeetingParticipants).call(this, __classPrivateFieldGet(this, _BreakoutRoomsManager_state, "f").parentMeeting.id);
+    }
+    /**
+     * get participants of a meeting
+     */
+    getParticipantsForMeeting(meetingId) {
+        return __classPrivateFieldGet(this, _BreakoutRoomsManager_instances, "m", _BreakoutRoomsManager_getMeetingParticipants).call(this, meetingId);
+    }
+    /**
+     * add a new connected meeting
+     */
+    addNewMeeting() {
+        __classPrivateFieldSet(this, _BreakoutRoomsManager_hasLocalChanges, true, "f");
+        const _a = createDraftRoom(), { participants } = _a, meeting = __rest(_a, ["participants"]);
+        __classPrivateFieldGet(this, _BreakoutRoomsManager_instances, "m", _BreakoutRoomsManager_addNewMeetingToState).call(this, Object.assign(Object.assign({}, meeting), { isParent: false }));
+        return meeting;
+    }
+    /**
+     * add multiple new connected meetings
+     */
+    addNewMeetings(count) {
+        return Array.from({ length: count }).map(() => this.addNewMeeting());
+    }
+    /**
+     * update a meeting's title
+     */
+    updateMeetingTitle(meetingId, newTitle) {
+        __classPrivateFieldGet(this, _BreakoutRoomsManager_allMeetingsMap, "f").get(meetingId).title = newTitle;
+        if (!isDraftRoom(meetingId)) {
+            __classPrivateFieldGet(this, _BreakoutRoomsManager_meetingsToUpdate, "f").add(meetingId);
+        }
+    }
+    /**
+     * deleteMeeting
+     */
+    deleteMeeting(meetingId) {
+        __classPrivateFieldSet(this, _BreakoutRoomsManager_hasLocalChanges, true, "f");
+        const meeting = __classPrivateFieldGet(this, _BreakoutRoomsManager_allMeetingsMap, "f").get(meetingId);
+        const participants = __classPrivateFieldGet(this, _BreakoutRoomsManager_instances, "m", _BreakoutRoomsManager_getMeetingParticipants).call(this, meeting.id).map(participantIdentifier);
+        this.assignParticipantsToMeeting(participants, __classPrivateFieldGet(this, _BreakoutRoomsManager_state, "f").parentMeeting.id);
+        __classPrivateFieldGet(this, _BreakoutRoomsManager_allMeetingsMap, "f").delete(meeting.id);
+        __classPrivateFieldGet(this, _BreakoutRoomsManager_meetingParticipantsMap, "f").delete(meeting.id);
+        if (!isDraftRoom(meeting.id)) {
+            __classPrivateFieldGet(this, _BreakoutRoomsManager_meetingsToDelete, "f").add(meeting.id);
+        }
+    }
+    /**
+     * assign participants to a meeting
+     */
+    assignParticipantsToMeeting(customParticipantIds, destinationMeetingId) {
+        __classPrivateFieldSet(this, _BreakoutRoomsManager_hasLocalChanges, true, "f");
+        customParticipantIds.forEach((participantId) => {
+            const currentMeetingId = __classPrivateFieldGet(this, _BreakoutRoomsManager_participantsNewMeetingMap, "f").get(participantId);
+            __classPrivateFieldGet(this, _BreakoutRoomsManager_meetingParticipantsMap, "f").get(currentMeetingId).delete(participantId);
+            __classPrivateFieldGet(this, _BreakoutRoomsManager_meetingParticipantsMap, "f").get(destinationMeetingId).add(participantId);
+            __classPrivateFieldGet(this, _BreakoutRoomsManager_participantsNewMeetingMap, "f").set(participantId, destinationMeetingId);
+        });
+        return this.currentState;
+    }
+    /**
+     * assign participants randomly
+     */
+    assignParticipantsRandomly() {
+        const splits = splitCollection(this.unassignedParticipants, this.allConnectedMeetings.length);
+        this.allConnectedMeetings.forEach((meeting, index) => {
+            const toAssign = splits[index];
+            if (toAssign && toAssign.length !== 0) {
+                this.assignParticipantsToMeeting(toAssign.map((participant) => participant.customParticipantId), meeting.id);
+            }
+        });
+        return this.currentState;
+    }
+    /**
+     * unassign participants
+     */
+    unassignParticipants(customParticipantIds) {
+        const destinationMeetingId = __classPrivateFieldGet(this, _BreakoutRoomsManager_state, "f").parentMeeting.id;
+        return this.assignParticipantsToMeeting(customParticipantIds, destinationMeetingId);
+    }
+    /**
+     * unassign all participants
+     */
+    unassignAllParticipants() {
+        const destinationMeetingId = __classPrivateFieldGet(this, _BreakoutRoomsManager_state, "f").parentMeeting.id;
+        const customParticipantIds = this.allParticipants.map(participantIdentifier);
+        return this.assignParticipantsToMeeting(customParticipantIds, destinationMeetingId);
+    }
+    /**
+     * update current state
+     */
+    updateCurrentState(state) {
+        if (!__classPrivateFieldGet(this, _BreakoutRoomsManager_hasLocalChanges, "f")) {
+            __classPrivateFieldGet(this, _BreakoutRoomsManager_instances, "m", _BreakoutRoomsManager_init).call(this, state);
+        }
+        [state.parentMeeting, ...state.meetings].forEach((meeting, index) => {
+            const draftMeeting = Object.assign(Object.assign({}, meeting), { isParent: index === 0 });
+            __classPrivateFieldGet(this, _BreakoutRoomsManager_instances, "m", _BreakoutRoomsManager_addNewMeetingToState).call(this, draftMeeting);
+            meeting.participants.forEach((participant) => {
+                __classPrivateFieldGet(this, _BreakoutRoomsManager_instances, "m", _BreakoutRoomsManager_addNewParticipantToState).call(this, participant, draftMeeting);
+            });
+        });
+    }
+    get meetingsToCreate() {
+        return this.allConnectedMeetings
+            .filter((meeting) => isDraftRoom(meeting.id))
+            .map(({ id, title }) => ({ id, title }));
+    }
+    get meetingsToUpdate() {
+        return this.allConnectedMeetings
+            .filter((meeting) => __classPrivateFieldGet(this, _BreakoutRoomsManager_meetingsToUpdate, "f").has(meeting.id))
+            .map(({ id, title }) => ({ id, title }));
+    }
+    get meetingsToDelete() {
+        return Array.from(__classPrivateFieldGet(this, _BreakoutRoomsManager_meetingsToDelete, "f"));
+    }
+    get participantsToMove() {
+        // gather participants
+        const moveMap = new Map();
+        Array.from(__classPrivateFieldGet(this, _BreakoutRoomsManager_participantsNewMeetingMap, "f").keys()).forEach((participantId) => {
+            const sourceMeetingId = __classPrivateFieldGet(this, _BreakoutRoomsManager_participantsOldMeetingMap, "f").get(participantId);
+            const destinationMeetingId = __classPrivateFieldGet(this, _BreakoutRoomsManager_participantsNewMeetingMap, "f").get(participantId);
+            if (sourceMeetingId === destinationMeetingId)
+                return;
+            const key = `${sourceMeetingId}__${destinationMeetingId}`;
+            if (!moveMap.has(key)) {
+                moveMap.set(key, []);
+            }
+            const participantDetails = __classPrivateFieldGet(this, _BreakoutRoomsManager_allParticipantsMap, "f").get(participantId);
+            moveMap.get(key).push(participantDetails.id);
+        });
+        return Array.from(moveMap.keys()).map((key) => {
+            const [sourceMeetingId, destinationMeetingId] = key.split('__');
+            return {
+                sourceMeetingId,
+                destinationMeetingId,
+                participantIds: moveMap.get(key),
+            };
+        });
+    }
+    async applyChanges(meeting) {
+        // create new rooms
+        const createMeetingsPromise = this.meetingsToCreate.length !== 0
+            ? meeting.connectedMeetings.createMeetings(this.meetingsToCreate)
+            : Promise.resolve([]);
+        // update old rooms titles
+        const updateMeetingsPromise = this.meetingsToUpdate.length !== 0
+            ? meeting.connectedMeetings.updateMeetings(this.meetingsToUpdate)
+            : Promise.resolve();
+        const [createMeetingsResponse] = await Promise.all([
+            createMeetingsPromise,
+            updateMeetingsPromise,
+        ]);
+        // replace temporary ids
+        if (createMeetingsResponse) {
+            createMeetingsResponse.forEach((meeting) => {
+                this.meetingsToCreate.forEach((draftMeeting) => {
+                    if (draftMeeting.title === meeting.title) {
+                        __classPrivateFieldGet(this, _BreakoutRoomsManager_instances, "m", _BreakoutRoomsManager_replaceDraftMeetingIds).call(this, __classPrivateFieldGet(this, _BreakoutRoomsManager_allMeetingsMap, "f").get(draftMeeting.id), meeting.id);
+                    }
+                });
+            });
+        }
+        // move participants (no async)
+        if (this.participantsToMove.length !== 0) {
+            this.participantsToMove.forEach(({ sourceMeetingId, destinationMeetingId, participantIds }) => {
+                meeting.connectedMeetings.moveParticipants(sourceMeetingId, destinationMeetingId, participantIds);
+            });
+        }
+        // delete rooms
+        if (this.meetingsToDelete.length !== 0) {
+            meeting.connectedMeetings.deleteMeetings(this.meetingsToDelete);
+        }
+    }
+    /**
+     * discard local changes
+     */
+    discardChanges() {
+        __classPrivateFieldSet(this, _BreakoutRoomsManager_hasLocalChanges, false, "f");
+        this.updateCurrentState(__classPrivateFieldGet(this, _BreakoutRoomsManager_state, "f"));
+        return this.currentState;
+    }
+}
+_BreakoutRoomsManager_hasLocalChanges = new WeakMap(), _BreakoutRoomsManager_state = new WeakMap(), _BreakoutRoomsManager_participantsNewMeetingMap = new WeakMap(), _BreakoutRoomsManager_participantsOldMeetingMap = new WeakMap(), _BreakoutRoomsManager_meetingParticipantsMap = new WeakMap(), _BreakoutRoomsManager_allParticipantsMap = new WeakMap(), _BreakoutRoomsManager_allMeetingsMap = new WeakMap(), _BreakoutRoomsManager_meetingsToUpdate = new WeakMap(), _BreakoutRoomsManager_meetingsToDelete = new WeakMap(), _BreakoutRoomsManager_instances = new WeakSet(), _BreakoutRoomsManager_init = function _BreakoutRoomsManager_init(state) {
+    __classPrivateFieldSet(this, _BreakoutRoomsManager_state, state, "f");
+    __classPrivateFieldSet(this, _BreakoutRoomsManager_allMeetingsMap, new Map(), "f");
+    __classPrivateFieldSet(this, _BreakoutRoomsManager_allParticipantsMap, new Map(), "f");
+    __classPrivateFieldSet(this, _BreakoutRoomsManager_meetingsToUpdate, new Set(), "f");
+    __classPrivateFieldSet(this, _BreakoutRoomsManager_meetingsToDelete, new Set(), "f");
+    __classPrivateFieldSet(this, _BreakoutRoomsManager_meetingParticipantsMap, new Map(), "f");
+    __classPrivateFieldSet(this, _BreakoutRoomsManager_participantsNewMeetingMap, new Map(), "f");
+    __classPrivateFieldSet(this, _BreakoutRoomsManager_participantsOldMeetingMap, new Map(), "f");
+    __classPrivateFieldSet(this, _BreakoutRoomsManager_participantsOldMeetingMap, new Map(), "f");
+    __classPrivateFieldGet(this, _BreakoutRoomsManager_state, "f").parentMeeting.participants.forEach((participant) => {
+        __classPrivateFieldGet(this, _BreakoutRoomsManager_participantsOldMeetingMap, "f").set(participantIdentifier(participant), __classPrivateFieldGet(this, _BreakoutRoomsManager_state, "f").parentMeeting.id);
+    });
+    __classPrivateFieldGet(this, _BreakoutRoomsManager_state, "f").meetings.forEach((meeting) => {
+        meeting.participants.forEach((participant) => {
+            __classPrivateFieldGet(this, _BreakoutRoomsManager_participantsOldMeetingMap, "f").set(participantIdentifier(participant), meeting.id);
+        });
+    });
+}, _BreakoutRoomsManager_addNewMeetingToState = function _BreakoutRoomsManager_addNewMeetingToState(meeting) {
+    if (!__classPrivateFieldGet(this, _BreakoutRoomsManager_allMeetingsMap, "f").has(meeting.id)) {
+        __classPrivateFieldGet(this, _BreakoutRoomsManager_allMeetingsMap, "f").set(meeting.id, meeting);
+        __classPrivateFieldGet(this, _BreakoutRoomsManager_meetingParticipantsMap, "f").set(meeting.id, new Set());
+    }
+}, _BreakoutRoomsManager_addNewParticipantToState = function _BreakoutRoomsManager_addNewParticipantToState(participant, meeting) {
+    if (__classPrivateFieldGet(this, _BreakoutRoomsManager_allParticipantsMap, "f").has(participantIdentifier(participant))) {
+        return;
+    }
+    __classPrivateFieldGet(this, _BreakoutRoomsManager_allParticipantsMap, "f").set(participantIdentifier(participant), participant);
+    __classPrivateFieldGet(this, _BreakoutRoomsManager_participantsNewMeetingMap, "f").set(participantIdentifier(participant), meeting.id);
+    __classPrivateFieldGet(this, _BreakoutRoomsManager_meetingParticipantsMap, "f").get(meeting.id).add(participantIdentifier(participant));
+}, _BreakoutRoomsManager_replaceDraftMeetingIds = function _BreakoutRoomsManager_replaceDraftMeetingIds(draftMeeting, realId) {
+    const draftId = draftMeeting.id;
+    __classPrivateFieldGet(this, _BreakoutRoomsManager_instances, "m", _BreakoutRoomsManager_addNewMeetingToState).call(this, Object.assign(Object.assign({}, draftMeeting), { id: realId }));
+    __classPrivateFieldGet(this, _BreakoutRoomsManager_allMeetingsMap, "f").delete(draftId);
+    const participantSet = __classPrivateFieldGet(this, _BreakoutRoomsManager_meetingParticipantsMap, "f").get(draftId);
+    __classPrivateFieldGet(this, _BreakoutRoomsManager_meetingParticipantsMap, "f").set(realId, participantSet);
+    __classPrivateFieldGet(this, _BreakoutRoomsManager_meetingParticipantsMap, "f").delete(draftId);
+    Array.from(__classPrivateFieldGet(this, _BreakoutRoomsManager_participantsNewMeetingMap, "f").keys()).forEach((participantId) => {
+        if (__classPrivateFieldGet(this, _BreakoutRoomsManager_participantsNewMeetingMap, "f").get(participantId) === draftId) {
+            __classPrivateFieldGet(this, _BreakoutRoomsManager_participantsNewMeetingMap, "f").set(participantId, realId);
+        }
+    });
+}, _BreakoutRoomsManager_getMeetingParticipants = function _BreakoutRoomsManager_getMeetingParticipants(meetingId) {
+    const participantIds = Array.from(__classPrivateFieldGet(this, _BreakoutRoomsManager_meetingParticipantsMap, "f").get(meetingId));
+    return participantIds.map((id) => __classPrivateFieldGet(this, _BreakoutRoomsManager_allParticipantsMap, "f").get(id));
+};
+export default BreakoutRoomsManager;

package/dist/collection/utils/breakout-rooms.js

@@ -0,0 +1,69 @@
+import { isBreakoutRoomsEnabled } from "./flags";
+let roomCount = 0;
+export function getNextRoomNumber() {
+    return ++roomCount;
+}
+export function resetRoomCount() {
+    roomCount = 0;
+}
+export const TEMP_ROOM_PREFIX = 'temp-';
+export function createDraftRoom() {
+    return {
+        id: `${TEMP_ROOM_PREFIX}${Math.random().toString(36)}`,
+        title: `Room ${getNextRoomNumber()}`,
+        participants: [],
+    };
+}
+export function createDraftRooms(numberOfRooms) {
+    return Array.from({ length: numberOfRooms }).map(createDraftRoom);
+}
+export function isDraftRoom(roomId) {
+    return roomId.includes(TEMP_ROOM_PREFIX);
+}
+export function splitCollection(collection, parts) {
+    const length = collection.length;
+    const size = Math.ceil(length / parts);
+    const result = new Array(parts);
+    let start = 0;
+    for (let i = 0; i < parts; i++) {
+        result[i] = collection.slice(start, start + size);
+        start += size;
+    }
+    return result.filter((res) => res.length);
+}
+export function participantIdentifier(participant) {
+    var _a;
+    return (_a = participant.customParticipantId) !== null && _a !== void 0 ? _a : participant.clientSpecificId;
+}
+export function getAllConnectedParticipants(meeting) {
+    // TODO: remove this once we start getting display pics from socket
+    const map = new Map();
+    [meeting.self, ...meeting.participants.joined.toArray()].map((participant) => {
+        map.set(participantIdentifier(participant), participant.picture);
+    });
+    return [meeting.connectedMeetings.parentMeeting, ...meeting.connectedMeetings.meetings]
+        .flatMap((meeting) => meeting.participants)
+        .map((connectedPeer) => {
+        return {
+            id: connectedPeer.id,
+            customParticipantId: participantIdentifier(connectedPeer),
+            displayName: connectedPeer.displayName,
+            displayPictureUrl: connectedPeer.displayPictureUrl !== ''
+                ? connectedPeer.displayPictureUrl
+                : map.get(participantIdentifier(connectedPeer)),
+        };
+    });
+}
+export const canToggleBreakout = (meeting) => {
+    if (!isBreakoutRoomsEnabled(meeting))
+        return false;
+    const permissions = meeting.self.permissions.connectedMeetings;
+    // for host - always show toggle
+    if (permissions.canAlterConnectedMeetings)
+        return true;
+    // for participants - show only when breakout is active
+    if (permissions.canSwitchConnectedMeetings || permissions.canSwitchToParentMeeting) {
+        return meeting.connectedMeetings.isActive;
+    }
+    return false;
+};

package/dist/collection/utils/chat.js

@@ -0,0 +1,198 @@
+import { chatUnreadTimestamps } from "./user-prefs";
+export const parseMessageForTarget = (message) => {
+    let parsedMessage = null;
+    try {
+        const parsed = JSON.parse(message.message);
+        const { target, message: m } = parsed;
+        if (target === undefined || m === undefined) {
+            parsedMessage = message;
+        }
+        else {
+            parsedMessage = Object.assign(Object.assign({}, message), { targetUserIds: target, message: m });
+        }
+    }
+    catch (error) {
+        parsedMessage = message;
+    }
+    return parsedMessage;
+};
+export function alphabeticalSorter(a, b) {
+    return a.localeCompare(b);
+}
+/**
+ * Generate a unique chat group key used in `<rtk-chat-messages-ui />`
+ * @param ids An array of user ids
+ * @returns A unique key from the user ids
+ */
+export function generateChatGroupKey(ids) {
+    return ids.sort((a, b) => a.localeCompare(b)).join('_');
+}
+export function handleFilesDataTransfer(items, callback) {
+    if (items == null)
+        return true;
+    for (const item of items) {
+        if (item.kind === 'file') {
+            const file = item.getAsFile();
+            if (item.type.startsWith('image/')) {
+                callback('image', file);
+            }
+            else {
+                callback('file', file);
+            }
+        }
+    }
+}
+export function getChatGroups({ messages, participants, selfUserId }) {
+    const groups = {};
+    // create empty chat groups for all participants
+    for (const participant of participants) {
+        groups[generateChatGroupKey([participant.userId, selfUserId])] = [];
+    }
+    messages.forEach((message) => {
+        var _a;
+        const parsedMessage = parseMessageForTarget(message);
+        let key = 'everyone';
+        if (((_a = parsedMessage.targetUserIds) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            const allParticipants = new Set([
+                parsedMessage.userId,
+                ...parsedMessage.targetUserIds,
+            ]);
+            key = generateChatGroupKey(Array.from(allParticipants));
+        }
+        if (!groups[key]) {
+            groups[key] = [];
+        }
+        groups[key].push({ type: 'chat', message: parsedMessage });
+    });
+    return groups;
+}
+export function getUnreadChatCounts({ messages, selfUserId, selectedGroupId, participants, }) {
+    var _a;
+    const groups = getChatGroups({
+        messages,
+        selfUserId,
+        participants,
+    });
+    const unreadCounts = {};
+    for (const key in groups) {
+        const lastReadTimestamp = (_a = chatUnreadTimestamps[key]) !== null && _a !== void 0 ? _a : 0;
+        if (key === selectedGroupId) {
+            // reset count to 0 when you select a group
+            unreadCounts[key] = 0;
+            chatUnreadTimestamps[key] = new Date();
+        }
+        else {
+            unreadCounts[key] = groups[key].filter((c) => {
+                return (c.type == 'chat' && c.message.time > lastReadTimestamp && c.message.userId !== selfUserId);
+            }).length;
+        }
+    }
+    return unreadCounts;
+}
+export function getParticipantUserId({ groupId, selfUserId, }) {
+    return groupId.split('_').find((id) => id != selfUserId);
+}
+export const TEMPORARY_CHANNEL_PREFIX = 'dm__';
+export function isDirectMessageChannel(channel) {
+    return channel.isDirectMessage;
+}
+export function getDMComparator(memberIds) {
+    const uniqueMemberIds = [...new Set(memberIds)];
+    return uniqueMemberIds.sort(alphabeticalSorter).join('<>');
+}
+export function reverse(str) {
+    return str.split('').reverse().join('');
+}
+export const emailPattern = /(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))/;
+export const boldPattern = /^\*([^*\s]+)\*/;
+export const italicsPattern = /^_([^_\s]+)_/;
+export const strikethroughPattern = /^~([^~\s]+)~/;
+// Source: https://stackoverflow.com/a/8234912/2013580
+export const linkPattern = /https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.,~#?&//=]*)/;
+export const replyBlockPattern = /<blockquote>[.\s\S]*<\/blockquote>\n\n/m;
+export function extractReplyBlock(message, excludeTags = false) {
+    if (!replyBlockPattern.test(message)) {
+        return '';
+    }
+    let startOffset = 0;
+    let endOffset = '</blockquote>'.length;
+    if (excludeTags) {
+        startOffset = '<blockquote>'.length;
+        endOffset = 0;
+    }
+    return message.substring(message.indexOf('<blockquote>') + startOffset, message.indexOf('</blockquote>') + endOffset);
+}
+export function stripOutReplyBlock(message) {
+    return message.replace(replyBlockPattern, '');
+}
+export const MAX_TEXT_LENGTH = 2000;
+const KNOWN_TAGS = ['<a>', '<b>', '<i>', '<q>', '<s>'];
+export function parseRichText(text) {
+    text = text
+        .split(' ')
+        .map((word) => {
+        if (linkPattern.test(word)) {
+            const res = linkPattern.exec(word);
+            word = word.replace(res[0], `<a>${res[0]}</a>`);
+        }
+        else {
+            if (boldPattern.test(word)) {
+                const res = boldPattern.exec(word);
+                word = word.replace(res[0], `<b>${res[1]}</b>`);
+            }
+            if (italicsPattern.test(word)) {
+                const res = italicsPattern.exec(word);
+                word = word.replace(res[0], `<i>${res[1]}</i>`);
+            }
+            if (strikethroughPattern.test(word)) {
+                const res = strikethroughPattern.exec(word);
+                word = word.replace(res[0], `<s>${res[1]}</s>`);
+            }
+        }
+        return word;
+    })
+        .join(' ');
+    text = text
+        .split(' ')
+        .map((word, idx) => {
+        if (word === '>' && (idx === 0 || word[idx - 1] === '>')) {
+            return `<q></q>`;
+        }
+        return word;
+    })
+        .join(' ');
+    const [tokens] = tokenizeRichText(text);
+    return tokens;
+}
+export function tokenizeRichText(text, endTag = '') {
+    const tokens = [];
+    if (text.length === 0) {
+        return [tokens, 0];
+    }
+    let i = 0;
+    while (i < text.length) {
+        if (endTag.length && endTag === text.substring(i, i + endTag.length)) {
+            return [tokens, i + endTag.length];
+        }
+        if (KNOWN_TAGS.includes(text.substring(i, i + 3))) {
+            const [subtokens, pos] = tokenizeRichText(text.substring(i + 3), `</${text[i + 1]}>`);
+            tokens.push({
+                type: text[i + 1],
+                content: subtokens.length === 1 && subtokens[0].type === 'plain_text'
+                    ? subtokens[0].content
+                    : subtokens,
+            });
+            i += pos + 3;
+        }
+        else {
+            let top = tokens[tokens.length - 1];
+            if (!top || top.type !== 'plain_text') {
+                tokens.push({ type: 'plain_text', content: '' });
+                top = tokens[tokens.length - 1];
+            }
+            top.content += text[i];
+            i++;
+        }
+    }
+    return [tokens, i];
+}

package/dist/collection/utils/clone.js

@@ -0,0 +1,7 @@
+import { cloneDeep } from "lodash-es";
+export default function clone(obj) {
+    if (structuredClone) {
+        return structuredClone(obj);
+    }
+    return cloneDeep(obj);
+}