stream-chat 10.0.0-rc.10 → 10.0.0-rc.11

package/dist/cjs/index.browser.js

@@ -4125,6 +4125,19 @@ var NotificationManager = class {
     }, duration);
     this.timeouts.set(id, timeout);
   }
+  /**
+   * Starts the notification's auto-dismiss countdown unless one is already running.
+   *
+   * The counterpart to {@link startTimeout}, which always restarts. Use this wherever the caller
+   * cannot know whether the countdown has been started already -- a UI component that remounts and
+   * has lost the record, or a second view displaying the same notification. Restarting there is
+   * invisible and open-ended: each call hands the notification another full lifetime, so it can
+   * outlive its duration indefinitely while looking like it is counting down.
+   */
+  ensureTimeout(id, durationOverride) {
+    if (this.timeouts.has(id)) return;
+    this.startTimeout(id, durationOverride);
+  }
   remove(id) {
     this.clearTimeout(id);
     this.store.partialNext({
@@ -5921,7 +5934,7 @@ var createUploadErrorHandlerMiddleware = (composer) => ({
         message: "Error uploading attachment",
         origin: {
           emitter: "AttachmentManager",
-          context: { attachment }
+          context: { attachment, composer }
         },
         options: {
           type: CORE_NOTIFICATION_TYPE.attachmentUploadFailed,
@@ -5989,7 +6002,7 @@ var createBlockedAttachmentUploadNotificationMiddleware = (composer) => ({
           message: `The attachment upload was blocked`,
           origin: {
             emitter: "AttachmentManager",
-            context: { blockedAttachment: attachment }
+            context: { blockedAttachment: attachment, composer }
           },
           options: {
             type: CORE_NOTIFICATION_TYPE.attachmentUploadBlocked,
@@ -6195,7 +6208,10 @@ var _AttachmentManager = class _AttachmentManager {
       if (!attachment.localMetadata?.file) {
         this.client.notifications.addError({
           message: "File is required for upload attachment",
-          origin: { emitter: "AttachmentManager", context: { attachment } },
+          origin: {
+            emitter: "AttachmentManager",
+            context: { attachment, composer: this.composer }
+          },
           options: { type: CORE_NOTIFICATION_TYPE.attachmentFileMissing }
         });
         return;
@@ -6203,7 +6219,10 @@ var _AttachmentManager = class _AttachmentManager {
       if (!attachment.localMetadata.id) {
         this.client.notifications.addError({
           message: "Local upload attachment missing local id",
-          origin: { emitter: "AttachmentManager", context: { attachment } },
+          origin: {
+            emitter: "AttachmentManager",
+            context: { attachment, composer: this.composer }
+          },
           options: { type: CORE_NOTIFICATION_TYPE.attachmentIdMissing }
         });
         return;
@@ -6270,7 +6289,11 @@ var _AttachmentManager = class _AttachmentManager {
           message: `The attachment upload was blocked`,
           origin: {
             emitter: "AttachmentManager",
-            context: { attachment, blockedAttachment: localAttachment }
+            context: {
+              attachment,
+              blockedAttachment: localAttachment,
+              composer: this.composer
+            }
           },
           options: {
             type: CORE_NOTIFICATION_TYPE.attachmentUploadBlocked,
@@ -6298,7 +6321,7 @@ var _AttachmentManager = class _AttachmentManager {
           message: "Error uploading attachment",
           origin: {
             emitter: "AttachmentManager",
-            context: { attachment, failedAttachment }
+            context: { attachment, failedAttachment, composer: this.composer }
           },
           options: {
             type: CORE_NOTIFICATION_TYPE.attachmentUploadFailed,
@@ -7605,6 +7628,13 @@ var ChannelPaginator = class extends BasePaginator {
       retryCount: DEFAULT_QUERY_CHANNELS_RETRY_COUNT,
       ...paginatorOptions
     });
+    /**
+     * True while the loaded items came ONLY from the offline cache - seeded by `setItems`, never
+     * confirmed by a query. Such a state has no pagination position worth continuing from, so the seed
+     * records `offset = <cache size>` and a query shape, which is what makes the next query look like a
+     * continuation rather than a first page. See `executeQuery`.
+     */
+    this._itemsLoadedFromOfflineDB = false;
     /**
      * Filters sent to the server with the next query (and used as the offline-db query key). Deliberately
      * built from the locally configured filters only — feeding the backend-resolved filter back in would
@@ -7629,12 +7659,15 @@ var ChannelPaginator = class extends BasePaginator {
         return void 0;
       const { stateOptions: _, ...request } = queryShape;
       try {
-        const channelsFromDB = await this.client.offlineDb.getChannelsForQuery({
+        const cachedQuery = await this.client.offlineDb.getChannelsForQuery({
           userId: this.client.user.id,
           options: request
         });
-        if (channelsFromDB) {
-          return this.client.hydrateActiveChannels(channelsFromDB, {
+        if (cachedQuery) {
+          if (cachedQuery.predefinedFilter) {
+            this.applyPredefinedFilterResponse(cachedQuery.predefinedFilter);
+          }
+          return this.client.hydrateActiveChannels(cachedQuery.channels, {
             offlineMode: true,
             skipInitialization: []
             // passing empty array will clear out the existing messages from channel state, this removes the possibility of duplicate messages
@@ -7658,6 +7691,7 @@ var ChannelPaginator = class extends BasePaginator {
       });
     };
     this.query = async () => {
+      this._itemsLoadedFromOfflineDB = false;
       if (!this._nextQueryShape) {
         this._nextQueryShape = this.getNextQueryShape();
       }
@@ -7676,7 +7710,7 @@ var ChannelPaginator = class extends BasePaginator {
       return { items };
     };
     this.filterQueryResults = (items) => items;
-    const definedSort = sort ?? DEFAULT_BACKEND_SORT2;
+    const definedSort = sort?.length ? sort : DEFAULT_BACKEND_SORT2;
     this.client = client;
     this._id = id ?? `channel-paginator-${generateUUIDv4()}`;
     this._sort = definedSort;
@@ -7732,7 +7766,7 @@ var ChannelPaginator = class extends BasePaginator {
     return this._staticFilters;
   }
   get sort() {
-    return this._sort ?? DEFAULT_BACKEND_SORT2;
+    return this._sort?.length ? this._sort : DEFAULT_BACKEND_SORT2;
   }
   /**
    * What the backend reported it actually filtered and sorted by for the last first-page query —
@@ -7856,6 +7890,11 @@ var ChannelPaginator = class extends BasePaginator {
    * `predefined_filter` / `filter_values` / `sort_values` appear, without which two predefined-filter
    * lists cannot be told apart. The duplication goes away once `convertFilterSortToQuery` derives the
    * key from `options` (a change in that implementation plus a schema-version bump to flush stale rows).
+   *
+   * The resolved `predefinedFilter` rides along with the order it produced: a cache-seeded list has no
+   * response to learn it from, and without it `effectiveFilters` / `effectiveSort` fall back to the
+   * local filters and the default sort - i.e. it would match and order by a different rule than the
+   * one the cached order came from.
    */
   cacheCidsForQuery({
     cids,
@@ -7866,6 +7905,7 @@ var ChannelPaginator = class extends BasePaginator {
         cids,
         filters: request.filter_conditions,
         options: request,
+        predefinedFilter: this._predefinedFilter,
         sort: request.sort
       }),
       { method: "upsertCidsForQuery" }
@@ -7895,24 +7935,32 @@ var ChannelPaginator = class extends BasePaginator {
    */
   async executeQuery(params = {}) {
     const { offlineDb } = this.client;
-    const queryShape = params.queryShape ?? this.getNextQueryShape();
-    const shouldDeferUntilSynced = !!offlineDb?.getChannelsForQuery && !!this.client.user?.id && !offlineDb.syncManager.syncStatus && this.isFirstPageQuery({ queryShape, reset: params.reset });
-    if (!shouldDeferUntilSynced) return await super.executeQuery(params);
+    const effectiveParams = this._itemsLoadedFromOfflineDB && params.reset !== "yes" ? { ...params, keepPreviousItems: true, reset: "yes" } : params;
+    const queryShape = effectiveParams.queryShape ?? this.getNextQueryShape();
+    const shouldDeferUntilSynced = !!offlineDb?.getChannelsForQuery && !!this.client.user?.id && !offlineDb.syncManager.isSynced && // Items seeded from the cache are not an already loaded list, so paginating them has to defer too.
+    (this._itemsLoadedFromOfflineDB || this.isFirstPageQuery({ queryShape, reset: effectiveParams.reset }));
+    if (!shouldDeferUntilSynced) return await super.executeQuery(effectiveParams);
     if (!this.isInitialized) {
       const cachedChannels = await this.preloadFirstPageFromOfflineDb({
-        ...params,
+        ...effectiveParams,
         queryShape
       });
       if (cachedChannels?.length) {
         this.setItems({ valueOrFactory: cachedChannels, isFirstPage: true });
+        this._itemsLoadedFromOfflineDB = true;
       }
       this.state.partialNext({ isLoading: false });
     }
-    if (offlineDb.syncManager.syncStatus) {
-      return await super.executeQuery({ ...params, keepPreviousItems: true });
+    const refreshParams = {
+      ...effectiveParams,
+      keepPreviousItems: true,
+      ...this._itemsLoadedFromOfflineDB ? { reset: "yes" } : {}
+    };
+    if (offlineDb.syncManager.isSynced) {
+      return await super.executeQuery(refreshParams);
     }
     offlineDb.syncManager.scheduleSyncStatusChangeCallback(this.id, async () => {
-      await this.executeQuery({ ...params, keepPreviousItems: true });
+      await this.executeQuery(refreshParams);
     });
   }
   setItems(params) {
@@ -8671,7 +8719,6 @@ var SearchController = class {
       searchQuery: "",
       sources: sources ?? []
     });
-    this._internalState = new import_state_store12.StateStore({});
     this.configController = new ConfigController({
       defaults: DEFAULT_SEARCH_CONTROLLER_CONFIG,
       constructorOptions: config
@@ -11500,9 +11547,10 @@ var MessageOperationStatePolicy = class {
       }
       return;
     }
-    const queued = kind !== "send" && kind !== "retry" && await this.ctx.isQueued(messageId, [
-      kind === "delete" ? "delete-message" : "update-message"
-    ]);
+    const queued = kind !== "send" && kind !== "retry" && await this.ctx.isQueued(
+      messageId,
+      kind === "delete" ? ["delete-message"] : ["update-message", "send-message"]
+    );
     if (kind === "delete") {
       if (!queued) this.revertDelete({ messageId, optimistic, options });
       return;
@@ -11630,6 +11678,23 @@ var MessageOperations = class {
   clearCachedFailedSend(messageId) {
     this.failedSendCache.delete(messageId);
   }
+  /**
+   * Folds an edit into the payload cached for this message's failed send, so `retry` resends what the
+   * message contains now rather than what it contained when the send failed.
+   *
+   * This exists so a retry while offline for example is also persisted, rather than just disappearing.
+   */
+  rewriteCachedFailedSend(localMessage) {
+    const cached = this.getCachedFailedSend(localMessage.id);
+    if (!cached) return;
+    this.failedSendCache.set(localMessage.id, {
+      ...cached,
+      message: {
+        ...cached.message,
+        ...localMessageToNewMessagePayload(localMessage)
+      }
+    });
+  }
   /**
    * The shared lifecycle: apply the optimistic state, fire the request, then reconcile or record the
    * failure. `kind` is threaded through because the three operations want materially different state
@@ -11710,6 +11775,7 @@ var MessageOperations = class {
     }
   }
   async update(params, requestFn) {
+    this.rewriteCachedFailedSend(params.localMessage);
     const handlers = this.ctx.handlers();
     let updateOptions;
     if (params.options) {
@@ -23200,7 +23266,7 @@ var StreamChat = class _StreamChat extends ChatApi {
         return this.userAgent;
       }
       if (!this.cachedUserAgent) {
-        const version = "10.0.0-rc.10";
+        const version = "10.0.0-rc.11";
         const { name: sdkName, version: sdkVersion } = this.sdkIdentifier ?? {};
         const { name: appName, version: appVersion } = this.appIdentifier ?? {};
         const { os, model: deviceModel } = this.deviceIdentifier ?? {};
@@ -24875,7 +24941,7 @@ var OfflineDBSyncManager = class {
     offlineDb,
     syncMaxEventCount
   }) {
-    this.syncStatus = false;
+    this.isSynced = false;
     this.connectionChangedListener = null;
     this.syncStatusListeners = [];
     this.scheduledSyncStatusCallbacks = /* @__PURE__ */ new Map();
@@ -24940,7 +25006,7 @@ var OfflineDBSyncManager = class {
      * @param status - The new sync status (`true` or `false`).
      */
     this.invokeSyncStatusListeners = async (status) => {
-      this.syncStatus = status;
+      this.isSynced = status;
       this.syncStatusListeners.forEach((l) => {
         try {
           l(status);
@@ -25033,7 +25099,7 @@ var OfflineDBSyncManager = class {
      * Each step is isolated so a failure in one does not prevent the other, and
      * neither can escape to the callers (init + the connection.changed handler).
      * This guarantees the subsequent invokeSyncStatusListeners(true) always runs,
-     * so syncStatus recovers to true and gated channel queries are unblocked.
+     * so isSynced recovers to true and gated channel queries are unblocked.
      * Failed syncs degrade to "possibly stale data until the next query" rather
      * than freezing all future queries. See issue #1816.
      */
@@ -25786,69 +25852,52 @@ var AbstractOfflineDB = class {
      * @param error - The error thrown while executing the failed task.
      */
     this.shouldSkipQueueingTask = (error) => !isEphemeral(error);
-    this.mergeFailedMessageUpdateIntoPendingSendMessage = ({
-      editedMessage,
-      pendingMessage
-    }) => {
-      const normalizedEditedMessage = localMessageToNewMessagePayload(
-        editedMessage
-      );
-      const pendingMessageStatus = pendingMessage.status;
-      return {
-        ...pendingMessage,
-        ...normalizedEditedMessage,
-        ...typeof pendingMessageStatus !== "undefined" ? { status: pendingMessageStatus } : {}
-      };
-    };
     this.isPendingSendMessageTask = (task) => task.type === "send-message";
-    this.handleOfflineFailedUpdateMessagePendingTask = async (task) => {
+    /**
+     * Folds an edit of a message the server has never seen into that message's queued `send-message`
+     * task, so a replay sends the edited text once instead of sending the original and then editing it.
+     * The send task keeps its row, and with it its place in the queue, which is what keeps the edited
+     * message ordered against everything queued after it.
+     *
+     * Keyed on a queued `send-message` task existing for this id - the only reliable statement of "the
+     * server has never seen this message". NOT on the edited message's status: both payloads are built
+     * by `localMessageToNewMessagePayload`, which strips `status` along with every other client-only
+     * field, so nothing arriving here carries one.
+     *
+     * That same normalization is why the two merge by a plain spread: both are already `MessageRequest`s,
+     * and normalizing again would map an already-flattened `mentioned_users` back over itself as
+     * `[undefined]`.
+     *
+     * With nothing to fold into, the edit is queued on its own and replays as an ordinary update.
+     */
+    this.handleUpdateMessagePendingTask = async (task) => {
       const [{ id, message }] = task.payload;
-      if (!id) {
-        return;
-      }
       const pendingTasks = await this.getPendingTasks({ messageId: id });
-      const pendingSendMessageTask = pendingTasks.find(this.isPendingSendMessageTask);
-      if (!pendingSendMessageTask) {
+      const sendTask = pendingTasks.find(this.isPendingSendMessageTask);
+      if (sendTask?.id === void 0) {
+        if (!isMessageUpdateReplayable(message)) return;
+        await this.addPendingTask(task);
         return;
       }
-      const updatedPendingSendMessage = this.mergeFailedMessageUpdateIntoPendingSendMessage(
-        {
-          // TODO: this is not good, we have too many message types, should probably only have two (request, response)
-          editedMessage: message,
-          pendingMessage: pendingSendMessageTask.payload[0].message
+      const [sendRequest, ...sendRequestOptions] = sendTask.payload;
+      await this.updatePendingTask({
+        id: sendTask.id,
+        task: {
+          ...sendTask,
+          payload: [
+            { ...sendRequest, message: { ...sendRequest.message, ...message } },
+            ...sendRequestOptions
+          ]
         }
-      );
-      const updatedPendingTask = {
-        ...pendingSendMessageTask,
-        payload: [
-          {
-            ...pendingSendMessageTask.payload[0],
-            message: updatedPendingSendMessage
-          }
-        ]
-      };
-      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.
+     * Central ingress for persisting pending tasks. It either stores the task as-is or folds an edit of
+     * a message that has not been sent yet into that message's queued `send-message` task.
      */
     this.handleAddPendingTask = async ({ task }) => {
-      if (task.type === "update-message" && !isMessageUpdateReplayable(task.payload[0].message ?? {})) {
-        return;
-      }
-      if (task.type === "update-message" && !this.client.wsConnection?.isHealthy && task.payload[0].message?.status === "failed") {
-        await this.handleOfflineFailedUpdateMessagePendingTask(task);
+      if (task.type === "update-message") {
+        await this.handleUpdateMessagePendingTask(task);
         return;
       }
       await this.addPendingTask(task);