stream-chat 9.45.5 → 9.46.0

package/dist/types/client.d.ts

@@ -23,6 +23,7 @@ import { ReminderManager } from './reminders';
 import { StateStore } from './store';
 import type { MessageComposer } from './messageComposer';
 import type { AbstractOfflineDB } from './offline-support';
+import { FixedSizeQueueCache } from './utils/FixedSizeQueueCache';
 type MessageComposerTearDownFunction = () => void;
 export type QueryChannelsResponseWithChannels = Omit<QueryChannelsAPIResponse, 'channels'> & {
     channels: Channel[];
@@ -110,6 +111,7 @@ export declare class StreamChat {
     defaultWSTimeout: number;
     sdkIdentifier?: SdkIdentifier;
     deviceIdentifier?: DeviceIdentifier;
+    readonly messageComposerCache: FixedSizeQueueCache<string, MessageComposer>;
     private nextRequestAbortController;
     /**
      * @private

package/dist/types/search/ChannelMemberSearchSource.d.ts

@@ -0,0 +1,24 @@
+import { BaseSearchSource } from './BaseSearchSource';
+import { FilterBuilder, type FilterBuilderOptions } from '../pagination';
+import type { Channel } from '../channel';
+import type { ChannelMemberResponse, MemberFilters, MemberSort, QueryMembersOptions } from '../types';
+import type { SearchSourceOptions } from './types';
+type CustomContext = Record<string, unknown>;
+export type ChannelMemberSearchSourceFilterBuilderContext<C extends CustomContext = CustomContext> = {
+    searchQuery?: string;
+} & C;
+export declare class ChannelMemberSearchSource<TFilterContext extends CustomContext = CustomContext> extends BaseSearchSource<ChannelMemberResponse> {
+    readonly type = "members";
+    channel: Channel;
+    filters: MemberFilters | undefined;
+    sort: MemberSort | undefined;
+    searchOptions: Omit<QueryMembersOptions, 'limit' | 'offset'> | undefined;
+    filterBuilder: FilterBuilder<MemberFilters, ChannelMemberSearchSourceFilterBuilderContext<TFilterContext>>;
+    constructor(channel: Channel, options?: SearchSourceOptions, filterBuilderOptions?: FilterBuilderOptions<MemberFilters, ChannelMemberSearchSourceFilterBuilderContext<TFilterContext>>);
+    canExecuteQuery: (newSearchString?: string) => boolean;
+    protected query(searchQuery: string): Promise<{
+        items: ChannelMemberResponse[];
+    }>;
+    protected filterQueryResults(items: ChannelMemberResponse[]): ChannelMemberResponse[];
+}
+export {};

package/dist/types/search/index.d.ts

@@ -1,4 +1,5 @@
 export * from './BaseSearchSource';
+export * from './ChannelMemberSearchSource';
 export * from './SearchController';
 export * from './UserSearchSource';
 export * from './ChannelSearchSource';

package/dist/types/utils/FixedSizeQueueCache.d.ts

@@ -28,4 +28,8 @@ export declare class FixedSizeQueueCache<K, T> {
      * @param key
      */
     get(key: K): T | undefined;
+    /**
+     * Clears queue entirely and disposes of each item individually.
+     */
+    clear(): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stream-chat",
-  "version": "9.45.5",
+  "version": "9.46.0",
   "description": "JS SDK for the Stream Chat API",
   "homepage": "https://getstream.io/chat/",
   "author": {

package/src/client.ts

@@ -293,6 +293,7 @@ import { StateStore } from './store';
 import type { MessageComposer } from './messageComposer';
 import type { AbstractOfflineDB } from './offline-support';
 import { getPendingTaskChannelData } from './offline-support/util';
+import { FixedSizeQueueCache } from './utils/FixedSizeQueueCache';
 
 function isString(x: unknown): x is string {
   return typeof x === 'string' || x instanceof String;
@@ -393,6 +394,7 @@ export class StreamChat {
   defaultWSTimeout: number;
   sdkIdentifier?: SdkIdentifier;
   deviceIdentifier?: DeviceIdentifier;
+  readonly messageComposerCache: FixedSizeQueueCache<string, MessageComposer>;
   private nextRequestAbortController: AbortController | null = null;
   /**
    * @private
@@ -573,6 +575,7 @@ export class StreamChat {
     this.polls = new PollManager({ client: this });
     this.reminders = new ReminderManager({ client: this });
     this.messageDeliveryReporter = new MessageDeliveryReporter({ client: this });
+    this.messageComposerCache = new FixedSizeQueueCache<string, MessageComposer>(64);
   }
 
   /**
@@ -1060,6 +1063,7 @@ export class StreamChat {
     // reset thread manager
     this.threads.resetState();
     this.uploadManager.reset();
+    this.messageComposerCache.clear();
 
     // Since we wipe all user data already, we should reset token manager as well
     closePromise

package/src/search/ChannelMemberSearchSource.ts

@@ -0,0 +1,85 @@
+import { BaseSearchSource } from './BaseSearchSource';
+import { FilterBuilder, type FilterBuilderOptions } from '../pagination';
+import type { Channel } from '../channel';
+import type {
+  ChannelMemberResponse,
+  MemberFilters,
+  MemberSort,
+  QueryMembersOptions,
+} from '../types';
+import type { SearchSourceOptions } from './types';
+
+type CustomContext = Record<string, unknown>;
+
+export type ChannelMemberSearchSourceFilterBuilderContext<
+  C extends CustomContext = CustomContext,
+> = { searchQuery?: string } & C;
+
+export class ChannelMemberSearchSource<
+  TFilterContext extends CustomContext = CustomContext,
+> extends BaseSearchSource<ChannelMemberResponse> {
+  readonly type = 'members';
+  channel: Channel;
+  filters: MemberFilters | undefined;
+  sort: MemberSort | undefined;
+  searchOptions: Omit<QueryMembersOptions, 'limit' | 'offset'> | undefined;
+  filterBuilder: FilterBuilder<
+    MemberFilters,
+    ChannelMemberSearchSourceFilterBuilderContext<TFilterContext>
+  >;
+
+  constructor(
+    channel: Channel,
+    options?: SearchSourceOptions,
+    filterBuilderOptions: FilterBuilderOptions<
+      MemberFilters,
+      ChannelMemberSearchSourceFilterBuilderContext<TFilterContext>
+    > = {},
+  ) {
+    super(options);
+    this.channel = channel;
+    this.filterBuilder = new FilterBuilder<
+      MemberFilters,
+      ChannelMemberSearchSourceFilterBuilderContext<TFilterContext>
+    >({
+      initialFilterConfig: {
+        default: {
+          enabled: true,
+          generate: ({ searchQuery }) =>
+            searchQuery
+              ? {
+                  $or: [
+                    { name: { $autocomplete: searchQuery } },
+                    { id: { $eq: searchQuery } },
+                  ],
+                }
+              : null,
+        },
+      },
+      ...filterBuilderOptions,
+    });
+  }
+
+  canExecuteQuery = (newSearchString?: string) => {
+    const hasNewSearchQuery = typeof newSearchString !== 'undefined';
+
+    return this.isActive && !this.isLoading && (this.hasNext || hasNewSearchQuery);
+  };
+
+  protected async query(searchQuery: string) {
+    const filters = this.filterBuilder.buildFilters({
+      baseFilters: this.filters,
+      context: {
+        searchQuery,
+      } as ChannelMemberSearchSourceFilterBuilderContext<TFilterContext>,
+    });
+    const sort = this.sort ?? [];
+    const options = { ...this.searchOptions, limit: this.pageSize, offset: this.offset };
+    const { members } = await this.channel.queryMembers(filters ?? {}, sort, options);
+    return { items: members };
+  }
+
+  protected filterQueryResults(items: ChannelMemberResponse[]) {
+    return items;
+  }
+}

package/src/search/MessageSearchSource.ts

@@ -130,7 +130,7 @@ export class MessageSearchSource<
   }
 
   protected async query(searchQuery: string) {
-    if (!this.client.userID || !searchQuery || this.next === null) return { items: [] };
+    if (!this.client.userID || this.next === null) return { items: [] };
 
     const channelFilters = this.messageSearchChannelFilterBuilder.buildFilters({
       baseFilters: {

package/src/search/index.ts

@@ -1,4 +1,5 @@
 export * from './BaseSearchSource';
+export * from './ChannelMemberSearchSource';
 export * from './SearchController';
 export * from './UserSearchSource';
 export * from './ChannelSearchSource';

package/src/utils/FixedSizeQueueCache.ts

@@ -71,4 +71,15 @@ export class FixedSizeQueueCache<K, T> {
 
     return foundItem;
   }
+
+  /**
+   * Clears queue entirely and disposes of each item individually.
+   */
+  clear() {
+    if (this.dispose) {
+      this.map.forEach((entry, key) => this.dispose?.(key, entry));
+    }
+    this.map.clear();
+    this.keys = [];
+  }
 }