stream-chat 9.39.0 → 9.40.0

package/dist/cjs/index.browser.js

@@ -12755,6 +12755,29 @@ var _ReminderManager = class _ReminderManager extends WithSubscriptions {
 _ReminderManager.isReminderWsEventPayload = (event) => !!event.reminder && (event.type.startsWith("reminder.") || event.type === "notification.reminder_due");
 var ReminderManager = _ReminderManager;
 
+// src/offline-support/util.ts
+var isLocalUrl = (value) => !!value && !value.startsWith("http");
+var isAttachmentReplayable = (attachment) => {
+  if (!attachment || typeof attachment !== "object") {
+    return true;
+  }
+  return !isLocalUrl(attachment.asset_url) && !isLocalUrl(attachment.image_url);
+};
+var isMessageUpdateReplayable = (message) => !message.attachments?.some((attachment) => !isAttachmentReplayable(attachment));
+var getPendingTaskChannelData = (cid) => {
+  if (!cid) {
+    return {};
+  }
+  const separatorIndex = cid.indexOf(":");
+  if (separatorIndex <= 0 || separatorIndex === cid.length - 1) {
+    return {};
+  }
+  return {
+    channelId: cid.slice(separatorIndex + 1),
+    channelType: cid.slice(0, separatorIndex)
+  };
+};
+
 // src/client.ts
 function isString2(x) {
   return typeof x === "string" || x instanceof String;
@@ -14847,6 +14870,30 @@ var StreamChat = class _StreamChat {
    * @return {{ message: LocalMessage | MessageResponse }} Response that includes the message
    */
   async updateMessage(message, partialUserOrUserId, options) {
+    if (!message.id) {
+      throw Error("Please specify the message.id when calling updateMessage");
+    }
+    const messageId = message.id;
+    try {
+      if (this.offlineDb) {
+        return await this.offlineDb.queueTask({
+          task: {
+            ...getPendingTaskChannelData(message.cid),
+            messageId,
+            payload: [message, partialUserOrUserId, options],
+            type: "update-message"
+          }
+        });
+      }
+    } catch (error) {
+      this.logger("error", `offlineDb:updateMessage`, {
+        tags: ["channel", "offlineDb"],
+        error
+      });
+    }
+    return await this._updateMessage(message, partialUserOrUserId, options);
+  }
+  async _updateMessage(message, partialUserOrUserId, options) {
     if (!message.id) {
       throw Error("Please specify the message.id when calling updateMessage");
     }
@@ -15124,7 +15171,7 @@ var StreamChat = class _StreamChat {
     if (this.userAgent) {
       return this.userAgent;
     }
-    const version = "9.39.0";
+    const version = "9.40.0";
     const clientBundle = "browser-cjs";
     let userAgentString = "";
     if (this.sdkIdentifier) {
@@ -17280,7 +17327,7 @@ var AbstractOfflineDB = class {
         return await attemptTaskExecution();
       } catch (e) {
         if (!this.shouldSkipQueueingTask(e)) {
-          await this.addPendingTask(task);
+          await this.handleAddPendingTask({ task });
         }
         throw e;
       }
@@ -17293,19 +17340,92 @@ var AbstractOfflineDB = class {
      * @param error
      */
     this.shouldSkipQueueingTask = (error) => error?.response?.data?.code === 4 || error?.response?.data?.code === 17;
+    this.mergeFailedMessageUpdateIntoPendingSendMessage = ({
+      editedMessage,
+      pendingMessage
+    }) => {
+      const normalizedEditedMessageSource = {
+        ...editedMessage
+      };
+      if (editedMessage.status === "failed") {
+        delete normalizedEditedMessageSource.message_text_updated_at;
+      }
+      const normalizedEditedMessage = localMessageToNewMessagePayload(
+        normalizedEditedMessageSource
+      );
+      const pendingMessageStatus = pendingMessage.status;
+      return {
+        ...pendingMessage,
+        ...normalizedEditedMessage,
+        ...typeof pendingMessageStatus !== "undefined" ? { status: pendingMessageStatus } : {}
+      };
+    };
+    this.isPendingSendMessageTask = (task) => task.type === "send-message";
+    this.handleOfflineFailedUpdateMessagePendingTask = async (task) => {
+      const [message] = task.payload;
+      if (!message.id) {
+        return;
+      }
+      const pendingTasks = await this.getPendingTasks({ messageId: message.id });
+      const pendingSendMessageTask = pendingTasks.find(this.isPendingSendMessageTask);
+      if (!pendingSendMessageTask) {
+        return;
+      }
+      const updatedPendingSendMessage = this.mergeFailedMessageUpdateIntoPendingSendMessage(
+        {
+          editedMessage: message,
+          pendingMessage: pendingSendMessageTask.payload[0]
+        }
+      );
+      const updatedPendingTask = {
+        ...pendingSendMessageTask,
+        payload: [updatedPendingSendMessage, pendingSendMessageTask.payload[1]]
+      };
+      if (pendingSendMessageTask.id) {
+        await this.updatePendingTask({
+          id: pendingSendMessageTask.id,
+          task: updatedPendingTask
+        });
+        return;
+      }
+      await this.addPendingTask({
+        ...updatedPendingTask,
+        id: void 0
+      });
+    };
+    /**
+     * Central ingress for persisting pending tasks. It either stores the task as-is
+     * or rewrites an existing pending `send-message` task for offline edits of failed messages.
+     */
+    this.handleAddPendingTask = async ({ task }) => {
+      if (task.type === "update-message" && !isMessageUpdateReplayable(task.payload[0])) {
+        return;
+      }
+      if (task.type === "update-message" && !this.client.wsConnection?.isHealthy && task.payload[0].status === "failed") {
+        await this.handleOfflineFailedUpdateMessagePendingTask(task);
+        return;
+      }
+      await this.addPendingTask(task);
+    };
     /**
      * Executes a task from the list of supported pending tasks. Currently supported pending tasks
      * are:
+     * - Updating a message
      * - Deleting a message
      * - Sending a reaction
      * - Removing a reaction
      * - Sending a message
+     * - Creating a draft
+     * - Deleting a draft
      * It will throw if we try to execute a pending task that is not supported.
      * @param task - The task we want to execute
      * @param isPendingTask - a control value telling us if it's an actual pending task being executed
      * or delayed execution
      */
     this.executeTask = async ({ task }, isPendingTask = false) => {
+      if (task.type === "update-message") {
+        return await this.client._updateMessage(...task.payload);
+      }
       if (task.type === "delete-message") {
         return await this.client._deleteMessage(...task.payload);
       }