stream-chat 9.50.3 → 10.0.0-rc.2

package/src/events.ts

@@ -1,75 +0,0 @@
-export const EVENT_MAP = {
-  'channel.created': true,
-  'channel.deleted': true,
-  'channel.hidden': true,
-  'channel.kicked': true,
-  'channel.muted': true,
-  'channel.truncated': true,
-  'channel.unmuted': true,
-  'channel.updated': true,
-  'channel.visible': true,
-  'draft.deleted': true,
-  'draft.updated': true,
-  'health.check': true,
-  'member.added': true,
-  'member.removed': true,
-  'member.updated': true,
-  'message.deleted': true,
-  'message.new': true,
-  'message.read': true,
-  'message.updated': true,
-  'message.undeleted': true,
-  'notification.added_to_channel': true,
-  'notification.channel_deleted': true,
-  'message.delivered': true,
-  'notification.channel_mutes_updated': true,
-  'notification.channel_truncated': true,
-  'notification.invite_accepted': true,
-  'notification.invite_rejected': true,
-  'notification.invited': true,
-  'notification.mark_read': true,
-  'notification.mark_unread': true,
-  'notification.message_new': true,
-  'notification.mutes_updated': true,
-  'notification.reminder_due': true,
-  'notification.removed_from_channel': true,
-  'notification.thread_message_new': true,
-  'poll.closed': true,
-  'poll.updated': true,
-  'poll.vote_casted': true,
-  'poll.vote_changed': true,
-  'poll.vote_removed': true,
-  'reaction.deleted': true,
-  'reaction.new': true,
-  'reaction.updated': true,
-  'reminder.created': true,
-  'reminder.deleted': true,
-  'reminder.updated': true,
-  'thread.updated': true,
-  'typing.start': true,
-  'typing.stop': true,
-  'user.banned': true,
-  'user.deleted': true,
-  'user.messages.deleted': true,
-  'user.presence.changed': true,
-  'user.unbanned': true,
-  'user.unread_message_reminder': true,
-  'user.updated': true,
-  'user.watching.start': true,
-  'user.watching.stop': true,
-  // AI events
-  'ai_indicator.update': true,
-  'ai_indicator.stop': true,
-  'ai_indicator.clear': true,
-
-  // local events
-  'message.read_locally': true,
-  'channels.queried': true,
-  'offline_reactions.queried': true,
-  'connection.changed': true,
-  'connection.recovered': true,
-  'transport.changed': true,
-  'capabilities.changed': true,
-  'live_location_sharing.started': true,
-  'live_location_sharing.stopped': true,
-};

package/src/pagination/BasePaginator.ts

@@ -1,184 +0,0 @@
-import { StateStore } from '../store';
-import { debounce, type DebouncedFunc } from '../utils';
-
-type PaginationDirection = 'next' | 'prev';
-type Cursor = { next: string | null; prev: string | null };
-export type PaginationQueryParams = { direction: PaginationDirection };
-export type PaginationQueryReturnValue<T> = { items: T[] } & {
-  next?: string;
-  prev?: string;
-};
-export type PaginatorDebounceOptions = {
-  debounceMs: number;
-};
-type DebouncedExecQueryFunction = DebouncedFunc<
-  (params: { direction: PaginationDirection }) => Promise<void>
->;
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type PaginatorState<T = any> = {
-  hasNext: boolean;
-  hasPrev: boolean;
-  isLoading: boolean;
-  items: T[] | undefined;
-  lastQueryError?: Error;
-  cursor?: Cursor;
-  offset?: number;
-};
-
-export type PaginatorOptions = {
-  /** The number of milliseconds to debounce the search query. The default interval is 300ms. */
-  debounceMs?: number;
-  pageSize?: number;
-};
-export const DEFAULT_PAGINATION_OPTIONS: Required<PaginatorOptions> = {
-  debounceMs: 300,
-  pageSize: 10,
-} as const;
-
-export abstract class BasePaginator<T> {
-  state: StateStore<PaginatorState<T>>;
-  pageSize: number;
-  protected _executeQueryDebounced!: DebouncedExecQueryFunction;
-  protected _isCursorPagination = false;
-
-  protected constructor(options?: PaginatorOptions) {
-    const { debounceMs, pageSize } = { ...DEFAULT_PAGINATION_OPTIONS, ...options };
-    this.pageSize = pageSize;
-    this.state = new StateStore<PaginatorState<T>>(this.initialState);
-    this.setDebounceOptions({ debounceMs });
-  }
-
-  get lastQueryError() {
-    return this.state.getLatestValue().lastQueryError;
-  }
-
-  get hasNext() {
-    return this.state.getLatestValue().hasNext;
-  }
-
-  get hasPrev() {
-    return this.state.getLatestValue().hasPrev;
-  }
-
-  get hasResults() {
-    return Array.isArray(this.state.getLatestValue().items);
-  }
-
-  get isLoading() {
-    return this.state.getLatestValue().isLoading;
-  }
-
-  get initialState(): PaginatorState {
-    return {
-      hasNext: true,
-      hasPrev: true, //todo: check if optimistic value does not cause problems in UI
-      isLoading: false,
-      items: undefined,
-      lastQueryError: undefined,
-      cursor: undefined,
-      offset: 0,
-    };
-  }
-
-  get items() {
-    return this.state.getLatestValue().items;
-  }
-
-  get cursor() {
-    return this.state.getLatestValue().cursor;
-  }
-
-  get offset() {
-    return this.state.getLatestValue().offset;
-  }
-
-  abstract query(params: PaginationQueryParams): Promise<PaginationQueryReturnValue<T>>;
-
-  abstract filterQueryResults(items: T[]): T[] | Promise<T[]>;
-
-  setDebounceOptions = ({ debounceMs }: PaginatorDebounceOptions) => {
-    this._executeQueryDebounced = debounce(this.executeQuery.bind(this), debounceMs);
-  };
-
-  canExecuteQuery = (direction: PaginationDirection) =>
-    (!this.isLoading && direction === 'next' && this.hasNext) ||
-    (direction === 'prev' && this.hasPrev);
-
-  protected getStateBeforeFirstQuery(): PaginatorState<T> {
-    return {
-      ...this.initialState,
-      isLoading: true,
-    };
-  }
-
-  protected getStateAfterQuery(
-    stateUpdate: Partial<PaginatorState<T>>,
-    isFirstPage: boolean,
-  ): PaginatorState<T> {
-    const current = this.state.getLatestValue();
-    return {
-      ...current,
-      lastQueryError: undefined, // reset lastQueryError that can be overridden by the stateUpdate
-      ...stateUpdate,
-      isLoading: false,
-      items: isFirstPage
-        ? stateUpdate.items
-        : [...(this.items ?? []), ...(stateUpdate.items || [])],
-    };
-  }
-
-  async executeQuery({ direction }: { direction: PaginationDirection }) {
-    if (!this.canExecuteQuery(direction)) return;
-    const isFirstPage = typeof this.items === 'undefined';
-    if (isFirstPage) {
-      this.state.next(this.getStateBeforeFirstQuery());
-    } else {
-      this.state.partialNext({ isLoading: true });
-    }
-
-    const stateUpdate: Partial<PaginatorState<T>> = {};
-    try {
-      const results = await this.query({ direction });
-      if (!results) return;
-      const { items, next, prev } = results;
-      if (isFirstPage && (next || prev)) {
-        this._isCursorPagination = true;
-      }
-
-      if (this._isCursorPagination) {
-        stateUpdate.cursor = { next: next || null, prev: prev || null };
-        stateUpdate.hasNext = !!next;
-        stateUpdate.hasPrev = !!prev;
-      } else {
-        stateUpdate.offset = (this.offset ?? 0) + items.length;
-        stateUpdate.hasNext = items.length === this.pageSize;
-      }
-
-      stateUpdate.items = await this.filterQueryResults(items);
-    } catch (e) {
-      stateUpdate.lastQueryError = e as Error;
-    } finally {
-      this.state.next(this.getStateAfterQuery(stateUpdate, isFirstPage));
-    }
-  }
-
-  cancelScheduledQuery() {
-    this._executeQueryDebounced.cancel();
-  }
-
-  resetState() {
-    this.state.next(this.initialState);
-  }
-
-  next = () => this.executeQuery({ direction: 'next' });
-
-  prev = () => this.executeQuery({ direction: 'prev' });
-
-  nextDebounced = () => {
-    this._executeQueryDebounced({ direction: 'next' });
-  };
-  prevDebounced = () => {
-    this._executeQueryDebounced({ direction: 'prev' });
-  };
-}

package/src/pagination/ReminderPaginator.ts

@@ -1,56 +0,0 @@
-import { BasePaginator } from './BasePaginator';
-import type {
-  PaginationQueryParams,
-  PaginationQueryReturnValue,
-  PaginatorOptions,
-} from './BasePaginator';
-import type { ReminderFilters, ReminderResponse, ReminderSort } from '../types';
-import type { StreamChat } from '../client';
-
-export class ReminderPaginator extends BasePaginator<ReminderResponse> {
-  private client: StreamChat;
-  protected _filters: ReminderFilters | undefined;
-  protected _sort: ReminderSort | undefined;
-
-  get filters(): ReminderFilters | undefined {
-    return this._filters;
-  }
-
-  get sort(): ReminderSort | undefined {
-    return this._sort;
-  }
-
-  set filters(filters: ReminderFilters | undefined) {
-    this._filters = filters;
-    this.resetState();
-  }
-
-  set sort(sort: ReminderSort | undefined) {
-    this._sort = sort;
-    this.resetState();
-  }
-
-  constructor(client: StreamChat, options?: PaginatorOptions) {
-    super(options);
-    this.client = client;
-  }
-
-  query = async ({
-    direction,
-  }: PaginationQueryParams): Promise<PaginationQueryReturnValue<ReminderResponse>> => {
-    const cursor = this.cursor?.[direction];
-    const {
-      reminders: items,
-      next,
-      prev,
-    } = await this.client.queryReminders({
-      filter: this.filters,
-      sort: this.sort,
-      limit: this.pageSize,
-      [direction]: cursor,
-    });
-    return { items, next, prev };
-  };
-
-  filterQueryResults = (items: ReminderResponse[]) => items;
-}

package/src/pagination/UserGroupPaginator.ts

@@ -1,93 +0,0 @@
-import { BasePaginator } from './BasePaginator';
-import type {
-  PaginationQueryParams,
-  PaginationQueryReturnValue,
-  PaginatorOptions,
-  PaginatorState,
-} from './BasePaginator';
-import type { QueryUserGroupsOptions, UserGroupResponse } from '../types';
-import type { StreamChat } from '../client';
-
-type UserGroupListCursor = {
-  created_at_gt: string;
-  id_gt: string;
-};
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === 'object' && value !== null;
-
-const decodeCursor = <TCursor extends object>(cursor: string | null | undefined) => {
-  if (!cursor) return undefined;
-
-  try {
-    const parsed = JSON.parse(cursor);
-    return isRecord(parsed) ? (parsed as TCursor) : undefined;
-  } catch {
-    return undefined;
-  }
-};
-
-/**
- * Paginates user-group listing through `/usergroups`.
- *
- * This entity only supports forward cursor pagination via `created_at_gt` and `id_gt`.
- * Previous-page pagination is not available because the API does not expose a backward cursor.
- */
-export class UserGroupPaginator extends BasePaginator<UserGroupResponse> {
-  private client: StreamChat;
-  protected _teamId: string | undefined;
-
-  constructor(client: StreamChat, options?: PaginatorOptions) {
-    super(options);
-    this.client = client;
-  }
-
-  get initialState(): PaginatorState<UserGroupResponse> {
-    return {
-      ...super.initialState,
-      hasPrev: false,
-    };
-  }
-
-  get teamId() {
-    return this._teamId;
-  }
-
-  set teamId(teamId: string | undefined) {
-    if (teamId === this._teamId) return;
-    this._teamId = teamId;
-    this.resetState();
-  }
-
-  private buildNextCursor = (items: UserGroupResponse[]) => {
-    if (items.length < this.pageSize) return undefined;
-    const lastItem = items[items.length - 1];
-    if (!lastItem) return undefined;
-
-    return JSON.stringify({
-      created_at_gt: lastItem.created_at,
-      id_gt: lastItem.id,
-    } satisfies UserGroupListCursor);
-  };
-
-  query = async ({
-    direction,
-  }: PaginationQueryParams): Promise<PaginationQueryReturnValue<UserGroupResponse>> => {
-    if (direction === 'prev') {
-      return { items: [] };
-    }
-
-    const cursor = decodeCursor<UserGroupListCursor>(this.cursor?.next);
-    const options: QueryUserGroupsOptions = {
-      limit: this.pageSize,
-      ...(this.teamId ? { team_id: this.teamId } : {}),
-      ...(cursor?.id_gt ? { id_gt: cursor.id_gt } : {}),
-      ...(cursor?.created_at_gt ? { created_at_gt: cursor.created_at_gt } : {}),
-    };
-
-    const { user_groups: items } = await this.client.queryUserGroups(options);
-    return { items, next: this.buildNextCursor(items) };
-  };
-
-  filterQueryResults = (items: UserGroupResponse[]) => items;
-}