@onyx-p/imlib-web 2.0.7 → 2.0.9

package/index.esm.js

@@ -7741,14 +7741,6 @@ const isElectron = () => {
   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) {
@@ -20937,6 +20929,607 @@ const GroupCloseBurnAfterReadingMessage = registerMessageType$1(NotiMessageTypes
 
 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 < ReceivedStatus.RECEIVED) {
+              message.receivedStatus = ReceivedStatus.RECEIVED;
+              needUpdate = true;
+            } else if (type === 1 && message.receivedStatus < ReceivedStatus.READ) {
+              message.receivedStatus = 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;
@@ -21025,6 +21618,7 @@ class LibLoader {
       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();
@@ -28373,174 +28967,6 @@ function getMessageSentTime() {
   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 < ReceivedStatus.RECEIVED) {
-            updated = true;
-            return {
-              ...message,
-              receivedStatus: ReceivedStatus.RECEIVED
-            };
-          }
-        } else {
-          if (message.receivedStatus < ReceivedStatus.READ) {
-            updated = true;
-            return {
-              ...message,
-              receivedStatus: 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;
@@ -28589,7 +29015,7 @@ class IMClient extends EventEmitter {
       },
       batchMessage: messages => {
         if (messages.length) {
-          MessageCache.get().addMessages(messages, {
+          MessageCache$1.get()?.addMessages(messages, {
             conversationType: messages[0].content,
             targetId: messages[0].targetId
           });
@@ -28620,13 +29046,13 @@ class IMClient extends EventEmitter {
         });
       },
       onRecall: messageUids => {
-        MessageCache.get().removeMessagesByUId(messageUids);
+        MessageCache$1.get()?.removeMessagesByUId(messageUids);
         messageUids.forEach(messageUId => {
           this.emit(Events.RECALL, messageUId);
         });
       },
       onReceiptReceived: (event, type) => {
-        MessageCache.get().updateMessageReceiptStatus(event, type);
+        MessageCache$1.get()?.updateMessageReceiptStatus(event, type);
         if (type === 0) {
           this.emit(Events.ARRIVAL_RECEIPT_RECEIVED, event);
         } else {
@@ -28662,7 +29088,7 @@ class IMClient extends EventEmitter {
   async recallMsg(conversation, options) {
     const result = await sendRecallMessage(conversation, options);
     if (result.code === ErrorCode.SUCCESS) {
-      MessageCache.get().removeMessagesByUId([options.messageUId]);
+      MessageCache$1.get()?.removeMessagesByUId([options.messageUId]);
     }
     return result;
   }
@@ -28704,7 +29130,8 @@ class IMClient extends EventEmitter {
     });
   }
   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]);
     }
@@ -28730,7 +29157,7 @@ class IMClient extends EventEmitter {
     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: ErrorCode.SUCCESS,
       data: {
@@ -28740,11 +29167,11 @@ class IMClient extends EventEmitter {
     };
   }
   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);
   }
@@ -28930,7 +29357,7 @@ class IMClient extends EventEmitter {
     return conversationObj;
   }
   clearBurnAfterReadingExpiredMessages(conversation) {
-    return MessageCache.get().clearBurnAfterReadingExpiredMessages(conversation);
+    return MessageCache$1.get()?.clearBurnAfterReadingExpiredMessages(conversation) ?? Promise.resolve([]);
   }
 }
 
@@ -30191,11 +30618,11 @@ const _logSendError = (conversation, errorCode) => {
     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} 条阅后即焚过期消息`);
   }