@onyx-p/imlib-web 2.4.5 → 2.4.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/index.esm.js +191 -154
  2. package/index.umd.js +191 -154
  3. package/package.json +1 -1
package/index.esm.js CHANGED
@@ -19491,24 +19491,28 @@ class DialogSecretKey {
19491
19491
  if (!dialogIdList.length) {
19492
19492
  return new Map();
19493
19493
  }
19494
- const {
19495
- code,
19496
- data
19497
- } = await getDialogKey(dialogIdList.map(e => Long.fromString(e)));
19498
- if (code === ErrorCode.SUCCESS) {
19499
- const content = new Map();
19500
- for (const k in data.entry) {
19501
- const v = data.entry[k];
19502
- if (v.aesKey?.length && v.aesIV?.length) {
19503
- const keyItem = {
19504
- key: v.aesKey,
19505
- iv: v.aesIV
19506
- };
19507
- content.set(k, keyItem);
19508
- this.aesKeyRecord.set(k, keyItem);
19494
+ try {
19495
+ const {
19496
+ code,
19497
+ data
19498
+ } = await getDialogKey(dialogIdList.map(e => Long.fromString(e)));
19499
+ if (code === ErrorCode.SUCCESS) {
19500
+ const content = new Map();
19501
+ for (const k in data.entry) {
19502
+ const v = data.entry[k];
19503
+ if (v.aesKey?.length && v.aesIV?.length) {
19504
+ const keyItem = {
19505
+ key: v.aesKey,
19506
+ iv: v.aesIV
19507
+ };
19508
+ content.set(k, keyItem);
19509
+ this.aesKeyRecord.set(k, keyItem);
19510
+ }
19509
19511
  }
19512
+ return content;
19510
19513
  }
19511
- return content;
19514
+ } catch (error) {
19515
+ logger.error('getDialogAesKeyListFromRemote error', error);
19512
19516
  }
19513
19517
  return new Map();
19514
19518
  }
@@ -20132,14 +20136,6 @@ class ConversationManager {
20132
20136
  val: newLocalConversation.unreadMentionedCount
20133
20137
  };
20134
20138
  }
20135
- if (isPersited) {
20136
- updateConOptions.conversation.updateTime = parseInt(message.sentTime);
20137
- updateConOptions.conversation.latestMessage = message;
20138
- updateConOptions.updatedItems.latestMessage = {
20139
- time: parseInt(message.sentTime),
20140
- val: message
20141
- };
20142
- }
20143
20139
  if (Object.keys(updateConOptions.updatedItems).length) {
20144
20140
  this.setUpdatedConversation(updateConOptions);
20145
20141
  }
@@ -20435,15 +20431,22 @@ function parse(orginalMsgs, callback) {
20435
20431
  }
20436
20432
  const remainDialogIds = new Set([...msgs.keys()]);
20437
20433
  DialogSecretKey$1.getDialogAesKeyListInBatches([...msgs.keys()], (remote, aesKeys) => {
20438
- if (aesKeys.size) {
20439
- const dialogIds = [...aesKeys.keys()];
20440
- for (const k of dialogIds) {
20441
- remainDialogIds.delete(k);
20434
+ try {
20435
+ if (aesKeys.size) {
20436
+ const dialogIds = [...aesKeys.keys()];
20437
+ for (const k of dialogIds) {
20438
+ remainDialogIds.delete(k);
20439
+ }
20440
+ callback(!remainDialogIds.size, parseDialogsMessages(dialogIds, msgs, aesKeys));
20441
+ }
20442
+ if (remainDialogIds.size && remote) {
20443
+ callback(true, new Map());
20444
+ }
20445
+ } catch (error) {
20446
+ logger.error('parseDialogsMessages error', error);
20447
+ if (remainDialogIds.size && remote) {
20448
+ callback(true, new Map());
20442
20449
  }
20443
- callback(!remainDialogIds.size, parseDialogsMessages(dialogIds, msgs, aesKeys));
20444
- }
20445
- if (remainDialogIds.size && remote) {
20446
- callback(true, new Map());
20447
20450
  }
20448
20451
  });
20449
20452
  }
@@ -20506,7 +20509,11 @@ const parseSingleDialogMessages = (dialogId, originalMessageList, aesKey) => {
20506
20509
  if (receivedMessage.isStatusMessage && Long.fromNumber(getServerTime$1()).subtract(receivedMessage.sentTime).greaterThan(STATUSMESSAGE_ALIVE_TIMEMS)) {
20507
20510
  return;
20508
20511
  }
20509
- contentList.push(receivedMessage);
20512
+ if (notEmptyString(receivedMessage.messageUId)) {
20513
+ contentList.push(receivedMessage);
20514
+ } else {
20515
+ logger.error('message is invalid', item);
20516
+ }
20510
20517
  }
20511
20518
  });
20512
20519
  return contentList;
@@ -21301,29 +21308,55 @@ class MessageCache {
21301
21308
  if (!messageUIds || messageUIds.length === 0 || !this.db) {
21302
21309
  return;
21303
21310
  }
21304
- const transaction = this.db.transaction(this.STORE_NAME, 'readwrite');
21305
- const store = transaction.objectStore(this.STORE_NAME);
21306
- const index = store.index('messageUId');
21307
- messageUIds.forEach(messageUId => {
21308
- const request = index.get(messageUId);
21309
- request.onsuccess = () => {
21310
- const message = request.result;
21311
- if (message) {
21312
- const recallContent = {
21313
- messageUId: messageUId
21314
- };
21315
- const updatedMessage = {
21316
- ...message,
21317
- messageType: MessageTypes.RECALL,
21318
- content: this.encryptContent(recallContent)
21319
- };
21320
- store.put(updatedMessage);
21311
+ return new Promise(resolve => {
21312
+ const transaction = this.db.transaction(this.STORE_NAME, 'readwrite');
21313
+ const store = transaction.objectStore(this.STORE_NAME);
21314
+ const index = store.index('messageUId');
21315
+ let pendingRequests = messageUIds.length;
21316
+ for (const messageUId of messageUIds) {
21317
+ const request = index.get(messageUId);
21318
+ request.onsuccess = () => {
21319
+ const message = request.result;
21320
+ if (message) {
21321
+ const recallContent = {
21322
+ messageUId: messageUId
21323
+ };
21324
+ const updatedMessage = {
21325
+ ...message,
21326
+ messageType: MessageTypes.RECALL,
21327
+ content: this.encryptContent(recallContent)
21328
+ };
21329
+ const putRequest = store.put(updatedMessage);
21330
+ putRequest.onerror = () => {
21331
+ checkComplete();
21332
+ };
21333
+ putRequest.onsuccess = () => {
21334
+ checkComplete();
21335
+ };
21336
+ } else {
21337
+ checkComplete();
21338
+ }
21339
+ };
21340
+ request.onerror = () => {
21341
+ checkComplete();
21342
+ };
21343
+ }
21344
+ function checkComplete() {
21345
+ pendingRequests--;
21346
+ if (pendingRequests === 0) {
21347
+ resolve();
21321
21348
  }
21349
+ }
21350
+ transaction.oncomplete = () => {
21351
+ resolve();
21352
+ };
21353
+ transaction.onerror = () => {
21354
+ resolve();
21322
21355
  };
21323
21356
  });
21324
21357
  }
21325
21358
  }
21326
- let cache;
21359
+ let cache = null;
21327
21360
  var MessageCache$1 = {
21328
21361
  create(appkey, currentUserId) {
21329
21362
  cache = new MessageCache(appkey, currentUserId);
@@ -21427,101 +21460,124 @@ class MessageLoader {
21427
21460
  };
21428
21461
  });
21429
21462
  await ConversationManager$1.get().loadConvsationsIfNotExist(cons);
21430
- serverMessageParser.parse(msg, (done, outputMsgs) => {
21431
- const messages = [];
21432
- let recallMessageUIds = [];
21433
- const recallMessageIndexes = [];
21434
- const isOffLineMessage = !this.pullOfflineFinished;
21435
- outputMsgs.forEach((l, dialogId) => {
21436
- let messageList = [];
21437
- l.forEach(m => {
21438
- if (m.messageType === MessageTypes.RECALL && RecallMessageStore.has(m.content.messageUId)) {
21439
- if (m.content.messageUId) {
21440
- RecallMessageStore.remove(m.content.messageUId);
21441
- recallMessageUIds.push(m.content.messageUId);
21442
- } else {
21443
- logger.error('recall messageUId is undefined', m);
21444
- }
21445
- } else if (m.messageUId) {
21446
- m.isOffLineMessage = isOffLineMessage;
21447
- if (!m.messageId || m.messageId > getCurrentMessageId()) {
21448
- m.messageId = generateNewMessageId();
21449
- }
21450
- ConversationManager$1.get().setConversationCacheByMessage(m);
21451
- messageList.push(m);
21452
- if (m.messageType === MessageTypes.RECALL) {
21453
- recallMessageIndexes.push(messageList.length - 1);
21463
+ serverMessageParser.parse(msg, async (done, outputMsgs) => {
21464
+ try {
21465
+ for (const [dialogId, l] of outputMsgs.entries()) {
21466
+ if (l.length === 0) {
21467
+ return;
21468
+ }
21469
+ await this.processMessages(l, !this.pullOfflineFinished);
21470
+ }
21471
+ } catch (error) {
21472
+ logger.error('processMessages error', error);
21473
+ }
21474
+ if (done) {
21475
+ try {
21476
+ let seqNo_long;
21477
+ if (seqno) {
21478
+ if (Long.isLong(seqno)) {
21479
+ seqNo_long = seqno;
21480
+ } else if (typeof seqno === 'string') {
21481
+ seqNo_long = Long.fromString(seqno);
21482
+ } else if (typeof seqno === 'number') {
21483
+ seqNo_long = Long.fromNumber(seqno);
21454
21484
  }
21455
- } else {
21456
- logger.error('messageUId is undefined', m);
21457
21485
  }
21458
- if ([NotiMessageTypes.PRIVATE_OPEN_BURNAFTERREADING, NotiMessageTypes.GROUP_OPEN_BURNAFTERREADING, NotiMessageTypes.PRIVATE_CLOSE_BURNAFTERREADING, NotiMessageTypes.GROUP_CLOSE_BURNAFTERREADING].includes(m.messageType)) {
21459
- this.handleBurnAfterReadingMessage(m);
21486
+ if (seqNo_long && Long.isLong(seqNo_long) && seqNo_long.ge(this.serverMsgSeqno)) {
21487
+ this.serverMsgSeqno = seqNo_long;
21460
21488
  }
21461
- });
21462
- let deletedMessageIndexes = [];
21463
- for (let i = recallMessageIndexes.length - 1; i >= 0; i--) {
21464
- const index = recallMessageIndexes[i];
21465
- const recallMessage = messageList[index];
21466
- const recallContent = recallMessage.content;
21467
- const messageIndex = messageList.findIndex(m => m.messageUId === recallContent.messageUId);
21468
- if (messageIndex !== -1) {
21469
- deletedMessageIndexes.push(messageIndex);
21470
- } else {
21471
- recallMessageUIds.push(recallContent.messageUId);
21472
- deletedMessageIndexes.push(index);
21489
+ const isFinished = this.serverMsgSeqno.lessThanOrEqual(offset);
21490
+ logger.info(`pullMsg success -> syncTime: ${offset}, finished: ${isFinished}`);
21491
+ this.letterbox?.setInboxOffset(offset);
21492
+ this.pullingMsg = false;
21493
+ if (isFinished && !this.pullOfflineFinished) {
21494
+ this.pullOfflineFinished = true;
21495
+ this.watcher.pullFinished && this.watcher.pullFinished();
21473
21496
  }
21497
+ if (!isFinished) {
21498
+ this.pullMsg();
21499
+ }
21500
+ } catch (error) {
21501
+ logger.error('setPullMsgDone error', error);
21502
+ this.pullingMsg = false;
21474
21503
  }
21475
- if (deletedMessageIndexes.length) {
21476
- let messageList_tmp = [];
21477
- messageList.forEach((m, index) => {
21478
- if (!deletedMessageIndexes.includes(index)) {
21479
- messageList_tmp.push(m);
21480
- }
21481
- });
21482
- messageList = messageList_tmp;
21483
- }
21484
- messages.push(...messageList);
21485
- if (this.isExistPersistedMessage(messageList)) {
21486
- splitFullDialog(dialogId);
21487
- }
21488
- });
21489
- let normalMessages = this.handleReceiptMessages(messages);
21490
- if (normalMessages.length) {
21491
- this.handleBatchMessages(normalMessages);
21492
- MessageReceiptManager$1.get()?.sendArrivalReceipts(normalMessages);
21493
- }
21494
- if (recallMessageUIds.length) {
21495
- MessageCache$1.get()?.convertToRecallMessages(recallMessageUIds);
21496
- this.watcher.onRecall?.(recallMessageUIds);
21497
21504
  }
21498
- if (done) {
21499
- let seqNo_long;
21500
- if (seqno) {
21501
- if (Long.isLong(seqno)) {
21502
- seqNo_long = seqno;
21503
- } else if (typeof seqno === 'string') {
21504
- seqNo_long = Long.fromString(seqno);
21505
- } else if (typeof seqno === 'number') {
21506
- seqNo_long = Long.fromNumber(seqno);
21507
- }
21505
+ });
21506
+ }
21507
+ async processMessages(l, isOffLineMessage) {
21508
+ const conversation = {
21509
+ conversationType: l[0].conversationType,
21510
+ targetId: l[0].targetId
21511
+ };
21512
+ let messageList = [];
21513
+ const recallMessageIndexes = [];
21514
+ let recallMessageUIds = [];
21515
+ l.forEach(m => {
21516
+ if (m.messageType === MessageTypes.RECALL && RecallMessageStore.has(m.content.messageUId)) {
21517
+ if (m.content.messageUId) {
21518
+ RecallMessageStore.remove(m.content.messageUId);
21519
+ recallMessageUIds.push(m.content.messageUId);
21520
+ } else {
21521
+ logger.error('recallMessage’s messageUId is undefined', m);
21508
21522
  }
21509
- if (seqNo_long && Long.isLong(seqNo_long) && seqNo_long.ge(this.serverMsgSeqno)) {
21510
- this.serverMsgSeqno = seqNo_long;
21523
+ } else if (m.messageUId) {
21524
+ m.isOffLineMessage = isOffLineMessage;
21525
+ if (!m.messageId || m.messageId > getCurrentMessageId()) {
21526
+ m.messageId = generateNewMessageId();
21511
21527
  }
21512
- const isFinished = this.serverMsgSeqno.lessThanOrEqual(offset);
21513
- logger.info(`pullMsg success -> syncTime: ${offset}, finished: ${isFinished}`);
21514
- this.letterbox?.setInboxOffset(offset);
21515
- this.pullingMsg = false;
21516
- if (isFinished && !this.pullOfflineFinished) {
21517
- this.pullOfflineFinished = true;
21518
- this.watcher.pullFinished && this.watcher.pullFinished();
21528
+ ConversationManager$1.get().setConversationCacheByMessage(m);
21529
+ messageList.push(m);
21530
+ if (m.messageType === MessageTypes.RECALL) {
21531
+ recallMessageIndexes.push(messageList.length - 1);
21519
21532
  }
21520
- if (!isFinished) {
21521
- this.pullMsg();
21533
+ if ([NotiMessageTypes.PRIVATE_OPEN_BURNAFTERREADING, NotiMessageTypes.GROUP_OPEN_BURNAFTERREADING, NotiMessageTypes.PRIVATE_CLOSE_BURNAFTERREADING, NotiMessageTypes.GROUP_CLOSE_BURNAFTERREADING].includes(m.messageType)) {
21534
+ this.handleBurnAfterReadingMessage(m);
21522
21535
  }
21536
+ } else {
21537
+ logger.error('message‘s messageUId is undefined', m);
21523
21538
  }
21524
21539
  });
21540
+ let deletedMessageIndexes = [];
21541
+ for (let i = recallMessageIndexes.length - 1; i >= 0; i--) {
21542
+ const index = recallMessageIndexes[i];
21543
+ const recallMessage = messageList[index];
21544
+ const recallContent = recallMessage.content;
21545
+ const messageIndex = messageList.findIndex(m => m.messageUId === recallContent.messageUId);
21546
+ if (messageIndex !== -1) {
21547
+ deletedMessageIndexes.push(index);
21548
+ const targetMessage = messageList[messageIndex];
21549
+ messageList[messageIndex] = recallMessage;
21550
+ messageList[index] = targetMessage;
21551
+ deletedMessageIndexes.push(index);
21552
+ } else {
21553
+ recallMessageUIds.push(recallContent.messageUId);
21554
+ deletedMessageIndexes.push(index);
21555
+ }
21556
+ }
21557
+ if (deletedMessageIndexes.length) {
21558
+ let messageList_tmp = [];
21559
+ messageList.forEach((m, index) => {
21560
+ if (!deletedMessageIndexes.includes(index)) {
21561
+ messageList_tmp.push(m);
21562
+ }
21563
+ });
21564
+ messageList = messageList_tmp;
21565
+ }
21566
+ let normalMessages = this.handleReceiptMessages(messageList);
21567
+ if (normalMessages.length) {
21568
+ await MessageCache$1.get()?.addMessages(normalMessages, {
21569
+ conversationType: normalMessages[0].conversationType,
21570
+ targetId: normalMessages[0].targetId
21571
+ });
21572
+ this.handleBatchMessages(normalMessages);
21573
+ MessageReceiptManager$1.get()?.sendArrivalReceipts(normalMessages);
21574
+ }
21575
+ if (recallMessageUIds.length) {
21576
+ await MessageCache$1.get()?.convertToRecallMessages(recallMessageUIds);
21577
+ this.watcher.onRecall?.(recallMessageUIds);
21578
+ }
21579
+ const latestMessage = await MessageCache$1.get()?.getLatestMessage(conversation);
21580
+ ConversationManager$1.get().updateLatestMessage(conversation, latestMessage);
21525
21581
  }
21526
21582
  handleBurnAfterReadingMessage(message) {
21527
21583
  const content = message.content;
@@ -21577,23 +21633,7 @@ class MessageLoader {
21577
21633
  return [];
21578
21634
  }
21579
21635
  }
21580
- handleBatchMessages(messages) {
21581
- if (messages.length) {
21582
- const targetGroups = new Map();
21583
- messages.forEach(message => {
21584
- if (!targetGroups.has(message.targetId)) {
21585
- targetGroups.set(message.targetId, []);
21586
- }
21587
- targetGroups.get(message.targetId).push(message);
21588
- });
21589
- targetGroups.forEach((targetMessages, targetId) => {
21590
- const conversationType = targetMessages[0].conversationType;
21591
- MessageCache$1.get()?.addMessages(targetMessages, {
21592
- conversationType,
21593
- targetId
21594
- });
21595
- });
21596
- }
21636
+ async handleBatchMessages(messages) {
21597
21637
  const filteredMessages = messages.filter(m => {
21598
21638
  if (m.messageDirection === MessageDirection.SEND && m.messageId && SentMessageStore.has(m.messageId)) {
21599
21639
  SentMessageStore.remove(m.messageId);
@@ -21605,9 +21645,6 @@ class MessageLoader {
21605
21645
  this.watcher.batchMessage?.(filteredMessages);
21606
21646
  }
21607
21647
  }
21608
- isExistPersistedMessage(messageList) {
21609
- return messageList.some(m => m.isPersited);
21610
- }
21611
21648
  }
21612
21649
 
21613
21650
  class BaseMessage {
package/index.umd.js CHANGED
@@ -19497,24 +19497,28 @@
19497
19497
  if (!dialogIdList.length) {
19498
19498
  return new Map();
19499
19499
  }
19500
- const {
19501
- code,
19502
- data
19503
- } = await getDialogKey(dialogIdList.map(e => Long.fromString(e)));
19504
- if (code === exports.ErrorCode.SUCCESS) {
19505
- const content = new Map();
19506
- for (const k in data.entry) {
19507
- const v = data.entry[k];
19508
- if (v.aesKey?.length && v.aesIV?.length) {
19509
- const keyItem = {
19510
- key: v.aesKey,
19511
- iv: v.aesIV
19512
- };
19513
- content.set(k, keyItem);
19514
- this.aesKeyRecord.set(k, keyItem);
19500
+ try {
19501
+ const {
19502
+ code,
19503
+ data
19504
+ } = await getDialogKey(dialogIdList.map(e => Long.fromString(e)));
19505
+ if (code === exports.ErrorCode.SUCCESS) {
19506
+ const content = new Map();
19507
+ for (const k in data.entry) {
19508
+ const v = data.entry[k];
19509
+ if (v.aesKey?.length && v.aesIV?.length) {
19510
+ const keyItem = {
19511
+ key: v.aesKey,
19512
+ iv: v.aesIV
19513
+ };
19514
+ content.set(k, keyItem);
19515
+ this.aesKeyRecord.set(k, keyItem);
19516
+ }
19515
19517
  }
19518
+ return content;
19516
19519
  }
19517
- return content;
19520
+ } catch (error) {
19521
+ logger.error('getDialogAesKeyListFromRemote error', error);
19518
19522
  }
19519
19523
  return new Map();
19520
19524
  }
@@ -20138,14 +20142,6 @@
20138
20142
  val: newLocalConversation.unreadMentionedCount
20139
20143
  };
20140
20144
  }
20141
- if (isPersited) {
20142
- updateConOptions.conversation.updateTime = parseInt(message.sentTime);
20143
- updateConOptions.conversation.latestMessage = message;
20144
- updateConOptions.updatedItems.latestMessage = {
20145
- time: parseInt(message.sentTime),
20146
- val: message
20147
- };
20148
- }
20149
20145
  if (Object.keys(updateConOptions.updatedItems).length) {
20150
20146
  this.setUpdatedConversation(updateConOptions);
20151
20147
  }
@@ -20441,15 +20437,22 @@
20441
20437
  }
20442
20438
  const remainDialogIds = new Set([...msgs.keys()]);
20443
20439
  DialogSecretKey$1.getDialogAesKeyListInBatches([...msgs.keys()], (remote, aesKeys) => {
20444
- if (aesKeys.size) {
20445
- const dialogIds = [...aesKeys.keys()];
20446
- for (const k of dialogIds) {
20447
- remainDialogIds.delete(k);
20440
+ try {
20441
+ if (aesKeys.size) {
20442
+ const dialogIds = [...aesKeys.keys()];
20443
+ for (const k of dialogIds) {
20444
+ remainDialogIds.delete(k);
20445
+ }
20446
+ callback(!remainDialogIds.size, parseDialogsMessages(dialogIds, msgs, aesKeys));
20447
+ }
20448
+ if (remainDialogIds.size && remote) {
20449
+ callback(true, new Map());
20450
+ }
20451
+ } catch (error) {
20452
+ logger.error('parseDialogsMessages error', error);
20453
+ if (remainDialogIds.size && remote) {
20454
+ callback(true, new Map());
20448
20455
  }
20449
- callback(!remainDialogIds.size, parseDialogsMessages(dialogIds, msgs, aesKeys));
20450
- }
20451
- if (remainDialogIds.size && remote) {
20452
- callback(true, new Map());
20453
20456
  }
20454
20457
  });
20455
20458
  }
@@ -20512,7 +20515,11 @@
20512
20515
  if (receivedMessage.isStatusMessage && Long.fromNumber(getServerTime$1()).subtract(receivedMessage.sentTime).greaterThan(STATUSMESSAGE_ALIVE_TIMEMS)) {
20513
20516
  return;
20514
20517
  }
20515
- contentList.push(receivedMessage);
20518
+ if (notEmptyString(receivedMessage.messageUId)) {
20519
+ contentList.push(receivedMessage);
20520
+ } else {
20521
+ logger.error('message is invalid', item);
20522
+ }
20516
20523
  }
20517
20524
  });
20518
20525
  return contentList;
@@ -21307,29 +21314,55 @@
21307
21314
  if (!messageUIds || messageUIds.length === 0 || !this.db) {
21308
21315
  return;
21309
21316
  }
21310
- const transaction = this.db.transaction(this.STORE_NAME, 'readwrite');
21311
- const store = transaction.objectStore(this.STORE_NAME);
21312
- const index = store.index('messageUId');
21313
- messageUIds.forEach(messageUId => {
21314
- const request = index.get(messageUId);
21315
- request.onsuccess = () => {
21316
- const message = request.result;
21317
- if (message) {
21318
- const recallContent = {
21319
- messageUId: messageUId
21320
- };
21321
- const updatedMessage = {
21322
- ...message,
21323
- messageType: MessageTypes.RECALL,
21324
- content: this.encryptContent(recallContent)
21325
- };
21326
- store.put(updatedMessage);
21317
+ return new Promise(resolve => {
21318
+ const transaction = this.db.transaction(this.STORE_NAME, 'readwrite');
21319
+ const store = transaction.objectStore(this.STORE_NAME);
21320
+ const index = store.index('messageUId');
21321
+ let pendingRequests = messageUIds.length;
21322
+ for (const messageUId of messageUIds) {
21323
+ const request = index.get(messageUId);
21324
+ request.onsuccess = () => {
21325
+ const message = request.result;
21326
+ if (message) {
21327
+ const recallContent = {
21328
+ messageUId: messageUId
21329
+ };
21330
+ const updatedMessage = {
21331
+ ...message,
21332
+ messageType: MessageTypes.RECALL,
21333
+ content: this.encryptContent(recallContent)
21334
+ };
21335
+ const putRequest = store.put(updatedMessage);
21336
+ putRequest.onerror = () => {
21337
+ checkComplete();
21338
+ };
21339
+ putRequest.onsuccess = () => {
21340
+ checkComplete();
21341
+ };
21342
+ } else {
21343
+ checkComplete();
21344
+ }
21345
+ };
21346
+ request.onerror = () => {
21347
+ checkComplete();
21348
+ };
21349
+ }
21350
+ function checkComplete() {
21351
+ pendingRequests--;
21352
+ if (pendingRequests === 0) {
21353
+ resolve();
21327
21354
  }
21355
+ }
21356
+ transaction.oncomplete = () => {
21357
+ resolve();
21358
+ };
21359
+ transaction.onerror = () => {
21360
+ resolve();
21328
21361
  };
21329
21362
  });
21330
21363
  }
21331
21364
  }
21332
- let cache;
21365
+ let cache = null;
21333
21366
  var MessageCache$1 = {
21334
21367
  create(appkey, currentUserId) {
21335
21368
  cache = new MessageCache(appkey, currentUserId);
@@ -21433,101 +21466,124 @@
21433
21466
  };
21434
21467
  });
21435
21468
  await ConversationManager$1.get().loadConvsationsIfNotExist(cons);
21436
- serverMessageParser.parse(msg, (done, outputMsgs) => {
21437
- const messages = [];
21438
- let recallMessageUIds = [];
21439
- const recallMessageIndexes = [];
21440
- const isOffLineMessage = !this.pullOfflineFinished;
21441
- outputMsgs.forEach((l, dialogId) => {
21442
- let messageList = [];
21443
- l.forEach(m => {
21444
- if (m.messageType === MessageTypes.RECALL && RecallMessageStore.has(m.content.messageUId)) {
21445
- if (m.content.messageUId) {
21446
- RecallMessageStore.remove(m.content.messageUId);
21447
- recallMessageUIds.push(m.content.messageUId);
21448
- } else {
21449
- logger.error('recall messageUId is undefined', m);
21450
- }
21451
- } else if (m.messageUId) {
21452
- m.isOffLineMessage = isOffLineMessage;
21453
- if (!m.messageId || m.messageId > getCurrentMessageId()) {
21454
- m.messageId = generateNewMessageId();
21455
- }
21456
- ConversationManager$1.get().setConversationCacheByMessage(m);
21457
- messageList.push(m);
21458
- if (m.messageType === MessageTypes.RECALL) {
21459
- recallMessageIndexes.push(messageList.length - 1);
21469
+ serverMessageParser.parse(msg, async (done, outputMsgs) => {
21470
+ try {
21471
+ for (const [dialogId, l] of outputMsgs.entries()) {
21472
+ if (l.length === 0) {
21473
+ return;
21474
+ }
21475
+ await this.processMessages(l, !this.pullOfflineFinished);
21476
+ }
21477
+ } catch (error) {
21478
+ logger.error('processMessages error', error);
21479
+ }
21480
+ if (done) {
21481
+ try {
21482
+ let seqNo_long;
21483
+ if (seqno) {
21484
+ if (Long.isLong(seqno)) {
21485
+ seqNo_long = seqno;
21486
+ } else if (typeof seqno === 'string') {
21487
+ seqNo_long = Long.fromString(seqno);
21488
+ } else if (typeof seqno === 'number') {
21489
+ seqNo_long = Long.fromNumber(seqno);
21460
21490
  }
21461
- } else {
21462
- logger.error('messageUId is undefined', m);
21463
21491
  }
21464
- if ([NotiMessageTypes.PRIVATE_OPEN_BURNAFTERREADING, NotiMessageTypes.GROUP_OPEN_BURNAFTERREADING, NotiMessageTypes.PRIVATE_CLOSE_BURNAFTERREADING, NotiMessageTypes.GROUP_CLOSE_BURNAFTERREADING].includes(m.messageType)) {
21465
- this.handleBurnAfterReadingMessage(m);
21492
+ if (seqNo_long && Long.isLong(seqNo_long) && seqNo_long.ge(this.serverMsgSeqno)) {
21493
+ this.serverMsgSeqno = seqNo_long;
21466
21494
  }
21467
- });
21468
- let deletedMessageIndexes = [];
21469
- for (let i = recallMessageIndexes.length - 1; i >= 0; i--) {
21470
- const index = recallMessageIndexes[i];
21471
- const recallMessage = messageList[index];
21472
- const recallContent = recallMessage.content;
21473
- const messageIndex = messageList.findIndex(m => m.messageUId === recallContent.messageUId);
21474
- if (messageIndex !== -1) {
21475
- deletedMessageIndexes.push(messageIndex);
21476
- } else {
21477
- recallMessageUIds.push(recallContent.messageUId);
21478
- deletedMessageIndexes.push(index);
21495
+ const isFinished = this.serverMsgSeqno.lessThanOrEqual(offset);
21496
+ logger.info(`pullMsg success -> syncTime: ${offset}, finished: ${isFinished}`);
21497
+ this.letterbox?.setInboxOffset(offset);
21498
+ this.pullingMsg = false;
21499
+ if (isFinished && !this.pullOfflineFinished) {
21500
+ this.pullOfflineFinished = true;
21501
+ this.watcher.pullFinished && this.watcher.pullFinished();
21479
21502
  }
21503
+ if (!isFinished) {
21504
+ this.pullMsg();
21505
+ }
21506
+ } catch (error) {
21507
+ logger.error('setPullMsgDone error', error);
21508
+ this.pullingMsg = false;
21480
21509
  }
21481
- if (deletedMessageIndexes.length) {
21482
- let messageList_tmp = [];
21483
- messageList.forEach((m, index) => {
21484
- if (!deletedMessageIndexes.includes(index)) {
21485
- messageList_tmp.push(m);
21486
- }
21487
- });
21488
- messageList = messageList_tmp;
21489
- }
21490
- messages.push(...messageList);
21491
- if (this.isExistPersistedMessage(messageList)) {
21492
- splitFullDialog(dialogId);
21493
- }
21494
- });
21495
- let normalMessages = this.handleReceiptMessages(messages);
21496
- if (normalMessages.length) {
21497
- this.handleBatchMessages(normalMessages);
21498
- MessageReceiptManager$1.get()?.sendArrivalReceipts(normalMessages);
21499
- }
21500
- if (recallMessageUIds.length) {
21501
- MessageCache$1.get()?.convertToRecallMessages(recallMessageUIds);
21502
- this.watcher.onRecall?.(recallMessageUIds);
21503
21510
  }
21504
- if (done) {
21505
- let seqNo_long;
21506
- if (seqno) {
21507
- if (Long.isLong(seqno)) {
21508
- seqNo_long = seqno;
21509
- } else if (typeof seqno === 'string') {
21510
- seqNo_long = Long.fromString(seqno);
21511
- } else if (typeof seqno === 'number') {
21512
- seqNo_long = Long.fromNumber(seqno);
21513
- }
21511
+ });
21512
+ }
21513
+ async processMessages(l, isOffLineMessage) {
21514
+ const conversation = {
21515
+ conversationType: l[0].conversationType,
21516
+ targetId: l[0].targetId
21517
+ };
21518
+ let messageList = [];
21519
+ const recallMessageIndexes = [];
21520
+ let recallMessageUIds = [];
21521
+ l.forEach(m => {
21522
+ if (m.messageType === MessageTypes.RECALL && RecallMessageStore.has(m.content.messageUId)) {
21523
+ if (m.content.messageUId) {
21524
+ RecallMessageStore.remove(m.content.messageUId);
21525
+ recallMessageUIds.push(m.content.messageUId);
21526
+ } else {
21527
+ logger.error('recallMessage’s messageUId is undefined', m);
21514
21528
  }
21515
- if (seqNo_long && Long.isLong(seqNo_long) && seqNo_long.ge(this.serverMsgSeqno)) {
21516
- this.serverMsgSeqno = seqNo_long;
21529
+ } else if (m.messageUId) {
21530
+ m.isOffLineMessage = isOffLineMessage;
21531
+ if (!m.messageId || m.messageId > getCurrentMessageId()) {
21532
+ m.messageId = generateNewMessageId();
21517
21533
  }
21518
- const isFinished = this.serverMsgSeqno.lessThanOrEqual(offset);
21519
- logger.info(`pullMsg success -> syncTime: ${offset}, finished: ${isFinished}`);
21520
- this.letterbox?.setInboxOffset(offset);
21521
- this.pullingMsg = false;
21522
- if (isFinished && !this.pullOfflineFinished) {
21523
- this.pullOfflineFinished = true;
21524
- this.watcher.pullFinished && this.watcher.pullFinished();
21534
+ ConversationManager$1.get().setConversationCacheByMessage(m);
21535
+ messageList.push(m);
21536
+ if (m.messageType === MessageTypes.RECALL) {
21537
+ recallMessageIndexes.push(messageList.length - 1);
21525
21538
  }
21526
- if (!isFinished) {
21527
- this.pullMsg();
21539
+ if ([NotiMessageTypes.PRIVATE_OPEN_BURNAFTERREADING, NotiMessageTypes.GROUP_OPEN_BURNAFTERREADING, NotiMessageTypes.PRIVATE_CLOSE_BURNAFTERREADING, NotiMessageTypes.GROUP_CLOSE_BURNAFTERREADING].includes(m.messageType)) {
21540
+ this.handleBurnAfterReadingMessage(m);
21528
21541
  }
21542
+ } else {
21543
+ logger.error('message‘s messageUId is undefined', m);
21529
21544
  }
21530
21545
  });
21546
+ let deletedMessageIndexes = [];
21547
+ for (let i = recallMessageIndexes.length - 1; i >= 0; i--) {
21548
+ const index = recallMessageIndexes[i];
21549
+ const recallMessage = messageList[index];
21550
+ const recallContent = recallMessage.content;
21551
+ const messageIndex = messageList.findIndex(m => m.messageUId === recallContent.messageUId);
21552
+ if (messageIndex !== -1) {
21553
+ deletedMessageIndexes.push(index);
21554
+ const targetMessage = messageList[messageIndex];
21555
+ messageList[messageIndex] = recallMessage;
21556
+ messageList[index] = targetMessage;
21557
+ deletedMessageIndexes.push(index);
21558
+ } else {
21559
+ recallMessageUIds.push(recallContent.messageUId);
21560
+ deletedMessageIndexes.push(index);
21561
+ }
21562
+ }
21563
+ if (deletedMessageIndexes.length) {
21564
+ let messageList_tmp = [];
21565
+ messageList.forEach((m, index) => {
21566
+ if (!deletedMessageIndexes.includes(index)) {
21567
+ messageList_tmp.push(m);
21568
+ }
21569
+ });
21570
+ messageList = messageList_tmp;
21571
+ }
21572
+ let normalMessages = this.handleReceiptMessages(messageList);
21573
+ if (normalMessages.length) {
21574
+ await MessageCache$1.get()?.addMessages(normalMessages, {
21575
+ conversationType: normalMessages[0].conversationType,
21576
+ targetId: normalMessages[0].targetId
21577
+ });
21578
+ this.handleBatchMessages(normalMessages);
21579
+ MessageReceiptManager$1.get()?.sendArrivalReceipts(normalMessages);
21580
+ }
21581
+ if (recallMessageUIds.length) {
21582
+ await MessageCache$1.get()?.convertToRecallMessages(recallMessageUIds);
21583
+ this.watcher.onRecall?.(recallMessageUIds);
21584
+ }
21585
+ const latestMessage = await MessageCache$1.get()?.getLatestMessage(conversation);
21586
+ ConversationManager$1.get().updateLatestMessage(conversation, latestMessage);
21531
21587
  }
21532
21588
  handleBurnAfterReadingMessage(message) {
21533
21589
  const content = message.content;
@@ -21583,23 +21639,7 @@
21583
21639
  return [];
21584
21640
  }
21585
21641
  }
21586
- handleBatchMessages(messages) {
21587
- if (messages.length) {
21588
- const targetGroups = new Map();
21589
- messages.forEach(message => {
21590
- if (!targetGroups.has(message.targetId)) {
21591
- targetGroups.set(message.targetId, []);
21592
- }
21593
- targetGroups.get(message.targetId).push(message);
21594
- });
21595
- targetGroups.forEach((targetMessages, targetId) => {
21596
- const conversationType = targetMessages[0].conversationType;
21597
- MessageCache$1.get()?.addMessages(targetMessages, {
21598
- conversationType,
21599
- targetId
21600
- });
21601
- });
21602
- }
21642
+ async handleBatchMessages(messages) {
21603
21643
  const filteredMessages = messages.filter(m => {
21604
21644
  if (m.messageDirection === exports.MessageDirection.SEND && m.messageId && SentMessageStore.has(m.messageId)) {
21605
21645
  SentMessageStore.remove(m.messageId);
@@ -21611,9 +21651,6 @@
21611
21651
  this.watcher.batchMessage?.(filteredMessages);
21612
21652
  }
21613
21653
  }
21614
- isExistPersistedMessage(messageList) {
21615
- return messageList.some(m => m.isPersited);
21616
- }
21617
21654
  }
21618
21655
 
21619
21656
  class BaseMessage {
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@onyx-p/imlib-web",
3
- "version": "2.4.5",
3
+ "version": "2.4.7",
4
4
  "main": "index.umd.js",
5
5
  "module": "index.esm.js",
6
6
  "types": "types/index.d.ts",