stream-chat 9.50.3 → 10.0.0-rc.2

package/dist/types/channel_manager.d.ts

@@ -1,122 +0,0 @@
-import type { QueryChannelsResponseWithChannels, StreamChat } from './client';
-import type { ChannelFilters, ChannelOptions, ChannelSort, ChannelStateOptions, Event } from './types';
-import type { ValueOrPatch } from './store';
-import { StateStore } from './store';
-import type { Channel } from './channel';
-import { WithSubscriptions } from './utils/WithSubscriptions';
-export type ChannelManagerPagination = {
-    filters: ChannelFilters;
-    hasNext: boolean;
-    isLoading: boolean;
-    isLoadingNext: boolean;
-    options: ChannelOptions;
-    responseFilters?: ChannelFilters;
-    responseSort?: ChannelSort;
-    sort: ChannelSort;
-};
-export type ChannelManagerState = {
-    channels: Channel[];
-    /**
-     * This value will become true the first time queryChannels is successfully executed and
-     * will remain false otherwise. It's used as a control property regarding whether the list
-     * has been initialized yet (i.e a query has already been done at least once) or not. We do
-     * this to prevent state.channels from being forced to be nullable.
-     */
-    initialized: boolean;
-    pagination: ChannelManagerPagination;
-    error: Error | undefined;
-};
-export type ChannelSetterParameterType = ValueOrPatch<ChannelManagerState['channels']>;
-export type ChannelSetterType = (arg: ChannelSetterParameterType) => void;
-export type GenericEventHandlerType<T extends unknown[]> = (...args: T) => void | (() => void) | ((...args: T) => Promise<void>) | Promise<void>;
-export type EventHandlerType = GenericEventHandlerType<[Event]>;
-export type EventHandlerOverrideType = GenericEventHandlerType<[
-    ChannelSetterType,
-    Event
-]>;
-export type ChannelManagerEventTypes = 'notification.added_to_channel' | 'notification.message_new' | 'notification.removed_from_channel' | 'message.new' | 'member.updated' | 'channel.deleted' | 'channel.hidden' | 'channel.truncated' | 'channel.visible' | 'channel.updated';
-export type ChannelManagerEventHandlerNames = 'channelDeletedHandler' | 'channelHiddenHandler' | 'channelTruncatedHandler' | 'channelUpdatedHandler' | 'channelVisibleHandler' | 'newMessageHandler' | 'memberUpdatedHandler' | 'notificationAddedToChannelHandler' | 'notificationNewMessageHandler' | 'notificationRemovedFromChannelHandler';
-export type ChannelManagerEventHandlerOverrides = Partial<Record<ChannelManagerEventHandlerNames, EventHandlerOverrideType>>;
-export type ExecuteChannelsQueryPayload = Pick<ChannelManagerPagination, 'filters' | 'sort' | 'options'> & {
-    stateOptions: ChannelStateOptions;
-};
-export declare const channelManagerEventToHandlerMapping: {
-    [key in ChannelManagerEventTypes]: ChannelManagerEventHandlerNames;
-};
-export type ChannelManagerOptions = {
-    /**
-     * Aborts a channels query that is already in progress and runs the new one.
-     */
-    abortInFlightQuery?: boolean;
-    /**
-     * Allows channel promotion to be applied where applicable for channels that are
-     * currently not part of the channel list within the state. A good example of
-     * this would be a channel that is being watched and it receives a new message,
-     * but is not part of the list initially.
-     */
-    allowNotLoadedChannelPromotionForEvent?: {
-        'channel.visible': boolean;
-        'message.new': boolean;
-        'notification.added_to_channel': boolean;
-        'notification.message_new': boolean;
-    };
-    /**
-     * Allows us to lock the order of channels within the list. Any event that would
-     * change the order of channels within the list will do nothing.
-     */
-    lockChannelOrder?: boolean;
-};
-export type QueryChannelsRequestOutput = Channel[] | QueryChannelsResponseWithChannels;
-export type QueryChannelsRequestType = (filters: ChannelFilters, sort?: ChannelSort, options?: ChannelOptions, stateOptions?: ChannelStateOptions) => Promise<QueryChannelsRequestOutput>;
-export declare const DEFAULT_CHANNEL_MANAGER_OPTIONS: {
-    abortInFlightQuery: boolean;
-    allowNotLoadedChannelPromotionForEvent: {
-        'channel.visible': boolean;
-        'message.new': boolean;
-        'notification.added_to_channel': boolean;
-        'notification.message_new': boolean;
-    };
-    lockChannelOrder: boolean;
-};
-export declare const DEFAULT_CHANNEL_MANAGER_PAGINATION_OPTIONS: {
-    offset: number;
-};
-/**
- * A class that manages a list of channels and changes it based on configuration and WS events. The
- * list of channels is reactive as well as the pagination and it can be subscribed to for state updates.
- *
- * @internal
- */
-export declare class ChannelManager extends WithSubscriptions {
-    readonly state: StateStore<ChannelManagerState>;
-    private client;
-    private eventHandlers;
-    private eventHandlerOverrides;
-    private queryChannelsRequest;
-    private options;
-    private stateOptions;
-    private id;
-    constructor({ client, eventHandlerOverrides, options, queryChannelsOverride, }: {
-        client: StreamChat;
-        eventHandlerOverrides?: ChannelManagerEventHandlerOverrides;
-        options?: ChannelManagerOptions;
-        queryChannelsOverride?: QueryChannelsRequestType;
-    });
-    setChannels: (valueOrFactory: ChannelSetterParameterType) => void;
-    setEventHandlerOverrides: (eventHandlerOverrides?: ChannelManagerEventHandlerOverrides) => void;
-    setQueryChannelsRequest: (queryChannelsRequest: QueryChannelsRequestType) => void;
-    setOptions: (options?: ChannelManagerOptions) => void;
-    private executeChannelsQuery;
-    queryChannels: (filters: ChannelFilters, sort?: ChannelSort, options?: ChannelOptions, stateOptions?: ChannelStateOptions) => Promise<void>;
-    loadNext: () => Promise<void>;
-    private notificationAddedToChannelHandler;
-    private channelDeletedHandler;
-    private channelHiddenHandler;
-    private newMessageHandler;
-    private notificationNewMessageHandler;
-    private channelVisibleHandler;
-    private notificationRemovedFromChannelHandler;
-    private memberUpdatedHandler;
-    private subscriptionOrOverride;
-    registerSubscriptions: () => void;
-}

package/dist/types/events.d.ts

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

package/dist/types/pagination/BasePaginator.d.ts

@@ -1,69 +0,0 @@
-import { StateStore } from '../store';
-import { 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>>;
-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 declare const DEFAULT_PAGINATION_OPTIONS: Required<PaginatorOptions>;
-export declare abstract class BasePaginator<T> {
-    state: StateStore<PaginatorState<T>>;
-    pageSize: number;
-    protected _executeQueryDebounced: DebouncedExecQueryFunction;
-    protected _isCursorPagination: boolean;
-    protected constructor(options?: PaginatorOptions);
-    get lastQueryError(): Error | undefined;
-    get hasNext(): boolean;
-    get hasPrev(): boolean;
-    get hasResults(): boolean;
-    get isLoading(): boolean;
-    get initialState(): PaginatorState;
-    get items(): T[] | undefined;
-    get cursor(): Cursor | undefined;
-    get offset(): number | undefined;
-    abstract query(params: PaginationQueryParams): Promise<PaginationQueryReturnValue<T>>;
-    abstract filterQueryResults(items: T[]): T[] | Promise<T[]>;
-    setDebounceOptions: ({ debounceMs }: PaginatorDebounceOptions) => void;
-    canExecuteQuery: (direction: PaginationDirection) => boolean;
-    protected getStateBeforeFirstQuery(): PaginatorState<T>;
-    protected getStateAfterQuery(stateUpdate: Partial<PaginatorState<T>>, isFirstPage: boolean): PaginatorState<T>;
-    executeQuery({ direction }: {
-        direction: PaginationDirection;
-    }): Promise<void>;
-    cancelScheduledQuery(): void;
-    resetState(): void;
-    next: () => Promise<void>;
-    prev: () => Promise<void>;
-    nextDebounced: () => void;
-    prevDebounced: () => void;
-}
-export {};

package/dist/types/pagination/ReminderPaginator.d.ts

@@ -1,16 +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 declare class ReminderPaginator extends BasePaginator<ReminderResponse> {
-    private client;
-    protected _filters: ReminderFilters | undefined;
-    protected _sort: ReminderSort | undefined;
-    get filters(): ReminderFilters | undefined;
-    get sort(): ReminderSort | undefined;
-    set filters(filters: ReminderFilters | undefined);
-    set sort(sort: ReminderSort | undefined);
-    constructor(client: StreamChat, options?: PaginatorOptions);
-    query: ({ direction, }: PaginationQueryParams) => Promise<PaginationQueryReturnValue<ReminderResponse>>;
-    filterQueryResults: (items: ReminderResponse[]) => ReminderResponse[];
-}

package/dist/types/pagination/UserGroupPaginator.d.ts

@@ -1,21 +0,0 @@
-import { BasePaginator } from './BasePaginator';
-import type { PaginationQueryParams, PaginationQueryReturnValue, PaginatorOptions, PaginatorState } from './BasePaginator';
-import type { UserGroupResponse } from '../types';
-import type { StreamChat } from '../client';
-/**
- * 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 declare class UserGroupPaginator extends BasePaginator<UserGroupResponse> {
-    private client;
-    protected _teamId: string | undefined;
-    constructor(client: StreamChat, options?: PaginatorOptions);
-    get initialState(): PaginatorState<UserGroupResponse>;
-    get teamId(): string | undefined;
-    set teamId(teamId: string | undefined);
-    private buildNextCursor;
-    query: ({ direction, }: PaginationQueryParams) => Promise<PaginationQueryReturnValue<UserGroupResponse>>;
-    filterQueryResults: (items: UserGroupResponse[]) => UserGroupResponse[];
-}