stream-chat 9.50.2 → 9.51.0

package/dist/cjs/index.node.js

@@ -967,7 +967,8 @@ var debounce = (fn, timeout = 0, { leading = false, trailing = true } = {}) => {
       }
       runningTimeout = null;
     };
-    runningTimeout = setTimeout(timeoutHandler, timeout);
+    const delay = typeof timeout === "function" ? timeout(...args) : timeout;
+    runningTimeout = setTimeout(timeoutHandler, delay);
     return lastResult;
   };
   debouncedFn.cancel = () => {
@@ -4405,13 +4406,41 @@ function isErrorResponse(res) {
 
 // src/search/BaseSearchSource.ts
 var DEFAULT_SEARCH_SOURCE_OPTIONS = {
-  debounceMs: 300,
   pageSize: 10,
   allowEmptySearchString: false,
   resetOnNewSearchQuery: true
 };
+var resolveDebounceOptions = ({
+  debounceMs,
+  shortQueryDebounceMs,
+  longQueryDebounceMs,
+  shortQueryMaxLength
+}) => ({
+  shortQueryDebounceMs: shortQueryDebounceMs ?? debounceMs ?? 500,
+  longQueryDebounceMs: longQueryDebounceMs ?? debounceMs ?? 300,
+  shortQueryMaxLength: shortQueryMaxLength ?? 2
+});
 var BaseSearchSourceBase = class {
   constructor(options) {
+    this.setDebounceOptions = (options = {}) => {
+      const resolved = resolveDebounceOptions(options);
+      this.shortQueryDebounceMs = resolved.shortQueryDebounceMs;
+      this.longQueryDebounceMs = resolved.longQueryDebounceMs;
+      this.shortQueryMaxLength = resolved.shortQueryMaxLength;
+      this.searchDebounced = debounce(
+        this.executeQuery.bind(this),
+        (searchString) => this.getDebounceMs(searchString)
+      );
+    };
+    /**
+     * Short queries match too much and are slow server-side, so they get a longer debounce.
+     * Resolved per call, which is what lets the interval switch as the user keeps typing.
+     */
+    this.getDebounceMs = (searchString) => {
+      const { length } = searchString ?? this.searchQuery;
+      return length <= this.shortQueryMaxLength ? this.shortQueryDebounceMs : this.longQueryDebounceMs;
+    };
+    this.search = (searchQuery) => this.searchDebounced(searchQuery);
     this.activate = () => {
       if (this.isActive) return;
       this.state.partialNext({ isActive: true });
@@ -4423,7 +4452,7 @@ var BaseSearchSourceBase = class {
     this.canExecuteQuery = (newSearchString) => {
       const hasNewSearchQuery = typeof newSearchString !== "undefined";
       const searchString = newSearchString ?? this.searchQuery;
-      return !!(this.isActive && !this.isLoading && (this.hasNext || hasNewSearchQuery) && (this.allowEmptySearchString || searchString));
+      return !!(this.isActive && this.canDispatchQuery(hasNewSearchQuery) && (this.allowEmptySearchString || searchString));
     };
     const { pageSize, allowEmptySearchString, resetOnNewSearchQuery } = {
       ...DEFAULT_SEARCH_SOURCE_OPTIONS,
@@ -4433,6 +4462,14 @@ var BaseSearchSourceBase = class {
     this.allowEmptySearchString = allowEmptySearchString;
     this.resetOnNewSearchQuery = resetOnNewSearchQuery;
     this.state = new StateStore(this.initialState);
+    this.setDebounceOptions(options ?? {});
+  }
+  /**
+   * A new search query preempts an in-flight one; pagination waits for it to finish
+   * and needs a next page to fetch.
+   */
+  canDispatchQuery(hasNewSearchQuery) {
+    return hasNewSearchQuery || !this.isLoading && this.hasNext;
   }
   get lastQueryError() {
     return this.state.getLatestValue().lastQueryError;
@@ -4527,21 +4564,30 @@ var BaseSearchSourceBase = class {
   }
 };
 var BaseSearchSource = class extends BaseSearchSourceBase {
-  constructor(options) {
-    const { debounceMs } = { ...DEFAULT_SEARCH_SOURCE_OPTIONS, ...options };
-    super(options);
-    this.setDebounceOptions = ({ debounceMs }) => {
-      this.searchDebounced = debounce(this.executeQuery.bind(this), debounceMs);
-    };
-    this.search = (searchQuery) => this.searchDebounced(searchQuery);
-    this.setDebounceOptions({ debounceMs });
+  constructor() {
+    super(...arguments);
+    /** Aborts the in-flight request, if any, once a newer query is dispatched. */
+    this.queryAbortController = null;
+  }
+  /** Aborts the in-flight request, if any. Returns true when one was aborted. */
+  abortInFlightQuery() {
+    if (!this.queryAbortController) return false;
+    this.queryAbortController.abort();
+    this.queryAbortController = null;
+    return true;
+  }
+  resetState() {
+    this.abortInFlightQuery();
+    super.resetState();
   }
   async executeQuery(newSearchString) {
     if (!this.canExecuteQuery(newSearchString)) return;
+    this.abortInFlightQuery();
+    const { signal } = this.queryAbortController = new AbortController();
     const { hasNewSearchQuery, searchString } = this.prepareStateForQuery(newSearchString);
     let stateUpdate = {};
     try {
-      const results = await this.query(searchString);
+      const results = await this.query(searchString, { signal });
       if (!results) return;
       const { items } = results;
       stateUpdate = this.updatePaginationStateFromQuery(results);
@@ -4552,23 +4598,19 @@ var BaseSearchSource = class extends BaseSearchSourceBase {
         stateUpdate.hasNext = false;
       }
     } finally {
-      this.state.next(this.getStateAfterQuery(stateUpdate, hasNewSearchQuery));
+      if (!signal.aborted) {
+        this.state.next(this.getStateAfterQuery(stateUpdate, hasNewSearchQuery));
+      }
     }
   }
   cancelScheduledQuery() {
     this.searchDebounced.cancel();
+    if (this.abortInFlightQuery() && this.isLoading) {
+      this.state.partialNext({ isLoading: false });
+    }
   }
 };
 var BaseSearchSourceSync = class extends BaseSearchSourceBase {
-  constructor(options) {
-    const { debounceMs } = { ...DEFAULT_SEARCH_SOURCE_OPTIONS, ...options };
-    super(options);
-    this.setDebounceOptions = ({ debounceMs }) => {
-      this.searchDebounced = debounce(this.executeQuery.bind(this), debounceMs);
-    };
-    this.search = (searchQuery) => this.searchDebounced(searchQuery);
-    this.setDebounceOptions({ debounceMs });
-  }
   executeQuery(newSearchString) {
     if (!this.canExecuteQuery(newSearchString)) return;
     const { hasNewSearchQuery, searchString } = this.prepareStateForQuery(newSearchString);
@@ -4864,13 +4906,13 @@ var UserGroupPaginator = class extends BasePaginator {
 // src/search/ChannelMemberSearchSource.ts
 var ChannelMemberSearchSource = class extends BaseSearchSource {
   constructor(channel, options, filterBuilderOptions = {}) {
-    super(options);
+    const { filters, sort, searchOptions, ...restOptions } = options || {};
+    super({ ...restOptions, allowEmptySearchString: true });
     this.type = "members";
-    this.canExecuteQuery = (newSearchString) => {
-      const hasNewSearchQuery = typeof newSearchString !== "undefined";
-      return this.isActive && !this.isLoading && (this.hasNext || hasNewSearchQuery);
-    };
     this.channel = channel;
+    this.filters = filters;
+    this.sort = sort;
+    this.searchOptions = searchOptions;
     this.filterBuilder = new FilterBuilder({
       initialFilterConfig: {
         default: {
@@ -4886,7 +4928,7 @@ var ChannelMemberSearchSource = class extends BaseSearchSource {
       ...filterBuilderOptions
     });
   }
-  async query(searchQuery) {
+  async query(searchQuery, queryOptions = {}) {
     const filters = this.filterBuilder.buildFilters({
       baseFilters: this.filters,
       context: {
@@ -4895,7 +4937,12 @@ var ChannelMemberSearchSource = class extends BaseSearchSource {
     });
     const sort = this.sort ?? [];
     const options = { ...this.searchOptions, limit: this.pageSize, offset: this.offset };
-    const { members } = await this.channel.queryMembers(filters ?? {}, sort, options);
+    const { members } = await this.channel.queryMembers(
+      filters ?? {},
+      sort,
+      options,
+      queryOptions
+    );
     return { items: members };
   }
   filterQueryResults(items) {
@@ -5010,9 +5057,13 @@ var SearchController = class {
 // src/search/UserSearchSource.ts
 var UserSearchSource = class extends BaseSearchSource {
   constructor(client, options, filterBuilderOptions = {}) {
-    super(options);
+    const { filters, sort, searchOptions, ...restOptions } = options || {};
+    super(restOptions);
     this.type = "users";
     this.client = client;
+    this.filters = filters;
+    this.sort = sort;
+    this.searchOptions = searchOptions;
     this.filterBuilder = new FilterBuilder({
       initialFilterConfig: {
         $or: {
@@ -5028,7 +5079,7 @@ var UserSearchSource = class extends BaseSearchSource {
       ...filterBuilderOptions
     });
   }
-  async query(searchQuery) {
+  async query(searchQuery, queryOptions = {}) {
     const filters = this.filterBuilder.buildFilters({
       baseFilters: this.filters,
       context: { searchQuery }
@@ -5041,7 +5092,7 @@ var UserSearchSource = class extends BaseSearchSource {
       sort = { id: 1, ...this.sort };
     }
     const options = { ...this.searchOptions, limit: this.pageSize, offset: this.offset };
-    const { users } = await this.client.queryUsers(filters, sort, options);
+    const { users } = await this.client.queryUsers(filters, sort, options, queryOptions);
     return { items: users };
   }
   filterQueryResults(items) {
@@ -5052,9 +5103,13 @@ var UserSearchSource = class extends BaseSearchSource {
 // src/search/ChannelSearchSource.ts
 var ChannelSearchSource = class extends BaseSearchSource {
   constructor(client, options, filterBuilderOptions = {}) {
-    super(options);
+    const { filters, sort, searchOptions, ...restOptions } = options || {};
+    super(restOptions);
     this.type = "channels";
     this.client = client;
+    this.filters = filters;
+    this.sort = sort;
+    this.searchOptions = searchOptions;
     this.filterBuilder = new FilterBuilder({
       ...filterBuilderOptions,
       initialFilterConfig: {
@@ -5066,7 +5121,7 @@ var ChannelSearchSource = class extends BaseSearchSource {
       }
     });
   }
-  async query(searchQuery) {
+  async query(searchQuery, queryOptions = {}) {
     const filters = this.filterBuilder.buildFilters({
       baseFilters: {
         ...this.client.userID ? { members: { $in: [this.client.userID] } } : {},
@@ -5076,7 +5131,7 @@ var ChannelSearchSource = class extends BaseSearchSource {
     });
     const sort = this.sort ?? {};
     const options = { ...this.searchOptions, limit: this.pageSize, offset: this.offset };
-    const items = await this.client.queryChannels(filters, sort, options);
+    const items = await this.client.queryChannels(filters, sort, options, queryOptions);
     return { items };
   }
   filterQueryResults(items) {
@@ -5087,9 +5142,24 @@ var ChannelSearchSource = class extends BaseSearchSource {
 // src/search/MessageSearchSource.ts
 var MessageSearchSource = class extends BaseSearchSource {
   constructor(client, options, filterBuilderOptions) {
-    super(options);
+    const {
+      messageSearchChannelFilters,
+      messageSearchFilters,
+      messageSearchSort,
+      channelQueryFilters,
+      channelQuerySort,
+      channelQueryOptions,
+      ...restOptions
+    } = options || {};
+    super(restOptions);
     this.type = "messages";
     this.client = client;
+    this.messageSearchChannelFilters = messageSearchChannelFilters;
+    this.messageSearchFilters = messageSearchFilters;
+    this.messageSearchSort = messageSearchSort;
+    this.channelQueryFilters = channelQueryFilters;
+    this.channelQuerySort = channelQuerySort;
+    this.channelQueryOptions = channelQueryOptions;
     this.messageSearchChannelFilterBuilder = new FilterBuilder(filterBuilderOptions?.messageSearchChannel);
     this.messageSearchFilterBuilder = new FilterBuilder({
       ...filterBuilderOptions?.messageSearch,
@@ -5112,7 +5182,7 @@ var MessageSearchSource = class extends BaseSearchSource {
       }
     });
   }
-  async query(searchQuery) {
+  async query(searchQuery, queryOptions = {}) {
     if (!this.client.userID || this.next === null) return { items: [] };
     const channelFilters = this.messageSearchChannelFilterBuilder.buildFilters({
       baseFilters: {
@@ -5140,9 +5210,11 @@ var MessageSearchSource = class extends BaseSearchSource {
     const { next, results } = await this.client.search(
       channelFilters,
       messageFilters,
-      options
+      options,
+      queryOptions
     );
     const items = results.map(({ message }) => message);
+    if (queryOptions.signal?.aborted) return { items, next };
     const cids = Array.from(
       items.reduce((acc, message) => {
         if (message.cid && !this.client.activeChannels[message.cid]) acc.add(message.cid);
@@ -5160,7 +5232,8 @@ var MessageSearchSource = class extends BaseSearchSource {
           last_message_at: -1,
           ...this.channelQuerySort
         },
-        this.channelQueryOptions
+        this.channelQueryOptions,
+        queryOptions
       );
     }
     return { items, next };
@@ -6454,13 +6527,18 @@ var MentionsSearchSource = class extends BaseSearchSource {
   constructor(channel, options) {
     const {
       mentionAllAppUsers,
+      memberFilters,
+      memberSort,
+      searchOptions,
       suggestionFactoryMappers,
       textComposerText,
       transliterate,
       trigger,
+      userFilters,
+      userSort,
       ...restOptions
     } = options || {};
-    super(restOptions);
+    super({ ...restOptions, allowEmptySearchString: true });
     this.type = "mentions";
     this.normalizeSearchValue = (value) => this.transliterate(removeDiacritics(value)).toLowerCase();
     this.matchesSearchQuery = (value, searchQuery) => {
@@ -6498,10 +6576,6 @@ var MentionsSearchSource = class extends BaseSearchSource {
     this.toHereMentionSuggestion = (searchToken = this.searchQuery) => this.mapMentionSuggestion("here", "here", searchToken);
     this.toRoleMentionSuggestion = (role, searchToken = this.searchQuery) => this.mapMentionSuggestion("role", role, searchToken);
     this.toUserGroupMentionSuggestion = (userGroup, searchToken = this.searchQuery) => this.mapMentionSuggestion("user_group", userGroup, searchToken);
-    this.canExecuteQuery = (newSearchString) => {
-      const hasNewSearchQuery = typeof newSearchString !== "undefined";
-      return this.isActive && !this.isLoading && (hasNewSearchQuery || this.hasNext);
-    };
     this.transliterate = (text) => text;
     this.getMembersAndWatchers = () => {
       const memberUsers = Object.values(this.channel.state.members ?? {}).map(
@@ -6521,10 +6595,10 @@ var MentionsSearchSource = class extends BaseSearchSource {
       ...this.isMentionTypeAllowed("channel") ? [this.toChannelMentionSuggestion(searchQuery)] : [],
       ...this.isMentionTypeAllowed("here") ? [this.toHereMentionSuggestion(searchQuery)] : []
     ].filter(({ name }) => this.matchesPrefixSearchQuery(name, searchQuery));
-    this.getRoleMentionSuggestions = async (query) => {
+    this.getRoleMentionSuggestions = async (query, queryOptions = {}) => {
       if (!this.isMentionTypeAllowed("role")) return [];
       if (!query) return [];
-      const { roles } = await this.client.searchRoles({ query });
+      const { roles } = await this.client.searchRoles({ query }, queryOptions);
       return [...roles?.map((role) => role.name) ?? []].sort((left, right) => left.localeCompare(right)).map((role) => this.toRoleMentionSuggestion(role, query));
     };
     this.searchMembersLocally = (searchQuery) => {
@@ -6586,20 +6660,25 @@ var MentionsSearchSource = class extends BaseSearchSource {
         options: { ...this.searchOptions, limit: this.pageSize, offset }
       };
     };
-    this.queryUsers = async (searchQuery, offset = 0) => {
+    this.queryUsers = async (searchQuery, offset = 0, queryOptions = {}) => {
       const { filters, sort, options } = this.prepareQueryUsersParams(searchQuery, offset);
-      const { users } = await this.client.queryUsers(filters, sort, options);
+      const { users } = await this.client.queryUsers(filters, sort, options, queryOptions);
       return users;
     };
-    this.queryMembers = async (searchQuery, offset = 0) => {
+    this.queryMembers = async (searchQuery, offset = 0, queryOptions = {}) => {
       const { filters, sort, options } = this.prepareQueryMembersParams(
         searchQuery,
         offset
       );
-      const response = await this.channel.queryMembers(filters, sort, options);
+      const response = await this.channel.queryMembers(
+        filters,
+        sort,
+        options,
+        queryOptions
+      );
       return response.members.map((member) => member.user);
     };
-    this.getUserSuggestionsPage = async (searchQuery, userOffset = 0) => {
+    this.getUserSuggestionsPage = async (searchQuery, userOffset = 0, queryOptions = {}) => {
       if (!this.isMentionTypeAllowed("user")) {
         return {
           items: [],
@@ -6609,7 +6688,7 @@ var MentionsSearchSource = class extends BaseSearchSource {
       let users;
       const shouldSearchLocally = this.allMembersLoadedWithInitialChannelQuery || !searchQuery;
       if (this.config.mentionAllAppUsers) {
-        users = await this.queryUsers(searchQuery, userOffset);
+        users = await this.queryUsers(searchQuery, userOffset, queryOptions);
       } else if (shouldSearchLocally) {
         const localUsers = this.searchMembersLocally(searchQuery);
         const items2 = localUsers.slice(userOffset, userOffset + this.pageSize).map((user) => this.toUserSuggestion(user, searchQuery));
@@ -6618,7 +6697,7 @@ var MentionsSearchSource = class extends BaseSearchSource {
           nextOffset: localUsers.length > userOffset + this.pageSize ? userOffset + items2.length : void 0
         };
       } else {
-        users = await this.queryMembers(searchQuery, userOffset);
+        users = await this.queryMembers(searchQuery, userOffset, queryOptions);
       }
       const items = users.map((user) => this.toUserSuggestion(user, searchQuery));
       return {
@@ -6635,7 +6714,7 @@ var MentionsSearchSource = class extends BaseSearchSource {
         name_gt: lastItem.name
       });
     };
-    this.getUserGroupSuggestionsPage = async (searchQuery, cursor) => {
+    this.getUserGroupSuggestionsPage = async (searchQuery, cursor, queryOptions = {}) => {
       if (!this.isMentionTypeAllowed("user_group")) {
         return {
           items: [],
@@ -6657,7 +6736,7 @@ var MentionsSearchSource = class extends BaseSearchSource {
         ...userGroupCursor?.id_gt ? { id_gt: userGroupCursor.id_gt } : {},
         ...userGroupCursor?.name_gt ? { name_gt: userGroupCursor.name_gt } : {}
       };
-      const { user_groups } = await this.client.searchUserGroups(options);
+      const { user_groups } = await this.client.searchUserGroups(options, queryOptions);
       return {
         items: user_groups.map(
           (userGroup) => this.toUserGroupMentionSuggestion(userGroup, searchQuery)
@@ -6667,6 +6746,11 @@ var MentionsSearchSource = class extends BaseSearchSource {
     };
     this.client = channel.getClient();
     this.channel = channel;
+    this.userFilters = userFilters;
+    this.userSort = userSort;
+    this.memberFilters = memberFilters;
+    this.memberSort = memberSort;
+    this.searchOptions = searchOptions;
     this.config = {
       mentionAllAppUsers,
       suggestionFactoryMappers,
@@ -6699,16 +6783,21 @@ var MentionsSearchSource = class extends BaseSearchSource {
       offset: (this.offset ?? 0) + userPaginationState.itemCount
     };
   }
-  async query(searchQuery) {
+  async query(searchQuery, queryOptions = {}) {
     const userOffset = this.offset ?? 0;
     const isFirstPage = userOffset === 0 && typeof this.userGroupCursor === "undefined";
     const previousUserPaginationState = this.latestUserPaginationState;
     const previousUserGroupCursor = this.userGroupCursor;
     const [userResultsState, userGroupResultsState, roleSuggestionsState] = await Promise.allSettled([
-      this.getUserSuggestionsPage(searchQuery, userOffset),
-      this.getUserGroupSuggestionsPage(searchQuery, previousUserGroupCursor),
-      isFirstPage ? this.getRoleMentionSuggestions(searchQuery) : Promise.resolve([])
+      this.getUserSuggestionsPage(searchQuery, userOffset, queryOptions),
+      this.getUserGroupSuggestionsPage(
+        searchQuery,
+        previousUserGroupCursor,
+        queryOptions
+      ),
+      isFirstPage ? this.getRoleMentionSuggestions(searchQuery, queryOptions) : Promise.resolve([])
     ]);
+    if (queryOptions.signal?.aborted) return { items: [] };
     const userResults = userResultsState.status === "fulfilled" ? userResultsState.value : {
       items: [],
       nextOffset: isFirstPage ? void 0 : previousUserPaginationState?.nextOffset
@@ -9384,10 +9473,11 @@ var Channel = class {
    * @param {MemberSort} [sort] Sort options, for instance [{created_at: -1}].
    * When using multiple fields, make sure you use array of objects to guarantee field order, for instance [{name: -1}, {created_at: 1}]
    * @param {{ limit?: number; offset?: number }} [options] Option object, {limit: 10, offset:10}
+   * @param {RequestOptions} [requestOptions] Carries an abort signal. Not sent in the request.
    *
    * @return {Promise<ChannelMemberAPIResponse>} Query Members response
    */
-  async queryMembers(filterConditions, sort = [], options = {}) {
+  async queryMembers(filterConditions, sort = [], options = {}, requestOptions = {}) {
     let id;
     const type = this.type;
     let members;
@@ -9407,7 +9497,8 @@ var Channel = class {
           filter_conditions: filterConditions,
           ...options
         }
-      }
+      },
+      requestOptions
     );
   }
   /**
@@ -14539,6 +14630,7 @@ var StreamChat = class _StreamChat {
         return this.handleResponse(response);
       } catch (e) {
         e.client_request_id = requestConfig.headers?.["x-client-request-id"];
+        if (import_axios3.default.isCancel(e)) throw e;
         this._logApiError(type, url, e);
         this.consecutiveFailures += 1;
         if (e.response) {
@@ -14850,7 +14942,7 @@ var StreamChat = class _StreamChat {
         return this.userAgent;
       }
       if (!this.cachedUserAgent) {
-        const version = "9.50.2";
+        const version = "9.51.0";
         const { name: sdkName, version: sdkVersion } = this.sdkIdentifier ?? {};
         const { name: appName, version: appVersion } = this.appIdentifier ?? {};
         const { os, model: deviceModel } = this.deviceIdentifier ?? {};
@@ -15226,14 +15318,14 @@ var StreamChat = class _StreamChat {
       error
     });
   }
-  get(url, params) {
-    return this.doAxiosRequest("get", url, null, { params });
+  get(url, params, config) {
+    return this.doAxiosRequest("get", url, null, { params, config });
   }
   put(url, data) {
     return this.doAxiosRequest("put", url, data);
   }
-  post(url, data) {
-    return this.doAxiosRequest("post", url, data);
+  post(url, data, config) {
+    return this.doAxiosRequest("post", url, data, { config });
   }
   patch(url, data) {
     return this.doAxiosRequest("patch", url, data);
@@ -15428,10 +15520,11 @@ var StreamChat = class _StreamChat {
    * @param {UserSort} sort Sort options, for instance [{last_active: -1}].
    * When using multiple fields, make sure you use array of objects to guarantee field order, for instance [{last_active: -1}, {created_at: 1}]
    * @param {UserOptions} options Option object, {presence: true}
+   * @param {RequestOptions} [requestOptions] Carries an abort signal. Not sent in the request.
    *
    * @return {Promise<{ users: Array<UserResponse> }>} User Query Response
    */
-  async queryUsers(filterConditions, sort = [], options = {}) {
+  async queryUsers(filterConditions, sort = [], options = {}, requestOptions = {}) {
     const defaultOptions = {
       presence: false
     };
@@ -15448,7 +15541,8 @@ var StreamChat = class _StreamChat {
           ...defaultOptions,
           ...options
         }
-      }
+      },
+      requestOptions
     );
     this.state.updateUsers(data.users);
     return data;
@@ -15494,13 +15588,14 @@ var StreamChat = class _StreamChat {
    * searchUserGroups - Search user groups by prefix for autocomplete
    *
    * @param {SearchUserGroupsOptions} options The search options
-   *
+   * @param {RequestOptions} [requestOptions] Carries an abort signal. Not sent in the request.
    * @return {Promise<SearchUserGroupsResponse>} User Group Search Response
    */
-  async searchUserGroups(options) {
+  async searchUserGroups(options, requestOptions = {}) {
     return await this.get(
       this.baseURL + "/usergroups/search",
-      options
+      options,
+      requestOptions
     );
   }
   /**
@@ -15620,10 +15715,11 @@ var StreamChat = class _StreamChat {
    * @param {ChannelSort} [sort] Sort options, for instance {created_at: -1}.
    * When using multiple fields, make sure you use array of objects to guarantee field order, for instance [{last_updated: -1}, {created_at: 1}]
    * @param {ChannelOptions} [options] Options object. Can include predefined_filter, filter_values, and sort_values for using predefined filters.
+   * @param {RequestOptions} [requestOptions] Carries an abort signal. Not sent in the request.
    *
    * @return {Promise<QueryChannelsAPIResponse>} full search channels response
    */
-  async queryChannelsRequestWithResponse(filterConditions, sort = [], options = {}) {
+  async queryChannelsRequestWithResponse(filterConditions, sort = [], options = {}, requestOptions = {}) {
     const defaultOptions = {
       state: true,
       watch: true,
@@ -15648,7 +15744,11 @@ var StreamChat = class _StreamChat {
       ...defaultOptions,
       ...restOptions
     };
-    return await this.post(this.baseURL + "/channels", payload);
+    return await this.post(
+      this.baseURL + "/channels",
+      payload,
+      requestOptions
+    );
   }
   /**
    * queryChannelsRequest - Queries channels and returns the raw channel response list.
@@ -15677,7 +15777,9 @@ var StreamChat = class _StreamChat {
     const queryChannelsResponse = await this.queryChannelsRequestWithResponse(
       filterConditions,
       sort,
-      options
+      options,
+      // stateOptions is never serialized, so it carries the abort signal
+      { signal: stateOptions.signal }
     );
     const channels = queryChannelsResponse.channels;
     this.dispatchEvent({
@@ -15794,10 +15896,11 @@ var StreamChat = class _StreamChat {
    * @param {ChannelFilters} filterConditions MongoDB style filter conditions
    * @param {MessageFilters | string} query search query or object MongoDB style filters
    * @param {SearchOptions} [options] Option object, {user_id: 'tommaso'}
+   * @param {RequestOptions} [requestOptions] Carries an abort signal. Not sent in the request.
    *
    * @return {Promise<SearchAPIResponse>} search messages response
    */
-  async search(filterConditions, query, options = {}) {
+  async search(filterConditions, query, options = {}, requestOptions = {}) {
     if (options.offset && options.next) {
       throw Error(`Cannot specify offset with next`);
     }
@@ -15814,7 +15917,11 @@ var StreamChat = class _StreamChat {
       throw Error(`Invalid type ${typeof query} for query parameter`);
     }
     await this.wsPromise;
-    return await this.get(this.baseURL + "/search", { payload });
+    return await this.get(
+      this.baseURL + "/search",
+      { payload },
+      requestOptions
+    );
   }
   /**
    * setLocalDevice - Set the device info for the current client(device) that will be sent via WS connection automatically
@@ -16851,6 +16958,7 @@ var StreamChat = class _StreamChat {
       headers: axiosRequestConfigHeaders,
       ...axiosRequestConfigRest
     } = this.options.axiosRequestConfig || {};
+    const resolvedSignal = options.config?.signal ?? axiosRequestConfigRest.signal ?? signal;
     return {
       params: {
         user_id: this.userID,
@@ -16866,9 +16974,9 @@ var StreamChat = class _StreamChat {
         ...options.headers,
         ...axiosRequestConfigHeaders || {}
       },
-      ...signal ? { signal } : {},
       ...options.config,
-      ...axiosRequestConfigRest || {}
+      ...axiosRequestConfigRest,
+      ...resolvedSignal ? { signal: resolvedSignal } : {}
     };
   }
   _getToken() {
@@ -17008,8 +17116,12 @@ var StreamChat = class _StreamChat {
    *
    * @returns {Promise<APIResponse>}
    */
-  searchRoles(options) {
-    return this.get(`${this.baseURL}/roles/search`, options);
+  searchRoles(options, requestOptions = {}) {
+    return this.get(
+      `${this.baseURL}/roles/search`,
+      options,
+      requestOptions
+    );
   }
   /** deleteRole - deletes a custom role
    *
@@ -18366,7 +18478,8 @@ var import_axios4 = require("axios");
 var OfflineDBSyncManager = class {
   constructor({
     client,
-    offlineDb
+    offlineDb,
+    syncMaxEventCount
   }) {
     this.syncStatus = false;
     this.connectionChangedListener = null;
@@ -18434,10 +18547,22 @@ var OfflineDBSyncManager = class {
      */
     this.invokeSyncStatusListeners = async (status) => {
       this.syncStatus = status;
-      this.syncStatusListeners.forEach((l) => l(status));
+      this.syncStatusListeners.forEach((l) => {
+        try {
+          l(status);
+        } catch (error) {
+          console.log("Error in a sync status listener.", error);
+        }
+      });
       if (status) {
         const promises = Array.from(this.scheduledSyncStatusCallbacks.values()).map(
-          (cb) => cb()
+          async (cb) => {
+            try {
+              await cb();
+            } catch (error) {
+              console.log("Error executing a scheduled sync status callback.", error);
+            }
+          }
         );
         await Promise.all(promises);
         this.scheduledSyncStatusCallbacks.clear();
@@ -18471,13 +18596,23 @@ var OfflineDBSyncManager = class {
             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);
+            const { syncMaxEventCount } = this;
+            const exceedsLimit = typeof syncMaxEventCount === "number" && syncMaxEventCount > 0 && result.events.length > syncMaxEventCount;
+            if (exceedsLimit) {
+              this.client.logger(
+                "warn",
+                `Skipping sync event replay: received ${result.events.length} events, which exceeds the configured limit of ${syncMaxEventCount}. Visible channels are refreshed on reconnect instead.`,
+                { tags: ["sync", "offline"] }
+              );
+            } else {
+              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);
+              }
             }
           }
         }
@@ -18499,19 +18634,38 @@ var OfflineDBSyncManager = class {
     };
     /**
      * Executes any tasks that were queued while offline and then performs a sync.
+     *
+     * 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.
+     * Failed syncs degrade to "possibly stale data until the next query" rather
+     * than freezing all future queries. See issue #1816.
      */
     this.syncAndExecutePendingTasks = async () => {
-      await this.offlineDb.executePendingTasks();
-      await this.sync();
+      try {
+        await this.offlineDb.executePendingTasks();
+      } catch (error) {
+        console.log("Error executing pending tasks during sync.", error);
+      }
+      try {
+        await this.sync();
+      } catch (error) {
+        console.log("Error while syncing the DB.", error);
+      }
     };
     this.client = client;
     this.offlineDb = offlineDb;
+    this.syncMaxEventCount = syncMaxEventCount;
   }
 };
 
 // src/offline-support/offline_support_api.ts
 var AbstractOfflineDB = class {
-  constructor({ client }) {
+  constructor({
+    client,
+    syncMaxEventCount
+  }) {
     /**
      * Initializes the DB as well as its syncManager for a given userId.
      * It will update the DBs reactive state with initialization values.
@@ -19201,7 +19355,11 @@ var AbstractOfflineDB = class {
       }
     };
     this.client = client;
-    this.syncManager = new OfflineDBSyncManager({ client, offlineDb: this });
+    this.syncManager = new OfflineDBSyncManager({
+      client,
+      offlineDb: this,
+      syncMaxEventCount
+    });
     this.state = new StateStore({
       initialized: false,
       userId: this.client.userID