@typexim/web-sdk 0.0.6 → 0.0.8

package/dist-test/modules/PushMessageProcessor.js

@@ -0,0 +1,437 @@
+import { Bool, MessageKind, MessageOperation, PushMessageType } from '../enums/index.js';
+import { CHAT_SDK_EVENT } from '../events.js';
+export default class PushMessageProcessor {
+    constructor(config) {
+        Object.defineProperty(this, "context", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "logger", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "emitter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "feedCache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "handleKickoff", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.context = config.context;
+        this.logger = config.logger;
+        this.emitter = config.emitter;
+        this.feedCache = config.feedCache;
+        this.handleKickoff = config.onKickoff;
+    }
+    emitFeedListUpdated() {
+        this.emitter.emit(CHAT_SDK_EVENT.FEED_LIST_UPDATED, {
+            list: this.feedCache.getAll(),
+            is_sync_completed: this.feedCache.isSyncCompleted(),
+        });
+    }
+    processCreateFeed(pushMessage) {
+        this.feedCache.unshift(pushMessage.content);
+        this.emitFeedListUpdated();
+    }
+    processUpdateFeed(pushMessage) {
+        const nFeed = pushMessage.content;
+        const feed = this.feedCache.getByChat(nFeed.chat_id, nFeed.thread_id);
+        if (feed === null) {
+            return;
+        }
+        const newFeed = { ...feed, ...nFeed };
+        this.feedCache.update(newFeed);
+        this.emitFeedListUpdated();
+    }
+    processDeleteFeed(pushMessage) {
+        const ok = this.feedCache.remove(pushMessage.content.id);
+        if (ok) {
+            this.emitFeedListUpdated();
+        }
+    }
+    processAddMessage(pushMessage) {
+        if (this.context.loginUser === null) {
+            return;
+        }
+        const loginUserId = this.context.loginUser.userId;
+        const message = pushMessage.content;
+        // 以下情况对消息不处理：
+        // 1. 消息对当前登录用户隐藏
+        // 2. 不更新feed的last_message_*
+        if (message.hide_ids.includes(loginUserId)) {
+            return;
+        }
+        // 找到message所属的feed
+        const feed = this.feedCache.getByChat(message.chat_id, message.thread_id);
+        if (feed === null) {
+            return;
+        }
+        if (message.no_last_msg !== Bool.yes) {
+            let needUpdateFeed = false;
+            let needUpdateFeedOrder = false;
+            const partialFeed = {};
+            // 更新未读消息数
+            if (message.message_kind_id !== MessageKind.system &&
+                message.sender_id !== loginUserId &&
+                message.no_read !== Bool.yes) {
+                needUpdateFeed = true;
+                const unreadMessageSet = new Set(feed.unread_message_ids);
+                unreadMessageSet.add(message.id);
+                partialFeed.unread_message_ids = [...unreadMessageSet];
+                partialFeed.badge = unreadMessageSet.size;
+            }
+            // 更新最后一条消息
+            if (feed.last_message_position < message.position) {
+                needUpdateFeed = true;
+                needUpdateFeedOrder = true;
+                partialFeed.last_message_id = message.id;
+                partialFeed.last_message_position = message.position;
+                partialFeed.last_message_sender_id = message.sender_id;
+                partialFeed.last_message_send_at = message.send_at;
+                partialFeed.last_message_kind_id = message.message_kind_id;
+                partialFeed.last_message_type_id = message.message_type_id;
+                partialFeed.last_message = message.content;
+                partialFeed.last_message_operation = message.operation;
+                partialFeed.last_message_operation_user_id = message.operation_user_id;
+            }
+            if (needUpdateFeed) {
+                const newFeed = { ...feed, ...partialFeed };
+                if (needUpdateFeedOrder) {
+                    this.feedCache.unshift(newFeed);
+                }
+                else {
+                    this.feedCache.update(newFeed);
+                }
+                this.emitFeedListUpdated();
+            }
+        }
+        this.emitter.emit(CHAT_SDK_EVENT.MESSAGE_RECEIVED, {
+            feed_id: feed.id,
+            message,
+        });
+    }
+    processUpdateMessage(pushMessage) {
+        const info = pushMessage.content;
+        const feed = this.feedCache.getByChat(info.chat_id, info.thread_id);
+        if (feed === null) {
+            return;
+        }
+        if (info.operation != null) {
+            let needUpdateFeed = false;
+            const partialFeed = {};
+            if (info.operation === MessageOperation.recall ||
+                info.operation === MessageOperation.destroy) {
+                // 更新未读消息数
+                if (feed.unread_message_ids != null &&
+                    feed.unread_message_ids.includes(info.id)) {
+                    needUpdateFeed = true;
+                    const unreadMessageSet = new Set(feed.unread_message_ids);
+                    unreadMessageSet.delete(info.id);
+                    partialFeed.unread_message_ids = [...unreadMessageSet];
+                    partialFeed.badge = partialFeed.unread_message_ids.length;
+                }
+                // 更新最后一条消息
+                if (feed.last_message_id === info.id) {
+                    needUpdateFeed = true;
+                    partialFeed.last_message = info.content ?? '{}';
+                    partialFeed.last_message_operation = info.operation;
+                    partialFeed.last_message_operation_user_id =
+                        info.operation_user_id ?? '0';
+                }
+            }
+            else if (info.operation === MessageOperation.edit) {
+                if (feed.last_message_id === info.id) {
+                    needUpdateFeed = true;
+                    partialFeed.last_message_kind_id = info.message_kind_id;
+                    partialFeed.last_message_type_id = info.message_type_id;
+                    partialFeed.last_message = info.content;
+                    partialFeed.last_message_operation = info.operation;
+                    partialFeed.last_message_operation_user_id = info.operation_user_id;
+                }
+            }
+            if (needUpdateFeed) {
+                this.feedCache.update({
+                    ...feed,
+                    ...partialFeed,
+                });
+                this.emitFeedListUpdated();
+            }
+            if (info.operation === MessageOperation.recall) {
+                this.emitter.emit(CHAT_SDK_EVENT.MESSAGE_RECALLED, {
+                    message_ids: [info.id],
+                });
+            }
+            else if (info.operation === MessageOperation.edit) {
+                if (info.content != null &&
+                    info.edited_at != null &&
+                    info.message_kind_id != null &&
+                    info.message_type_id != null &&
+                    info.operation_user_id != null) {
+                    this.emitter.emit(CHAT_SDK_EVENT.MESSAGE_EDITED, {
+                        chat_id: info.chat_id,
+                        content: info.content,
+                        edited_at: info.edited_at,
+                        id: info.id,
+                        message_kind_id: info.message_kind_id,
+                        message_type_id: info.message_type_id,
+                        operation: info.operation,
+                        operation_user_id: info.operation_user_id,
+                        thread_id: info.thread_id,
+                    });
+                }
+            }
+            else if (info.operation === MessageOperation.destroy) {
+                this.emitter.emit(CHAT_SDK_EVENT.MESSAGE_DESTROYED, {
+                    feed_id: feed.id,
+                    message_ids: [info.id],
+                });
+            }
+        }
+    }
+    processDeleteMessage(pushMessage) {
+        const info = pushMessage.content;
+        const feed = this.feedCache.getByChat(info.chat_id, info.thread_id);
+        if (feed === null) {
+            return;
+        }
+        let needUpdateFeed = false;
+        const partialFeed = {};
+        // 更新最后一条消息
+        if (feed.last_message_id === info.id) {
+            needUpdateFeed = true;
+            partialFeed.last_message = info.content ?? '{}';
+            partialFeed.last_message_operation = info.operation;
+            partialFeed.last_message_operation_user_id =
+                info.operation_user_id ?? '0';
+        }
+        if (needUpdateFeed) {
+            this.feedCache.update({
+                ...feed,
+                ...partialFeed,
+            });
+            this.emitFeedListUpdated();
+        }
+        this.emitter.emit(CHAT_SDK_EVENT.MESSAGE_DESTROYED, {
+            feed_id: feed.id,
+            message_ids: [info.id],
+        });
+    }
+    processOpenClockMessage(pushMessage) {
+        const info = pushMessage.content;
+        const feed = this.feedCache.getByChat(info.chat_id, info.thread_id);
+        if (feed === null) {
+            return;
+        }
+        if (Array.isArray(info.msgs_open_clock)) {
+            const messageIds = info.msgs_open_clock.map((item) => item.message_id);
+            this.emitter.emit(CHAT_SDK_EVENT.MESSAGE_OPEN_CLOCK, {
+                feed_id: feed.id,
+                message_ids: messageIds,
+            });
+        }
+    }
+    processPushLiveMessage(pushMessage) {
+        this.emitter.emit(CHAT_SDK_EVENT.ROOM_MESSAGE_RECEIVED, {
+            room_id: pushMessage.content.room_id,
+            content: pushMessage.content.message,
+        });
+    }
+    processPushSystemNotice(pushMessage) {
+        this.emitter.emit(CHAT_SDK_EVENT.SYSTEM_NOTICE_RECEIVED, {
+            content: pushMessage.content,
+        });
+    }
+    processReadMessage(pushMessage) {
+        if (this.context.loginUser === null) {
+            return;
+        }
+        const loginUserId = this.context.loginUser.userId;
+        const info = pushMessage.content;
+        const feed = this.feedCache.getByChat(info.chat_id, info.thread_id);
+        if (feed === null) {
+            return;
+        }
+        let needUpdateFeed = false;
+        const partialFeed = {};
+        // 更新未读数
+        if (info.reader_ids.includes(loginUserId) && info.message_ids.length > 0) {
+            needUpdateFeed = true;
+            const unreadMessageSet = new Set(feed.unread_message_ids);
+            info.message_ids.forEach((id) => {
+                unreadMessageSet.delete(id);
+            });
+            partialFeed.unread_message_ids = [...unreadMessageSet];
+            partialFeed.badge = unreadMessageSet.size;
+        }
+        if (needUpdateFeed) {
+            this.feedCache.update({
+                ...feed,
+                ...partialFeed,
+            });
+            this.emitFeedListUpdated();
+        }
+        this.emitter.emit(CHAT_SDK_EVENT.MESSAGE_RECEIPT_RECEIVED, {
+            feed_id: feed.id,
+            message_ids: info.message_ids,
+            reader_user_ids: info.reader_ids,
+        });
+    }
+    processKickOutDevice() {
+        this.handleKickoff();
+    }
+    processGroupMember(pushMessage) {
+        const info = pushMessage.content;
+        const feed = this.feedCache.getByChat(info.chat_id, '0');
+        if (feed === null) {
+            return;
+        }
+        const chatterIdSet = new Set(feed.chat_member);
+        const isAdd = pushMessage.type === PushMessageType.ADD_GROUP_MEMBER;
+        const isDel = pushMessage.type === PushMessageType.DEL_GROUP_MEMBER;
+        info.chat_member.forEach((chatter) => {
+            if (isAdd) {
+                chatterIdSet.add(chatter.chat_id);
+            }
+            else if (isDel) {
+                chatterIdSet.delete(chatter.chat_id);
+            }
+        });
+        this.feedCache.update({
+            ...feed,
+            chat_member: [...chatterIdSet],
+        });
+        this.emitFeedListUpdated();
+    }
+    processUpdateGroup(pushMessage) {
+        const info = pushMessage.content;
+        const feed = this.feedCache.getByChat(info.chat_id, '0');
+        if (feed === null) {
+            return;
+        }
+        let needUpdateFeed = false;
+        const partialFeed = {};
+        if (info.avatar != null) {
+            needUpdateFeed = true;
+            partialFeed.avatar = info.avatar;
+        }
+        if (info.name != null) {
+            needUpdateFeed = true;
+            partialFeed.name = info.name;
+        }
+        if (needUpdateFeed) {
+            this.feedCache.update({
+                ...feed,
+                ...partialFeed,
+            });
+            this.emitFeedListUpdated();
+        }
+    }
+    processUpdateUserData(pushMessage) {
+        const info = pushMessage.content;
+        const feedList = this.feedCache.getByTargetId(info.id);
+        if (feedList.length > 0) {
+            const partialFeed = {};
+            if (info.avatar != null) {
+                partialFeed.avatar = info.avatar;
+            }
+            if (info.first_name != null || info.last_name != null) {
+                let name = info.first_name ?? '';
+                if (info.last_name != null) {
+                    if (name.length > 0) {
+                        name = `${name} ${info.last_name}`;
+                    }
+                    else {
+                        name = info.last_name;
+                    }
+                }
+                partialFeed.name = name;
+            }
+            for (const feed of feedList) {
+                this.feedCache.update({
+                    ...feed,
+                    ...partialFeed,
+                });
+            }
+            this.emitFeedListUpdated();
+        }
+    }
+    processUpdateMessageReaction(pushMessage) {
+        const info = pushMessage.content;
+        const feed = this.feedCache.getByChat(info.chat_id, info.thread_id);
+        if (feed === null) {
+            return;
+        }
+        this.emitter.emit(CHAT_SDK_EVENT.MESSAGE_REACTION_UPDATED, {
+            feed_id: feed.id,
+            message_id: info.message_id,
+            reactions: info.reactions,
+        });
+    }
+    process(pushMessage) {
+        this.logger.info('PushMessageProcessor process', pushMessage);
+        switch (pushMessage.type) {
+            case PushMessageType.CREATE_FEED:
+                this.processCreateFeed(pushMessage);
+                break;
+            case PushMessageType.UPDATE_FEED:
+                this.processUpdateFeed(pushMessage);
+                break;
+            case PushMessageType.DELETE_FEED:
+                this.processDeleteFeed(pushMessage);
+                break;
+            case PushMessageType.ADD_MESSAGE:
+                this.processAddMessage(pushMessage);
+                break;
+            case PushMessageType.UPDATE_MESSAGE:
+                this.processUpdateMessage(pushMessage);
+                break;
+            case PushMessageType.DELETE_MESSAGE:
+                this.processDeleteMessage(pushMessage);
+                break;
+            case PushMessageType.PUSH_LIVE_MESSAGE:
+                this.processPushLiveMessage(pushMessage);
+                break;
+            case PushMessageType.MSG_OPEN_CLOCK: {
+                this.processOpenClockMessage(pushMessage);
+                break;
+            }
+            case PushMessageType.PUSH_SYSTEM_NOTICE:
+                this.processPushSystemNotice(pushMessage);
+                break;
+            case PushMessageType.READ_MESSAGE:
+                this.processReadMessage(pushMessage);
+                break;
+            case PushMessageType.KICK_OUT_DEVICE:
+                this.processKickOutDevice();
+                break;
+            case PushMessageType.ADD_GROUP_MEMBER:
+            case PushMessageType.DEL_GROUP_MEMBER:
+                this.processGroupMember(pushMessage);
+                break;
+            case PushMessageType.UPDATE_GROUP:
+                this.processUpdateGroup(pushMessage);
+                break;
+            case PushMessageType.UPDATE_USER_DATA:
+                this.processUpdateUserData(pushMessage);
+                break;
+            case PushMessageType.UPDATE_MESSAGE_REACTION:
+                this.processUpdateMessageReaction(pushMessage);
+                break;
+        }
+    }
+}

package/dist-test/modules/ReConnectWebsocket.js

@@ -0,0 +1,223 @@
+import { PushMessageType } from '../enums/index.js';
+import { buildWebSocketAuthProtocols, buildWebSocketConnectUrl, } from '../utils/websocket.js';
+import Base from './Base.js';
+const PING_TIMEOUT_MS = 20000;
+const PONG_TIMEOUT_MS = 10000;
+const RE_CONNECT_TIMEOUT_MS = 5000;
+export default class ReConnectWebsocket extends Base {
+    constructor(config) {
+        super();
+        Object.defineProperty(this, "url", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "token", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "wsRoute", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "logger", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ws", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "destroyed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pingTimeout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pongTimeout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "reConnectTimeout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.url = config.url;
+        this.token = config.token;
+        this.wsRoute = config.wsRoute ?? null;
+        this.logger = config.logger;
+        this.ws = null;
+        this.destroyed = false;
+        this.pingTimeout = null;
+        this.pongTimeout = null;
+        this.reConnectTimeout = null;
+        this.reConnect = this.reConnect.bind(this);
+        window.addEventListener('online', this.reConnect);
+        this.connect();
+    }
+    disconnect() {
+        if (this.ws) {
+            this.ws.onopen = null;
+            this.ws.onerror = null;
+            this.ws.onmessage = null;
+            this.ws.onclose = null;
+            this.ws.close();
+            this.ws = null;
+        }
+        if (this.pingTimeout !== null) {
+            clearTimeout(this.pingTimeout);
+            this.pingTimeout = null;
+        }
+        if (this.pongTimeout !== null) {
+            clearTimeout(this.pongTimeout);
+            this.pongTimeout = null;
+        }
+        if (this.reConnectTimeout !== null) {
+            clearTimeout(this.reConnectTimeout);
+            this.reConnectTimeout = null;
+        }
+    }
+    connect() {
+        if (this.ws) {
+            this.logger.warn('ReConnectWebsocket try connect but already connected');
+            return;
+        }
+        const ws = new WebSocket(buildWebSocketConnectUrl(this.url, {
+            platform: 'web',
+            wsRoute: this.wsRoute,
+        }), buildWebSocketAuthProtocols(this.token));
+        this.ws = ws;
+        ws.onopen = () => {
+            this.delaySendPing();
+        };
+        ws.onerror = (e) => {
+            this.logger.info('ReConnectWebsocket error', e);
+        };
+        ws.onmessage = (e) => {
+            try {
+                const pushMessage = JSON.parse(e.data);
+                if (pushMessage.type === PushMessageType.PONG_MESSAGE) {
+                    if (this.pongTimeout !== null) {
+                        clearTimeout(this.pongTimeout);
+                        this.pongTimeout = null;
+                        this.delaySendPing();
+                    }
+                }
+                else {
+                    this.sendAck(pushMessage.id);
+                }
+                if (pushMessage.type === PushMessageType.BIG_PACKAGE_PUSH) {
+                    for (const item of pushMessage.content.big_push) {
+                        this.emit('message', item);
+                    }
+                }
+                else {
+                    this.emit('message', pushMessage);
+                }
+            }
+            catch (e) {
+                this.logger.error('ReConnectWebsocket message parse failed', e);
+            }
+        };
+        ws.onclose = (e) => {
+            if (e.code === 4001) {
+                // kick off
+                this.kickOff();
+            }
+            else {
+                this.reConnect();
+            }
+        };
+    }
+    reConnect() {
+        this.disconnect();
+        if (!this.destroyed) {
+            this.reConnectTimeout = setTimeout(() => {
+                this.reConnectTimeout = null;
+                this.connect();
+            }, RE_CONNECT_TIMEOUT_MS);
+        }
+    }
+    send(message) {
+        if (this.destroyed) {
+            return false;
+        }
+        if (!this.ws) {
+            this.logger.warn('ReConnectWebsocket send before connect');
+            return false;
+        }
+        try {
+            if (this.ws.readyState !== this.ws.OPEN) {
+                this.logger.warn('ReConnectWebsocket send but not open', this.ws.readyState);
+                return false;
+            }
+            this.ws.send(JSON.stringify(message));
+            return true;
+        }
+        catch (e) {
+            this.logger.warn('ReConnectWebsocket send error', e);
+            return false;
+        }
+    }
+    sendAck(id) {
+        this.send({
+            type: 1,
+            ids: [id],
+        });
+    }
+    destroy() {
+        if (this.destroyed) {
+            return;
+        }
+        this.destroyed = true;
+        this.disconnect();
+        window.removeEventListener('online', this.reConnect);
+    }
+    delaySendPing() {
+        if (this.pingTimeout !== null) {
+            clearTimeout(this.pingTimeout);
+            this.pingTimeout = null;
+        }
+        this.pingTimeout = setTimeout(() => {
+            this.pingTimeout = null;
+            const success = this.send({
+                type: 0,
+            });
+            if (success) {
+                this.waitPong();
+            }
+            else {
+                this.reConnect();
+            }
+        }, PING_TIMEOUT_MS);
+    }
+    waitPong() {
+        this.pongTimeout = setTimeout(() => {
+            this.logger.info('ReConnectWebsocket pong timeout');
+            this.reConnect();
+        }, PONG_TIMEOUT_MS);
+    }
+    kickOff() {
+        this.destroy();
+        this.emit('kickoff');
+    }
+}

package/dist-test/modules/Storage.js

@@ -0,0 +1,27 @@
+class Storage {
+    static set(value) {
+        localStorage.setItem(this.key, JSON.stringify(value));
+    }
+    static get() {
+        try {
+            const raw = localStorage.getItem(this.key);
+            if (!raw)
+                return null;
+            const data = JSON.parse(raw);
+            return data;
+        }
+        catch {
+            return null;
+        }
+    }
+    static clear() {
+        localStorage.removeItem(this.key);
+    }
+}
+Object.defineProperty(Storage, "key", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: '__typex_sdk_data__'
+});
+export default Storage;