@onyx-p/imlib-web 2.0.7 → 2.0.9

package/index.umd.js

@@ -7747,14 +7747,6 @@
     return typeof process !== 'undefined' && typeof process.versions !== 'undefined' && !!process.versions.electron;
   };
   let electronStore = null;
-  if (isElectron()) {
-    try {
-      const Store = require('electron-store');
-      electronStore = new Store();
-    } catch (e) {
-      console.error('Failed to initialize electron-store:', e);
-    }
-  }
   const LocalStorageService = {
     get: function (key) {
       if (isElectron() && electronStore) {
@@ -20943,6 +20935,607 @@
 
   const RecallCommandMessage = registerMessageType$1(MessageTypes.RECALL, true, false, false);
 
+  class MessageCache {
+    static instance;
+    loadedEndMap = new Map();
+    db = null;
+    currentAppKey = '';
+    currentUserId = '';
+    APP_INFO_KEY = 'im_app_info';
+    DB_NAME_PREFIX = 'im_message_cache';
+    DB_VERSION = 2;
+    STORE_NAME = 'messages';
+    DIALOG_STATE_STORE = 'dialogStates';
+    encryptKey = {
+      key: ''
+    };
+    SALT_PREFIX = 'im_message_cache_salt_prefix';
+    SALT_SUFFIX = 'im_message_cache_salt_suffix';
+    constructor(appKey, userId) {
+      this.generateEncryptKey(appKey, userId);
+      this.init(appKey, userId);
+    }
+    generateEncryptKey(appKey, userId) {
+      const saltedInput = `${this.SALT_PREFIX}${appKey}_${userId}${this.SALT_SUFFIX}`;
+      const keyMaterial = CryptoJS.SHA256(saltedInput).toString();
+      const iv = keyMaterial.substring(0, 16);
+      const key = keyMaterial.substring(16, 48);
+      const additionalSalt = CryptoJS.SHA256(`${iv}:${this.SALT_PREFIX}:${userId}:${appKey}`).toString().substring(0, 8);
+      const finalKey = CryptoJS.PBKDF2(key, additionalSalt, {
+        keySize: 256 / 32,
+        iterations: 1000,
+        hasher: CryptoJS.algo.SHA256
+      }).toString();
+      this.encryptKey = {
+        key: finalKey.substring(0, 32),
+        iv: iv
+      };
+    }
+    async init(appKey, userId) {
+      this.currentAppKey = appKey;
+      this.currentUserId = userId;
+      await this.checkAndResetDatabase();
+      await this.initDatabase();
+    }
+    async checkAndResetDatabase() {
+      const storedInfoStr = LocalStorageService.get(this.APP_INFO_KEY);
+      if (storedInfoStr) {
+        try {
+          const storedInfo = JSON.parse(storedInfoStr);
+          if (storedInfo.appKey !== this.currentAppKey || storedInfo.userId !== this.currentUserId) {
+            await this.deleteDatabase();
+          }
+        } catch (error) {
+          console.error('解析存储的AppKey和UserId出错', error);
+          await this.deleteDatabase();
+        }
+      }
+      LocalStorageService.set(this.APP_INFO_KEY, JSON.stringify({
+        appKey: this.currentAppKey,
+        userId: this.currentUserId,
+        timestamp: Date.now()
+      }));
+    }
+    async deleteDatabase() {
+      if (this.db) {
+        this.db.close();
+        this.db = null;
+      }
+      this.loadedEndMap.clear();
+      return new Promise((resolve, reject) => {
+        const dbName = this.getDBName();
+        const deleteRequest = indexedDB.deleteDatabase(dbName);
+        deleteRequest.onsuccess = () => {
+          console.log(`数据库 ${dbName} 已成功删除`);
+          resolve();
+        };
+        deleteRequest.onerror = event => {
+          console.error(`删除数据库 ${dbName} 失败`, event);
+          resolve();
+        };
+      });
+    }
+    getDBName() {
+      return `${this.DB_NAME_PREFIX}_${this.currentAppKey}_${this.currentUserId}`;
+    }
+    initDatabase() {
+      return new Promise((resolve, reject) => {
+        const dbName = this.getDBName();
+        const request = indexedDB.open(dbName, this.DB_VERSION);
+        request.onerror = event => {
+          console.error('数据库打开失败', event);
+          reject(new Error('数据库打开失败'));
+        };
+        request.onsuccess = event => {
+          this.db = event.target.result;
+          this.loadAllDialogStates().then(() => {
+            resolve();
+          }).catch(err => {
+            console.error('加载会话状态失败', err);
+            resolve();
+          });
+        };
+        request.onupgradeneeded = event => {
+          const db = event.target.result;
+          if (!db.objectStoreNames.contains(this.STORE_NAME)) {
+            const store = db.createObjectStore(this.STORE_NAME, {
+              keyPath: 'messageUId'
+            });
+            store.createIndex('dialogId', 'dialogId', {
+              unique: false
+            });
+            store.createIndex('dialogId_sentTime', ['dialogId', 'sentTime'], {
+              unique: false
+            });
+            store.createIndex('receivedStatus', 'receivedStatus', {
+              unique: false
+            });
+            store.createIndex('burnAfterReadingFlag', 'burnAfterReadingFlag', {
+              unique: false
+            });
+            store.createIndex('dialogId_receivedStatus', ['dialogId', 'receivedStatus'], {
+              unique: false
+            });
+          }
+          if (!db.objectStoreNames.contains(this.DIALOG_STATE_STORE)) {
+            db.createObjectStore(this.DIALOG_STATE_STORE, {
+              keyPath: 'dialogId'
+            });
+          }
+        };
+      });
+    }
+    async loadAllDialogStates() {
+      if (!this.db) {
+        return;
+      }
+      return new Promise((resolve, reject) => {
+        const transaction = this.db.transaction(this.DIALOG_STATE_STORE, 'readonly');
+        const store = transaction.objectStore(this.DIALOG_STATE_STORE);
+        const request = store.getAll();
+        request.onsuccess = () => {
+          const states = request.result;
+          this.loadedEndMap.clear();
+          states.forEach(state => {
+            this.loadedEndMap.set(state.dialogId, state.isEnd);
+          });
+          resolve();
+        };
+        request.onerror = event => {
+          reject(new Error('加载会话状态失败'));
+        };
+      });
+    }
+    async updateDialogState(dialogId, isEnd) {
+      if (!this.db) {
+        return;
+      }
+      this.loadedEndMap.set(dialogId, isEnd);
+      return new Promise((resolve, reject) => {
+        const transaction = this.db.transaction(this.DIALOG_STATE_STORE, 'readwrite');
+        const store = transaction.objectStore(this.DIALOG_STATE_STORE);
+        const request = store.put({
+          dialogId,
+          isEnd,
+          updateTime: Date.now()
+        });
+        request.onsuccess = () => {
+          resolve();
+        };
+        request.onerror = event => {
+          console.error('更新会话状态失败', event);
+          reject(new Error('更新会话状态失败'));
+        };
+      });
+    }
+    encryptContent(content) {
+      if (!content) return '';
+      try {
+        const contentStr = JSON.stringify(content);
+        return aes256Encrypt(contentStr, this.encryptKey);
+      } catch (error) {
+        console.error('加密消息内容失败', error);
+        return '';
+      }
+    }
+    decryptContent(encryptedHex) {
+      if (!encryptedHex) {
+        return null;
+      }
+      try {
+        const decryptedStr = aes256Decrypt(encryptedHex, this.encryptKey);
+        return JSON.parse(decryptedStr);
+      } catch (error) {
+        console.error('解密消息内容失败', error);
+        return null;
+      }
+    }
+    async addMessages(messages, toConversation, isEnd = undefined) {
+      const dialogId = getFullDialogId(toConversation);
+      if (isDef(isEnd)) {
+        await this.updateDialogState(dialogId, isEnd);
+      }
+      if (!messages || messages.length === 0 || !this.db) {
+        return;
+      }
+      return new Promise((resolve, reject) => {
+        const transaction = this.db.transaction(this.STORE_NAME, 'readwrite');
+        const store = transaction.objectStore(this.STORE_NAME);
+        messages.forEach(message => {
+          const messageToStore = {
+            ...message,
+            dialogId
+          };
+          if (messageToStore.content) {
+            const encryptedContent = this.encryptContent(messageToStore.content);
+            messageToStore.content = encryptedContent;
+          }
+          store.put(messageToStore);
+        });
+        transaction.oncomplete = () => {
+          resolve();
+        };
+        transaction.onerror = event => {
+          console.error('添加消息事务失败', event);
+          reject(new Error('添加消息事务失败'));
+        };
+      });
+    }
+    async getPreviousMessages(conversation, timestamp = "0", count = 20) {
+      const dialogId = getFullDialogId(conversation);
+      if (!this.db) {
+        return {
+          messages: [],
+          hasMore: false
+        };
+      }
+      const isLoaded = await this.getDialogLoadedState(dialogId);
+      return new Promise((resolve, reject) => {
+        const transaction = this.db.transaction(this.STORE_NAME, 'readonly');
+        const store = transaction.objectStore(this.STORE_NAME);
+        const index = store.index('dialogId_sentTime');
+        let range;
+        const direction = 'prev';
+        if (timestamp === "0") {
+          range = IDBKeyRange.bound([dialogId, ''], [dialogId, '\uffff']);
+        } else {
+          range = IDBKeyRange.bound([dialogId, ''], [dialogId, timestamp]);
+        }
+        const messages = [];
+        let hasMoreMessages = false;
+        let processedCount = 0;
+        const countRequest = index.count(range);
+        countRequest.onsuccess = () => {
+          const totalCount = countRequest.result;
+          const cursorRequest = index.openCursor(range, direction);
+          cursorRequest.onsuccess = event => {
+            const cursor = event.target.result;
+            if (cursor) {
+              if (processedCount < count) {
+                const message = {
+                  ...cursor.value
+                };
+                if (typeof message.content === 'string' && message.content) {
+                  try {
+                    message.content = this.decryptContent(message.content);
+                  } catch (error) {
+                    console.error('解密消息内容失败', error);
+                    message.content = null;
+                  }
+                }
+                messages.push(message);
+                processedCount++;
+                cursor.continue();
+              } else {
+                hasMoreMessages = true;
+                finishQuery();
+              }
+            } else {
+              finishQuery();
+            }
+          };
+          const finishQuery = () => {
+            messages.sort((a, b) => Long.fromString(a.sentTime).compare(Long.fromString(b.sentTime)));
+            resolve({
+              messages,
+              hasMore: hasMoreMessages || totalCount > count || !isLoaded
+            });
+          };
+        };
+        transaction.onerror = event => {
+          console.error('获取消息事务失败', event);
+          reject(new Error('获取消息事务失败'));
+        };
+      });
+    }
+    async clearConversationCache(conversation) {
+      const dialogId = getFullDialogId(conversation);
+      if (!this.db) {
+        this.loadedEndMap.set(dialogId, true);
+        return;
+      }
+      const deleteMessagesPromise = new Promise((resolve, reject) => {
+        const transaction = this.db.transaction(this.STORE_NAME, 'readwrite');
+        const store = transaction.objectStore(this.STORE_NAME);
+        const index = store.index('dialogId');
+        const request = index.openCursor(IDBKeyRange.only(dialogId));
+        request.onsuccess = event => {
+          const cursor = event.target.result;
+          if (cursor) {
+            cursor.delete();
+            cursor.continue();
+          }
+        };
+        transaction.oncomplete = () => {
+          resolve();
+        };
+        transaction.onerror = event => {
+          reject(new Error('清除会话消息失败'));
+        };
+      });
+      await Promise.all([deleteMessagesPromise, this.updateDialogState(dialogId, true)]);
+    }
+    async clearAllCache() {
+      if (!this.db) {
+        this.loadedEndMap.clear();
+        return;
+      }
+      const clearMessagesPromise = new Promise((resolve, reject) => {
+        const transaction = this.db.transaction(this.STORE_NAME, 'readwrite');
+        const store = transaction.objectStore(this.STORE_NAME);
+        const request = store.clear();
+        request.onsuccess = () => {
+          resolve();
+        };
+        request.onerror = event => {
+          reject(new Error('清除所有消息失败'));
+        };
+      });
+      const clearStatesPromise = new Promise((resolve, reject) => {
+        const transaction = this.db.transaction(this.DIALOG_STATE_STORE, 'readwrite');
+        const store = transaction.objectStore(this.DIALOG_STATE_STORE);
+        const request = store.clear();
+        request.onsuccess = () => {
+          this.loadedEndMap.clear();
+          resolve();
+        };
+        request.onerror = event => {
+          reject(new Error('清除所有会话状态失败'));
+        };
+      });
+      await Promise.all([clearMessagesPromise, clearStatesPromise]);
+    }
+    async getDialogLoadedState(dialogId) {
+      if (this.loadedEndMap.has(dialogId)) {
+        return this.loadedEndMap.get(dialogId);
+      }
+      if (!this.db) {
+        return false;
+      }
+      return new Promise((resolve, reject) => {
+        const transaction = this.db.transaction(this.DIALOG_STATE_STORE, 'readonly');
+        const store = transaction.objectStore(this.DIALOG_STATE_STORE);
+        const request = store.get(dialogId);
+        request.onsuccess = () => {
+          const state = request.result;
+          if (state) {
+            this.loadedEndMap.set(dialogId, state.isEnd);
+            resolve(state.isEnd);
+          } else {
+            resolve(false);
+          }
+        };
+        request.onerror = event => {
+          resolve(false);
+        };
+      });
+    }
+    async removeMessagesByUId(messageUIds) {
+      if (!messageUIds || messageUIds.length === 0 || !this.db) {
+        return;
+      }
+      return new Promise((resolve, reject) => {
+        const transaction = this.db.transaction(this.STORE_NAME, 'readwrite');
+        const store = transaction.objectStore(this.STORE_NAME);
+        let completed = 0;
+        let hasError = false;
+        messageUIds.forEach(id => {
+          const deleteRequest = store.delete(id);
+          deleteRequest.onsuccess = () => {
+            completed++;
+            if (completed === messageUIds.length && !hasError) {
+              resolve();
+            }
+          };
+          deleteRequest.onerror = event => {
+            console.error('删除消息失败', id, event);
+            if (!hasError) {
+              hasError = true;
+              reject(new Error('删除消息失败'));
+            }
+          };
+        });
+        transaction.oncomplete = () => {
+          if (!hasError) {
+            resolve();
+          }
+        };
+        transaction.onerror = event => {
+          reject(new Error('批量删除消息事务失败'));
+        };
+      });
+    }
+    async updateMessageReceiptStatus(event, type) {
+      if (!event || !event.messageUIdList || event.messageUIdList.length === 0 || !this.db) {
+        return;
+      }
+      const {
+        conversation
+      } = event;
+      getFullDialogId(conversation);
+      return new Promise((resolve, reject) => {
+        const transaction = this.db.transaction(this.STORE_NAME, 'readwrite');
+        const store = transaction.objectStore(this.STORE_NAME);
+        let completed = 0;
+        let hasError = false;
+        event.messageUIdList.forEach(id => {
+          const getRequest = store.get(id);
+          getRequest.onsuccess = () => {
+            const message = getRequest.result;
+            if (message) {
+              let needUpdate = false;
+              if (type === 0 && message.receivedStatus < exports.ReceivedStatus.RECEIVED) {
+                message.receivedStatus = exports.ReceivedStatus.RECEIVED;
+                needUpdate = true;
+              } else if (type === 1 && message.receivedStatus < exports.ReceivedStatus.READ) {
+                message.receivedStatus = exports.ReceivedStatus.READ;
+                needUpdate = true;
+              }
+              if (needUpdate) {
+                store.put(message);
+              }
+            }
+            completed++;
+            if (completed === event.messageUIdList.length && !hasError) {
+              resolve();
+            }
+          };
+          getRequest.onerror = event => {
+            if (!hasError) {
+              hasError = true;
+              reject(new Error('更新消息状态失败'));
+            }
+          };
+        });
+        transaction.oncomplete = () => {
+          if (!hasError) {
+            resolve();
+          }
+        };
+        transaction.onerror = event => {
+          reject(new Error('更新消息状态事务失败'));
+        };
+      });
+    }
+    async clearBurnAfterReadingExpiredMessages(conversation) {
+      const dialogId = getFullDialogId(conversation);
+      if (!this.db) {
+        return [];
+      }
+      const currentTime = Date.now();
+      return new Promise((resolve, reject) => {
+        const transaction = this.db.transaction(this.STORE_NAME, 'readwrite');
+        const store = transaction.objectStore(this.STORE_NAME);
+        const index = store.index('dialogId');
+        const expiredMessageUIds = [];
+        const request = index.openCursor(IDBKeyRange.only(dialogId));
+        request.onsuccess = event => {
+          const cursor = event.target.result;
+          if (cursor) {
+            const message = cursor.value;
+            if (message.burnAfterReadingFlag) {
+              const burnTime = message.burnAfterReadingTime || 0;
+              let isExpired = burnTime === 0;
+              if (!isExpired && burnTime > 0) {
+                const sentTimeLong = Long.fromString(message.sentTime);
+                const currentTimeLong = Long.fromNumber(currentTime);
+                const burnTimeLong = Long.fromNumber(burnTime);
+                const expirationTime = sentTimeLong.add(burnTimeLong);
+                isExpired = currentTimeLong.greaterThan(expirationTime);
+              }
+              if (isExpired) {
+                expiredMessageUIds.push(message.messageUId);
+                cursor.delete();
+              }
+            }
+            cursor.continue();
+          } else {
+            resolve(expiredMessageUIds);
+          }
+        };
+        request.onerror = event => {
+          console.error('清除过期消息失败', event);
+          reject(new Error('清除过期消息失败'));
+        };
+      });
+    }
+    async getMessagesByPage(dialogId, pageSize = 20, cursorPosition = null) {
+      if (!this.db) {
+        return {
+          messages: [],
+          nextCursor: null
+        };
+      }
+      return new Promise((resolve, reject) => {
+        const transaction = this.db.transaction(this.STORE_NAME, 'readonly');
+        const store = transaction.objectStore(this.STORE_NAME);
+        const index = store.index('dialogId_sentTime');
+        const range = IDBKeyRange.bound([dialogId, cursorPosition || ''], [dialogId, '\uffff']);
+        const messages = [];
+        let nextCursor = null;
+        let count = 0;
+        const cursorRequest = index.openCursor(range);
+        cursorRequest.onsuccess = event => {
+          const cursor = event.target.result;
+          if (cursor && count < pageSize) {
+            messages.push(cursor.value);
+            count++;
+            cursor.continue();
+          } else if (cursor) {
+            nextCursor = cursor.value.sentTime;
+          } else {
+            nextCursor = null;
+          }
+          if (!cursor || count >= pageSize) {
+            resolve({
+              messages,
+              nextCursor
+            });
+          }
+        };
+        cursorRequest.onerror = event => {
+          reject(new Error('获取分页消息失败'));
+        };
+      });
+    }
+    async updateMessagesStatus(messageUIds, newStatus) {
+      if (!this.db || messageUIds.length === 0) {
+        return;
+      }
+      return new Promise((resolve, reject) => {
+        const transaction = this.db.transaction(this.STORE_NAME, 'readwrite');
+        const store = transaction.objectStore(this.STORE_NAME);
+        let completed = 0;
+        let hasError = false;
+        messageUIds.forEach(id => {
+          const getRequest = store.get(id);
+          getRequest.onsuccess = () => {
+            const message = getRequest.result;
+            if (message) {
+              message.receivedStatus = newStatus;
+              store.put(message);
+            }
+            completed++;
+            if (completed === messageUIds.length && !hasError) {
+              resolve();
+            }
+          };
+          getRequest.onerror = event => {
+            if (!hasError) {
+              hasError = true;
+              reject(new Error('更新消息状态失败'));
+            }
+          };
+        });
+        transaction.oncomplete = () => {
+          resolve();
+        };
+        transaction.onerror = event => {
+          reject(new Error('批量更新事务失败'));
+        };
+      });
+    }
+    async changeUser(appKey, userId) {
+      if (this.currentAppKey === appKey && this.currentUserId === userId) {
+        return;
+      }
+      this.currentAppKey = appKey;
+      this.currentUserId = userId;
+      this.generateEncryptKey(appKey, userId);
+      await this.checkAndResetDatabase();
+      await this.initDatabase();
+    }
+  }
+  let cache;
+  var MessageCache$1 = {
+    create(appkey, currentUserId) {
+      cache = new MessageCache(appkey, currentUserId);
+    },
+    get() {
+      return cache;
+    }
+  };
+
   const DEFAULT_SOCKET_URI = 'wss://imweb.mp.net:6443';
   class LibLoader {
     options;
@@ -21031,6 +21624,7 @@
         ConversationManager$1.get().destroyed();
         ConversationManager$1.create(this.options.appkey, accountStore.uid.toString(), this.watcher.conversationState);
         MessageReceiptManager$1.create(this.options.appkey, accountStore.uid.toString());
+        MessageCache$1.create(this.options.appkey, accountStore.uid.toString());
         this.messageLoader?.stop();
         this.messageLoader = new MessageLoader(this.watcher, this.options);
         synchronizeServerTime();
@@ -28379,174 +28973,6 @@
     return UniqueSentTime;
   }
 
-  class MessageCache {
-    static instance;
-    messageCache = new Map();
-    loadedEndMap = new Map();
-    maxCacheCount = 1000;
-    constructor() {}
-    static get() {
-      if (!MessageCache.instance) {
-        MessageCache.instance = new MessageCache();
-      }
-      return MessageCache.instance;
-    }
-    setMaxCacheCount(count) {
-      if (count > 0) {
-        this.maxCacheCount = count;
-      }
-    }
-    addMessages(messages, toConversation, isEnd = undefined) {
-      const dialogId = getFullDialogId(toConversation);
-      if (isDef(isEnd)) {
-        this.loadedEndMap.set(dialogId, isEnd);
-      }
-      if (!messages || messages.length === 0) {
-        return;
-      }
-      if (!this.messageCache.has(dialogId)) {
-        this.messageCache.set(dialogId, []);
-      }
-      const cachedMessages = this.messageCache.get(dialogId) || [];
-      const existingMessageIds = new Set(cachedMessages.map(msg => msg.messageUId));
-      const newMessages = messages.filter(msg => !existingMessageIds.has(msg.messageUId));
-      const allMessages = [...cachedMessages, ...newMessages].sort((a, b) => Long.fromString(a.sentTime).compare(Long.fromString(b.sentTime)));
-      if (allMessages.length > this.maxCacheCount) {
-        allMessages.splice(0, allMessages.length - this.maxCacheCount);
-      }
-      this.messageCache.set(dialogId, allMessages);
-    }
-    getPreviousMessages(conversation, timestamp = "0", count = 20) {
-      const dialogId = getFullDialogId(conversation);
-      const cachedMessages = this.messageCache.get(dialogId) || [];
-      if (cachedMessages.length === 0) {
-        return {
-          messages: [],
-          hasMore: !this.loadedEndMap.get(dialogId)
-        };
-      }
-      if (timestamp === "0") {
-        const messages = cachedMessages.slice(-count);
-        return {
-          messages,
-          hasMore: cachedMessages.length > count || !this.loadedEndMap.get(dialogId)
-        };
-      }
-      const timestampLong = Long.fromString(timestamp);
-      let endIndex = cachedMessages.length - 1;
-      while (endIndex >= 0) {
-        if (Long.fromString(cachedMessages[endIndex].sentTime).lessThanOrEqual(timestampLong)) {
-          break;
-        }
-        endIndex--;
-      }
-      if (endIndex < 0) {
-        return {
-          messages: [],
-          hasMore: !this.loadedEndMap.get(dialogId)
-        };
-      }
-      const startIndex = Math.max(0, endIndex - count + 1);
-      return {
-        messages: cachedMessages.slice(startIndex, endIndex + 1),
-        hasMore: startIndex > 0 || !this.loadedEndMap.get(dialogId)
-      };
-    }
-    clearConversationCache(conversation) {
-      const dialogId = getFullDialogId(conversation);
-      this.messageCache.delete(dialogId);
-      this.loadedEndMap.set(dialogId, true);
-    }
-    clearAllCache() {
-      this.messageCache.clear();
-      this.loadedEndMap.clear();
-    }
-    removeMessagesByUId(messageUIds) {
-      if (!messageUIds || messageUIds.length === 0) {
-        return;
-      }
-      const messageUIdSet = new Set(messageUIds);
-      this.messageCache.forEach((messages, dialogId) => {
-        const filteredMessages = messages.filter(msg => !messageUIdSet.has(msg.messageUId));
-        if (filteredMessages.length !== messages.length) {
-          this.messageCache.set(dialogId, filteredMessages);
-        }
-      });
-    }
-    updateMessageReceiptStatus(event, type) {
-      if (!event || !event.messageUIdList || event.messageUIdList.length === 0) {
-        return;
-      }
-      const {
-        conversation
-      } = event;
-      const dialogId = getFullDialogId(conversation);
-      const cachedMessages = this.messageCache.get(dialogId);
-      if (!cachedMessages || cachedMessages.length === 0) {
-        return;
-      }
-      const messageUIdSet = new Set(event.messageUIdList);
-      let updated = false;
-      const updatedMessages = cachedMessages.map((message, index) => {
-        if (messageUIdSet.has(message.messageUId)) {
-          if (type === 0) {
-            if (message.receivedStatus < exports.ReceivedStatus.RECEIVED) {
-              updated = true;
-              return {
-                ...message,
-                receivedStatus: exports.ReceivedStatus.RECEIVED
-              };
-            }
-          } else {
-            if (message.receivedStatus < exports.ReceivedStatus.READ) {
-              updated = true;
-              return {
-                ...message,
-                receivedStatus: exports.ReceivedStatus.READ
-              };
-            }
-          }
-        }
-        return message;
-      });
-      if (updated) {
-        this.messageCache.set(dialogId, updatedMessages);
-      }
-    }
-    clearBurnAfterReadingExpiredMessages(conversation) {
-      const dialogId = getFullDialogId(conversation);
-      const cachedMessages = this.messageCache.get(dialogId);
-      if (!cachedMessages || cachedMessages.length === 0) {
-        return [];
-      }
-      const currentTime = Date.now();
-      const expiredMessageUIds = [];
-      const remainingMessages = cachedMessages.filter(message => {
-        if (!message.burnAfterReadingFlag) {
-          return true;
-        }
-        const burnTime = message.burnAfterReadingTime || 0;
-        if (burnTime === 0) {
-          expiredMessageUIds.push(message.messageUId);
-          return false;
-        }
-        const sentTimeLong = Long.fromString(message.sentTime);
-        const currentTimeLong = Long.fromNumber(currentTime);
-        const burnTimeLong = Long.fromNumber(burnTime);
-        const expirationTime = sentTimeLong.add(burnTimeLong);
-        if (currentTimeLong.greaterThan(expirationTime)) {
-          expiredMessageUIds.push(message.messageUId);
-          return false;
-        }
-        return true;
-      });
-      if (remainingMessages.length < cachedMessages.length) {
-        this.messageCache.set(dialogId, remainingMessages);
-      }
-      return expiredMessageUIds;
-    }
-  }
-
   class IMClient extends EventEmitter {
     options;
     static imClient;
@@ -28595,7 +29021,7 @@
         },
         batchMessage: messages => {
           if (messages.length) {
-            MessageCache.get().addMessages(messages, {
+            MessageCache$1.get()?.addMessages(messages, {
               conversationType: messages[0].content,
               targetId: messages[0].targetId
             });
@@ -28626,13 +29052,13 @@
           });
         },
         onRecall: messageUids => {
-          MessageCache.get().removeMessagesByUId(messageUids);
+          MessageCache$1.get()?.removeMessagesByUId(messageUids);
           messageUids.forEach(messageUId => {
             this.emit(exports.Events.RECALL, messageUId);
           });
         },
         onReceiptReceived: (event, type) => {
-          MessageCache.get().updateMessageReceiptStatus(event, type);
+          MessageCache$1.get()?.updateMessageReceiptStatus(event, type);
           if (type === 0) {
             this.emit(exports.Events.ARRIVAL_RECEIPT_RECEIVED, event);
           } else {
@@ -28668,7 +29094,7 @@
     async recallMsg(conversation, options) {
       const result = await sendRecallMessage(conversation, options);
       if (result.code === exports.ErrorCode.SUCCESS) {
-        MessageCache.get().removeMessagesByUId([options.messageUId]);
+        MessageCache$1.get()?.removeMessagesByUId([options.messageUId]);
       }
       return result;
     }
@@ -28710,7 +29136,8 @@
       });
     }
     async getPreviousHistoryMessages(conversation, timestamp, count = 20) {
-      const cachedResult = MessageCache.get().getPreviousMessages(conversation, timestamp ?? '0', count);
+      debugger;
+      const cachedResult = await MessageCache$1.get().getPreviousMessages(conversation, timestamp ?? '0', count);
       if (!timestamp && cachedResult.messages.length) {
         ConversationManager$1.get().refreshLatestMessage(conversation, cachedResult.messages[cachedResult.messages.length - 1]);
       }
@@ -28736,7 +29163,7 @@
       if (!remotesTimestamp) {
         ConversationManager$1.get().refreshLatestMessage(conversation, remotesMessages[remotesMessages.length - 1]);
       }
-      MessageCache.get().addMessages(remotesMessages, conversation, !remotesResult.data.hasMore);
+      MessageCache$1.get().addMessages(remotesMessages, conversation, !remotesResult.data.hasMore);
       return {
         code: exports.ErrorCode.SUCCESS,
         data: {
@@ -28746,11 +29173,11 @@
       };
     }
     async deleteRemoteMessage(conversation, list) {
-      MessageCache.get().removeMessagesByUId(list.map(e => e.messageUId));
+      MessageCache$1.get()?.removeMessagesByUId(list.map(e => e.messageUId));
       return deleteMessages$1(getFullDialogId(conversation), list.map(e => e.messageUId)).then(result => result.code);
     }
     async deleteRemoteMessageByTimestamp(conversation, timestamp) {
-      MessageCache.get().clearConversationCache(conversation);
+      MessageCache$1.get()?.clearConversationCache(conversation);
       ConversationManager$1.get().clearHistoryMessages(conversation);
       return clearHistoryMessage(getFullDialogId(conversation), timestamp === 0 ? Number.MAX_VALUE : timestamp).then(result => result.code);
     }
@@ -28936,7 +29363,7 @@
       return conversationObj;
     }
     clearBurnAfterReadingExpiredMessages(conversation) {
-      return MessageCache.get().clearBurnAfterReadingExpiredMessages(conversation);
+      return MessageCache$1.get()?.clearBurnAfterReadingExpiredMessages(conversation) ?? Promise.resolve([]);
     }
   }
 
@@ -30197,11 +30624,11 @@
       logger.warn('send message fail ->' + errorCode + ':' + ErrorDesc(errorCode) + ',' + paramsStr);
     }
   };
-  const clearBurnAfterReadingExpiredMessages = conversation => {
+  const clearBurnAfterReadingExpiredMessages = async conversation => {
     assert('conversation', conversation, AssertRules.CONVERSATION, true);
     const paramsStr = 'conversationType:' + conversation.conversationType + ',targetId:' + conversation.targetId;
     logger.debug('clear burn after reading expired messages ->' + paramsStr);
-    const expiredMessageUIds = imClient.clearBurnAfterReadingExpiredMessages(conversation);
+    const expiredMessageUIds = await imClient.clearBurnAfterReadingExpiredMessages(conversation);
     if (expiredMessageUIds.length > 0) {
       logger.debug(`已清除会话 ${paramsStr} 中的 ${expiredMessageUIds.length} 条阅后即焚过期消息`);
     }