stream-chat 9.2.0-offline-support-beta.3 → 9.2.0

package/dist/cjs/index.browser.cjs

@@ -2550,7 +2550,7 @@ var RESERVED_UPDATED_MESSAGE_FIELDS = {
 };
 var LOCAL_MESSAGE_FIELDS = { error: true };
 var DEFAULT_QUERY_CHANNELS_RETRY_COUNT = 3;
-var DEFAULT_QUERY_CHANNELS_SECONDS_BETWEEN_RETRIES = 1;
+var DEFAULT_QUERY_CHANNELS_MS_BETWEEN_RETRIES = 1e3;
 
 // src/utils.ts
 function logChatPromiseExecution(promise, name) {
@@ -3254,16 +3254,17 @@ var promoteChannel = ({
 };
 var isDate2 = (value) => !!value.getTime;
 var isLocalMessage = (message) => isDate2(message.created_at);
-var waitSeconds = (seconds) => new Promise((resolve) => {
-  setTimeout(resolve, seconds * 1e3);
-});
 var runDetached = (callback, options) => {
   const { context, onSuccessCallback = () => void 0, onErrorCallback } = options ?? {};
   const defaultOnError = (error) => {
     console.log(`An error has occurred in context ${context}: ${error}`);
   };
   const onError = onErrorCallback ?? defaultOnError;
-  callback.then(onSuccessCallback).catch(onError);
+  let promise = callback;
+  if (onSuccessCallback) {
+    promise = promise.then(onSuccessCallback);
+  }
+  promise.catch(onError);
 };
 
 // src/channel_state.ts
@@ -4548,7 +4549,7 @@ var AttachmentManager = class {
       } = uploadConfig;
       const sizeLimit = size_limit || DEFAULT_UPLOAD_SIZE_LIMIT_BYTES;
       const mimeType = fileLike.type;
-      if (isFile2(fileLike)) {
+      if (isFile2(fileLike) || isFileReference(fileLike)) {
         if (allowed_file_extensions?.length && !allowed_file_extensions.some(
           (ext) => fileLike.name.toLowerCase().endsWith(ext.toLowerCase())
         )) {
@@ -8394,10 +8395,12 @@ var Channel = class {
           type: reactionType,
           user_id: this.getClient().userID ?? user_id
         };
-        await offlineDb.deleteReaction({
-          message,
-          reaction
-        });
+        if (message) {
+          await offlineDb.deleteReaction({
+            message,
+            reaction
+          });
+        }
         return await offlineDb.queueTask({
           task: {
             channelId: this.id,
@@ -11748,7 +11751,7 @@ var ChannelManager = class extends WithSubscriptions {
     this.setOptions = (options = {}) => {
       this.options = { ...DEFAULT_CHANNEL_MANAGER_OPTIONS, ...options };
     };
-    this.queryChannelsRequest = async (payload, retryCount = 0) => {
+    this.executeChannelsQuery = async (payload, retryCount = 0) => {
       const { filters, sort, options, stateOptions } = payload;
       const { offset, limit } = {
         ...DEFAULT_CHANNEL_MANAGER_PAGINATION_OPTIONS,
@@ -11792,8 +11795,8 @@ var ChannelManager = class extends WithSubscriptions {
           this.state.partialNext({ error: wrappedError });
           return;
         }
-        await waitSeconds(DEFAULT_QUERY_CHANNELS_SECONDS_BETWEEN_RETRIES);
-        return this.queryChannelsRequest(payload, retryCount + 1);
+        await sleep(DEFAULT_QUERY_CHANNELS_MS_BETWEEN_RETRIES);
+        return this.executeChannelsQuery(payload, retryCount + 1);
       }
     };
     this.queryChannels = async (filters, sort = [], options = {}, stateOptions = {}) => {
@@ -11801,10 +11804,12 @@ var ChannelManager = class extends WithSubscriptions {
         pagination: { isLoading, filters: filtersFromState },
         initialized
       } = this.state.getLatestValue();
-      if (isLoading && !this.options.abortInFlightQuery && JSON.stringify(filtersFromState) === JSON.stringify(filters)) {
+      if (isLoading && !this.options.abortInFlightQuery && // TODO: Figure a proper way to either deeply compare these or
+      //       create hashes from each.
+      JSON.stringify(filtersFromState) === JSON.stringify(filters)) {
         return;
       }
-      const queryChannelsRequestPayload = { filters, sort, options, stateOptions };
+      const executeChannelsQueryPayload = { filters, sort, options, stateOptions };
       try {
         this.stateOptions = stateOptions;
         this.state.next((currentState) => ({
@@ -11839,13 +11844,13 @@ var ChannelManager = class extends WithSubscriptions {
             this.client.offlineDb.syncManager.scheduleSyncStatusChangeCallback(
               this.id,
               async () => {
-                await this.queryChannelsRequest(queryChannelsRequestPayload);
+                await this.executeChannelsQuery(executeChannelsQueryPayload);
               }
             );
             return;
           }
         }
-        await this.queryChannelsRequest(queryChannelsRequestPayload);
+        await this.executeChannelsQuery(executeChannelsQueryPayload);
       } catch (error) {
         this.client.logger("error", error.message);
         this.state.next((currentState) => ({
@@ -13188,13 +13193,11 @@ var StreamChat = class _StreamChat {
     if (event.type === "notification.mutes_updated" && event.me?.mutes) {
       this.mutedUsers = event.me.mutes;
     }
-    if (event.type === "notification.mark_read") {
-      if (event.unread_channels === 0) {
-        const activeChannelKeys = Object.keys(this.activeChannels);
-        activeChannelKeys.forEach(
-          (activeChannelKey) => this.activeChannels[activeChannelKey].state.unreadCount = 0
-        );
-      }
+    if (event.type === "notification.mark_read" && event.unread_channels === 0) {
+      const activeChannelKeys = Object.keys(this.activeChannels);
+      activeChannelKeys.forEach(
+        (activeChannelKey) => this.activeChannels[activeChannelKey].state.unreadCount = 0
+      );
     }
     if ((event.type === "channel.deleted" || event.type === "notification.channel_deleted") && event.cid) {
       const { cid } = event;
@@ -14072,7 +14075,7 @@ var StreamChat = class _StreamChat {
       data
     );
   }
-  deleteChannelType(channelType) {
+  DBDeleteChannelType(channelType) {
     return this.delete(
       this.baseURL + `/channeltypes/${encodeURIComponent(channelType)}`
     );
@@ -14413,7 +14416,7 @@ var StreamChat = class _StreamChat {
     if (this.userAgent) {
       return this.userAgent;
     }
-    const version = "9.2.0-offline-support-beta.3";
+    const version = "9.2.0";
     const clientBundle = "browser-cjs";
     let userAgentString = "";
     if (this.sdkIdentifier) {
@@ -15589,7 +15592,147 @@ var BuiltinPermissions = {
   UseFrozenChannel: "Send messages and reactions to frozen channels"
 };
 
-// src/offline_support_api.ts
+// src/offline-support/offline_sync_manager.ts
+var OfflineDBSyncManager = class {
+  constructor({
+    client,
+    offlineDb
+  }) {
+    this.syncStatus = false;
+    this.connectionChangedListener = null;
+    this.syncStatusListeners = [];
+    this.scheduledSyncStatusCallbacks = /* @__PURE__ */ new Map();
+    /**
+     * Initializes the sync manager. Should only be called once per session.
+     *
+     * Cleans up old listeners if re-initialized to avoid memory leaks.
+     * Starts syncing immediately if already connected, otherwise waits for reconnection.
+     */
+    this.init = async () => {
+      try {
+        if (this.client.user?.id && this.client.wsConnection?.isHealthy) {
+          await this.syncAndExecutePendingTasks();
+          await this.invokeSyncStatusListeners(true);
+        }
+        if (this.connectionChangedListener) {
+          this.connectionChangedListener.unsubscribe();
+        }
+        this.connectionChangedListener = this.client.on(
+          "connection.changed",
+          async (event) => {
+            if (event.online) {
+              await this.syncAndExecutePendingTasks();
+              await this.invokeSyncStatusListeners(true);
+            } else {
+              await this.invokeSyncStatusListeners(false);
+            }
+          }
+        );
+      } catch (error) {
+        console.log("Error in DBSyncManager.init: ", error);
+      }
+    };
+    /**
+     * Registers a listener that is called whenever the sync status changes.
+     *
+     * @param listener - A callback invoked with the new sync status (`true` or `false`).
+     * @returns An object with an `unsubscribe` function to remove the listener.
+     */
+    this.onSyncStatusChange = (listener) => {
+      this.syncStatusListeners.push(listener);
+      return {
+        unsubscribe: () => {
+          this.syncStatusListeners = this.syncStatusListeners.filter(
+            (el) => el !== listener
+          );
+        }
+      };
+    };
+    /**
+     * Schedules a one-time callback to be invoked after the next successful sync.
+     *
+     * @param tag - A unique key to identify and manage the callback.
+     * @param callback - An async function to run after sync.
+     */
+    this.scheduleSyncStatusChangeCallback = (tag, callback) => {
+      this.scheduledSyncStatusCallbacks.set(tag, callback);
+    };
+    /**
+     * Invokes all registered sync status listeners and executes any scheduled sync callbacks.
+     *
+     * @param status - The new sync status (`true` or `false`).
+     */
+    this.invokeSyncStatusListeners = async (status) => {
+      this.syncStatus = status;
+      this.syncStatusListeners.forEach((l) => l(status));
+      if (status) {
+        const promises = Array.from(this.scheduledSyncStatusCallbacks.values()).map(
+          (cb) => cb()
+        );
+        await Promise.all(promises);
+        this.scheduledSyncStatusCallbacks.clear();
+      }
+    };
+    /**
+     * Performs synchronization with the Stream backend.
+     *
+     * This includes downloading events since the last sync, updating the local DB,
+     * and handling sync failures (e.g., if syncing beyond the allowed retention window).
+     */
+    this.sync = async () => {
+      if (!this.client?.user) {
+        return;
+      }
+      try {
+        const cids = await this.offlineDb.getAllChannelCids();
+        if (cids.length === 0) {
+          return;
+        }
+        const lastSyncedAt = await this.offlineDb.getLastSyncedAt({
+          userId: this.client.user.id
+        });
+        if (lastSyncedAt) {
+          const lastSyncedAtDate = new Date(lastSyncedAt);
+          const nowDate = /* @__PURE__ */ new Date();
+          const diff = Math.floor(
+            (nowDate.getTime() - lastSyncedAtDate.getTime()) / (1e3 * 60 * 60 * 24)
+          );
+          if (diff > 30) {
+            await this.offlineDb.resetDB();
+          } else {
+            const result = await this.client.sync(cids, lastSyncedAtDate.toISOString());
+            const queryPromises = result.events.map(
+              (event) => this.offlineDb.handleEvent({ event, execute: false })
+            );
+            const queriesArray = await Promise.all(queryPromises);
+            const queries = queriesArray.flat();
+            if (queries.length) {
+              await this.offlineDb.executeSqlBatch(queries);
+            }
+          }
+        }
+        await this.offlineDb.upsertUserSyncStatus({
+          userId: this.client.user.id,
+          lastSyncedAt: (/* @__PURE__ */ new Date()).toString()
+        });
+      } catch (e) {
+        console.log("An error has occurred while syncing the DB.", e);
+        await this.offlineDb.resetDB();
+      }
+    };
+    /**
+     * Executes any tasks that were queued while offline and then performs a sync.
+     */
+    this.syncAndExecutePendingTasks = async () => {
+      await this.offlineDb.executePendingTasks();
+      await this.sync();
+    };
+    this.client = client;
+    this.offlineDb = offlineDb;
+  }
+};
+
+// src/offline-support/offline_support_api.ts
 var AbstractOfflineDB = class {
   constructor({ client }) {
     /**
@@ -16167,144 +16310,6 @@ var AbstractOfflineDB = class {
     return userId === userIdFromState && initialized;
   }
 };
-var OfflineDBSyncManager = class {
-  constructor({
-    client,
-    offlineDb
-  }) {
-    this.syncStatus = false;
-    this.connectionChangedListener = null;
-    this.syncStatusListeners = [];
-    this.scheduledSyncStatusCallbacks = /* @__PURE__ */ new Map();
-    /**
-     * Initializes the sync manager. Should only be called once per session.
-     *
-     * Cleans up old listeners if re-initialized to avoid memory leaks.
-     * Starts syncing immediately if already connected, otherwise waits for reconnection.
-     */
-    this.init = async () => {
-      try {
-        if (this.client.user?.id && this.client.wsConnection?.isHealthy) {
-          await this.syncAndExecutePendingTasks();
-          await this.invokeSyncStatusListeners(true);
-        }
-        if (this.connectionChangedListener) {
-          this.connectionChangedListener.unsubscribe();
-        }
-        this.connectionChangedListener = this.client.on(
-          "connection.changed",
-          async (event) => {
-            if (event.online) {
-              await this.syncAndExecutePendingTasks();
-              await this.invokeSyncStatusListeners(true);
-            } else {
-              await this.invokeSyncStatusListeners(false);
-            }
-          }
-        );
-      } catch (error) {
-        console.log("Error in DBSyncManager.init: ", error);
-      }
-    };
-    /**
-     * Registers a listener that is called whenever the sync status changes.
-     *
-     * @param listener - A callback invoked with the new sync status (`true` or `false`).
-     * @returns An object with an `unsubscribe` function to remove the listener.
-     */
-    this.onSyncStatusChange = (listener) => {
-      this.syncStatusListeners.push(listener);
-      return {
-        unsubscribe: () => {
-          this.syncStatusListeners = this.syncStatusListeners.filter(
-            (el) => el !== listener
-          );
-        }
-      };
-    };
-    /**
-     * Schedules a one-time callback to be invoked after the next successful sync.
-     *
-     * @param tag - A unique key to identify and manage the callback.
-     * @param callback - An async function to run after sync.
-     */
-    this.scheduleSyncStatusChangeCallback = (tag, callback) => {
-      this.scheduledSyncStatusCallbacks.set(tag, callback);
-    };
-    /**
-     * Invokes all registered sync status listeners and executes any scheduled sync callbacks.
-     *
-     * @param status - The new sync status (`true` or `false`).
-     */
-    this.invokeSyncStatusListeners = async (status) => {
-      this.syncStatus = status;
-      this.syncStatusListeners.forEach((l) => l(status));
-      if (status) {
-        const promises = Array.from(this.scheduledSyncStatusCallbacks.values()).map(
-          (cb) => cb()
-        );
-        await Promise.all(promises);
-        this.scheduledSyncStatusCallbacks.clear();
-      }
-    };
-    /**
-     * Performs synchronization with the Stream backend.
-     *
-     * This includes downloading events since the last sync, updating the local DB,
-     * and handling sync failures (e.g., if syncing beyond the allowed retention window).
-     */
-    this.sync = async () => {
-      if (!this.client?.user) {
-        return;
-      }
-      const cids = await this.offlineDb.getAllChannelCids();
-      if (cids.length === 0) {
-        return;
-      }
-      const lastSyncedAt = await this.offlineDb.getLastSyncedAt({
-        userId: this.client.user.id
-      });
-      if (lastSyncedAt) {
-        const lastSyncedAtDate = new Date(lastSyncedAt);
-        const nowDate = /* @__PURE__ */ new Date();
-        const diff = Math.floor(
-          (nowDate.getTime() - lastSyncedAtDate.getTime()) / (1e3 * 60 * 60 * 24)
-        );
-        if (diff > 30) {
-          await this.offlineDb.resetDB();
-        } else {
-          try {
-            const result = await this.client.sync(cids, lastSyncedAtDate.toISOString());
-            const queryPromises = result.events.map(
-              (event) => this.offlineDb.handleEvent({ event, execute: false })
-            );
-            const queriesArray = await Promise.all(queryPromises);
-            const queries = queriesArray.flat();
-            if (queries.length) {
-              await this.offlineDb.executeSqlBatch(queries);
-            }
-          } catch (e) {
-            console.log("An error has occurred while syncing the DB.", e);
-            await this.offlineDb.resetDB();
-          }
-        }
-      }
-      await this.offlineDb.upsertUserSyncStatus({
-        userId: this.client.user.id,
-        lastSyncedAt: (/* @__PURE__ */ new Date()).toString()
-      });
-    };
-    /**
-     * Executes any tasks that were queued while offline and then performs a sync.
-     */
-    this.syncAndExecutePendingTasks = async () => {
-      await this.offlineDb.executePendingTasks();
-      await this.sync();
-    };
-    this.client = client;
-    this.offlineDb = offlineDb;
-  }
-};
 
 // src/utils/FixedSizeQueueCache.ts
 var FixedSizeQueueCache = class {