stream-chat 9.50.3 → 10.0.0-rc.2

package/dist/types/ChannelManager.d.ts

@@ -0,0 +1,221 @@
+import { EventHandlerPipeline } from './EventHandlerPipeline';
+import { WithSubscriptions } from './utils/WithSubscriptions';
+import type { EventType } from './types';
+import type { ChannelPaginator } from './pagination';
+import type { StreamChat } from './client';
+import type { Unsubscribe } from './store';
+import { StateStore } from './store';
+import type { EventHandlerPipelineHandler, FindEventHandlerParams, InsertEventHandlerPayload, LabeledEventHandler } from './EventHandlerPipeline';
+import type { Channel } from './channel';
+export type ChannelManagerEventHandlerContext = {
+    channelManager: ChannelManager;
+};
+type EventHandlerContext = ChannelManagerEventHandlerContext;
+type SupportedEventType = EventType | (string & {});
+/**
+ * Resolves which paginators should be the "owners" of a channel
+ * when the channel matches multiple paginator filters.
+ *
+ * Return a set of paginator ids that should keep/own the item.
+ * Returning an empty set means the channel will be removed everywhere.
+ */
+export type PaginatorOwnershipResolver = (args: {
+    channel: Channel;
+    matchingPaginators: ChannelPaginator[];
+}) => string[];
+/**
+ * Convenience factory for a priority-based ownership resolver.
+ * - Provide an ordered list of paginator ids from highest to lowest priority.
+ * - If two or more paginators match a channel, the one with the highest priority wins.
+ * - If none of the matching paginator ids are in the priority list, all matches are kept (back-compat).
+ */
+export declare const createPriorityOwnershipResolver: (priority?: string[]) => PaginatorOwnershipResolver;
+export declare const ignoreEventsForUnknownChannels: EventHandlerPipelineHandler<EventHandlerContext>;
+export type ChannelManagerState = {
+    paginators: ChannelPaginator[];
+};
+export type ChannelManagerEventHandlers = Partial<Record<SupportedEventType, LabeledEventHandler<EventHandlerContext>[]>>;
+export type ChannelManagerOptions = {
+    client: StreamChat;
+    paginators?: ChannelPaginator[];
+    /**
+     * The complete set of event handlers to run, replacing the defaults rather than extending them.
+     * Start from `ChannelManager.getDefaultHandlers()` (a fresh copy) and enrich it, unless the
+     * intention really is to route events differently from scratch. Note that the manager the client
+     * instantiates (`client.channelManager`) is constructed without this option — customize that one
+     * through `addEventHandler` / `setEventHandlers` / `removeEventHandlers`.
+     */
+    eventHandlers?: ChannelManagerEventHandlers;
+    /**
+     * Decide which paginator(s) should own a channel when multiple match.
+     * Defaults to keeping the channel in all matching paginators.
+     * Channels are kept only in the paginators that are listed in the ownershipResolver array.
+     * Empty ownershipResolver array means that the channel is kept in all matching paginators.
+     */
+    ownershipResolver?: PaginatorOwnershipResolver | string[];
+};
+export declare class ChannelManager extends WithSubscriptions {
+    client: StreamChat;
+    state: StateStore<ChannelManagerState>;
+    protected _pipelines: Map<SupportedEventType, EventHandlerPipeline<ChannelManagerEventHandlerContext>>;
+    protected ownershipResolver?: PaginatorOwnershipResolver;
+    /**
+     * The `filterQueryResults` each registered paginator had before this manager wrapped it.
+     *
+     * A server query bypasses the manager — the paginator fetches and ingests a page on its own, and
+     * the backend knows nothing about client-side ownership — so a "Work" (`{ team: 'work' }`) channel
+     * comes back in a catch-all list's page too and would render in both. `wrapPaginatorFiltering`
+     * therefore composes the ownership check onto that hook, which every page passes through.
+     *
+     * Keys = already wrapped (so re-inserting does not wrap twice); values = what to restore on
+     * removal, since a detached paginator must stop applying rules resolved against lists it left.
+     * Weakly keyed so a dropped paginator is not kept alive by this manager.
+     */
+    protected filterQueryResultsBeforeWrapping: WeakMap<ChannelPaginator, (items: Channel[]) => Channel[]>;
+    protected static readonly defaultEventHandlers: ChannelManagerEventHandlers;
+    constructor({ client, eventHandlers, paginators, ownershipResolver, }: ChannelManagerOptions);
+    get paginators(): ChannelPaginator[];
+    get pipelines(): Map<SupportedEventType, EventHandlerPipeline<EventHandlerContext>>;
+    private get ctx();
+    /**
+     * Returns deep copy of default handlers mapping.
+     * The defaults can be enriched with custom handlers or the custom handlers can be replaced.
+     */
+    static getDefaultHandlers(): ChannelManagerEventHandlers;
+    /**
+     * Replace the rule deciding which paginator(s) own a channel matched by several of them. Pass an
+     * ordered array of paginator ids (highest priority first) for the built-in priority resolver, a
+     * custom resolver function, or `undefined` to go back to the default (a channel is kept in every
+     * paginator whose filter it matches).
+     *
+     * Available as a setter because the manager is constructed by the client, before the app has had
+     * a chance to create its paginators — their ids are therefore only known later.
+     */
+    setOwnershipResolver(ownershipResolver?: PaginatorOwnershipResolver | string[]): void;
+    /**
+     * Which paginators should own the channel among the ones that matched.
+     * Default behavior keeps the channel in all matching paginators.
+     */
+    resolveOwnership(channel: Channel, matchingPaginators: ChannelPaginator[]): Set<string>;
+    /**
+     * Route a channel into the paginator(s) that should own it, and remove it from any list it
+     * no longer belongs to. Ownership is resolved exactly as for live WS updates — the channel is
+     * ingested into every paginator whose filter it matches (or, when an ownership resolver picks
+     * winners among several matches, only into the owner(s)).
+     *
+     * Use this to surface a channel the app just opened — a search result, a freshly created DM —
+     * in the list(s) without a full re-query. `ingestItem` dedupes by cid and inserts in sort
+     * order, so calling this repeatedly is safe.
+     *
+     * A channel that matches no paginator is not added anywhere. To have such channels still
+     * appear, register a catch-all paginator (empty filter) with the lowest ownership priority as
+     * a local fallback list.
+     */
+    ingestChannel(channel: Channel): void;
+    /**
+     * Filter a page of query results for a specific paginator according to ownership rules.
+     * If no owners are specified by the resolver, all matching paginators keep the item.
+     */
+    protected filterItemsByOwnership({ paginator, items, }: {
+        paginator: ChannelPaginator;
+        items: Channel[];
+    }): Channel[];
+    /**
+     * Makes a registered paginator apply this manager's ownership rules to the pages it fetches
+     * itself, by composing `filterItemsByOwnership` onto its `filterQueryResults`.
+     *
+     * A channel can enter a list through two doors, and only one of them goes through the manager:
+     * - **WS events / `ingestChannel`** — the manager routes the channel and consults
+     *   `resolveOwnership` before ingesting, so exclusivity holds by construction.
+     * - **A server query** — `paginator.next()` (a `ChannelList` scrolling, `reload()`) queries and
+     *   ingests on its own; the manager is not involved. Without this wrapper a page would land in
+     *   every list whose *server-side* filter matched it, so a channel matching both
+     *   `channels:archived` and `channels:default` would show up in both lists until some later event
+     *   re-routed it — the exact duplication the resolver exists to prevent.
+     *
+     * Wrapping (rather than subclassing or a constructor hook) is what lets the manager inject this
+     * into paginators it does not construct: `filterQueryResults` is an instance property, so the
+     * original is captured here and handed back by `unwrapPaginatorFiltering` when the paginator is
+     * detached. The paginator's own filtering runs first and stays authoritative — ownership only ever
+     * removes further items, never adds any back.
+     *
+     * Idempotent: the `WeakMap` guard keeps a re-inserted paginator from being wrapped twice, which
+     * would filter the same page repeatedly and, worse, lose the reference to the true original.
+     */
+    protected wrapPaginatorFiltering(paginator: ChannelPaginator): void;
+    /**
+     * Undo `wrapPaginatorFiltering` — restore the `filterQueryResults` the paginator had before this
+     * manager wrapped it. A paginator that has left the manager must not keep applying its ownership
+     * rules: those are resolved against the paginators the manager still holds, so a detached
+     * paginator would drop channels owned by lists it is no longer part of.
+     */
+    protected unwrapPaginatorFiltering(paginator: ChannelPaginator): void;
+    getPaginatorById(id: string): ChannelPaginator | undefined;
+    /**
+     * Replace the whole set of lists in a single state update — the primitive `insertPaginator` and
+     * `removePaginator` build on, and what to use for a wholesale swap instead of publishing an
+     * intermediate state per step. Paginators dropped from the set are detached exactly as
+     * `removePaginator` detaches them; a repeated id keeps only its first occurrence.
+     *
+     * @param paginators - The lists this manager should hold, in render order.
+     */
+    setPaginators(paginators: ChannelPaginator[]): void;
+    /**
+     * Detach every list at once — the teardown counterpart of `setPaginators`. Each paginator is
+     * released exactly as `removePaginator` releases it (ownership-filtering wrapper removed,
+     * scheduled query canceled, loaded items kept), in a single state update.
+     *
+     * @returns The paginators the manager held, in the order it held them.
+     */
+    clearPaginators(): ChannelPaginator[];
+    /**
+     * If paginator already exists → remove old, reinsert at new index.
+     * If index not provided → append at the end.
+     * If index provided → insert (or move) at that index.
+     *
+     * @param params - The insertion parameters.
+     * @param params.paginator - The paginator to insert or move.
+     * @param params.index - Target index; when omitted the paginator is appended.
+     */
+    insertPaginator({ paginator, index }: {
+        paginator: ChannelPaginator;
+        index?: number;
+    }): void;
+    /**
+     * Remove a paginator from the manager. The paginator stops receiving WS-driven updates and
+     * disappears from `state.paginators` (so UIs rendering one list per paginator drop its list), and
+     * gets its own `filterQueryResults` back — from here on it is an independent paginator again.
+     *
+     * Its loaded items are left untouched: the paginator can be re-inserted later, or kept and
+     * queried on its own. Any query scheduled through `nextDebounced` is canceled, so a list that was
+     * just removed does not fire one more request.
+     *
+     * @param paginatorOrId - The paginator to remove, or its id.
+     * @returns The removed paginator, or `undefined` when this manager did not hold it.
+     */
+    removePaginator(paginatorOrId: ChannelPaginator | string): ChannelPaginator | undefined;
+    /**
+     * Discard the loaded data of every registered list, keeping the registrations themselves: which
+     * lists exist is application configuration, while the channels in them belong to the connected
+     * user and become invalid on `disconnectUser`. Each paginator returns to "never queried"
+     * (`items: undefined`) with its debounced query canceled. Deliberately not named `resetState` —
+     * this manager's own `state` *is* the paginator list, which this must not touch.
+     */
+    resetPaginatorStates(): void;
+    addEventHandler({ eventType, ...payload }: {
+        eventType: SupportedEventType;
+    } & InsertEventHandlerPayload<EventHandlerContext>): Unsubscribe;
+    setEventHandlers({ eventType, handlers, }: {
+        eventType: SupportedEventType;
+        handlers: LabeledEventHandler<EventHandlerContext>[];
+    }): void;
+    removeEventHandlers({ eventType, handlers, }: {
+        eventType: SupportedEventType;
+        handlers: FindEventHandlerParams<EventHandlerContext>[];
+    }): void;
+    /** Subscribe to WS (and more buses via attachBus) */
+    registerSubscriptions(): Unsubscribe;
+    ensurePipeline(eventType: SupportedEventType): EventHandlerPipeline<EventHandlerContext>;
+    reload: () => Promise<PromiseSettledResult<void>[]>;
+}
+export {};

package/dist/types/EventHandlerPipeline.d.ts

@@ -0,0 +1,104 @@
+import type { ChannelResponse, Event, EventType, MessageResponse, ReactionResponse, UserResponse } from './types';
+import type { Unsubscribe } from './store';
+/**
+ * Flat routing view of an event, as seen by pipeline handlers. The public `Event` type is now a
+ * discriminated union (each WS event exposes only its own fields) and also admits bare custom-event
+ * name strings — neither is convenient for the generic routers here, which only read a bounded set of
+ * common optional fields. Dispatched event *values* are always objects, so the pipeline casts to
+ * this view at the boundary (see `processOne`).
+ */
+export type PipelineEvent = {
+    type: EventType | (string & {});
+    channel?: ChannelResponse;
+    channel_id?: string;
+    channel_type?: string;
+    cid?: string;
+    created_at?: string | Date;
+    hard_delete?: boolean;
+    message?: MessageResponse;
+    reaction?: ReactionResponse;
+    user?: UserResponse;
+};
+type MatchById = {
+    id: string | RegExp;
+    regexMatch?: boolean;
+};
+export type FindEventHandlerParams<CTX extends Record<string, unknown>> = {
+    handler?: LabeledEventHandler<CTX> | EventHandlerPipelineHandler<CTX>;
+    idMatch?: MatchById;
+};
+export type EventHandlerResult = {
+    action: 'stop';
+};
+export type InsertEventHandlerPayload<CTX extends Record<string, unknown>> = {
+    handle: EventHandlerPipelineHandler<CTX>;
+    index?: number;
+    id?: string;
+    replace?: boolean;
+    revertOnUnsubscribe?: boolean;
+};
+export type EventHandlerPipelineHandler<CTX extends Record<string, unknown>> = (payload: {
+    event: PipelineEvent;
+    ctx: CTX;
+}) => EventHandlerResult | void | Promise<EventHandlerResult | void>;
+export type LabeledEventHandler<CTX extends Record<string, unknown>> = {
+    handle: EventHandlerPipelineHandler<CTX>;
+    id?: string;
+};
+export declare class EventHandlerPipeline<CTX extends Record<string, unknown> = {}> {
+    id: string;
+    protected handlers: LabeledEventHandler<CTX>[];
+    private runnerExecutionPromise;
+    constructor({ id }: {
+        id: string;
+    });
+    get size(): number;
+    findIndex({ handler, idMatch }: FindEventHandlerParams<CTX>): number;
+    /**
+     * Insert a handler into the pipeline at the given index.
+     *
+     * - If `replace` is `true` and the index is within bounds, the existing handler
+     *   at that position will be replaced by the new one.
+     *   - If `revertOnUnsubscribe` is also `true`, then calling the returned
+     *     unsubscribe will both remove the inserted handler *and* restore the
+     *     previously replaced handler at the same index.
+     * - If `replace` is `false` (default), the new handler is inserted at the index
+     *   (or appended if the index is greater than the pipeline size). Unsubscribe
+     *   will only remove this handler.
+     *
+     * @param payload - Insertion options.
+     * @param payload.handle - The handler function to insert.
+     * @param payload.index - Target index in the pipeline (clamped to valid range).
+     * @param payload.replace - If true, replace existing handler at index instead of inserting.
+     * @param payload.revertOnUnsubscribe - If true, restore the replaced handler when unsubscribing.
+     * @returns                   An unsubscribe function that removes (and optionally restores) the handler.
+     */
+    insert({ handle, id, index, replace, revertOnUnsubscribe, }: InsertEventHandlerPayload<CTX>): Unsubscribe;
+    /**
+     * Remove handler by:
+     * - handler function identity or
+     * - by id that could be an exact match or
+     * - match by regexp.
+     *
+     * @param params - {FindEventHandlerParams}
+     */
+    remove(params: FindEventHandlerParams<CTX>): void;
+    replaceAll(handlers: LabeledEventHandler<CTX>[]): void;
+    clear(): void;
+    /**
+     * Queue an event for processing. Events are processed serially, in the order
+     * `run` is called. Returns a promise that resolves/rejects for this specific
+     * event’s processing, while the internal chain continues (errors won’t break it).
+     */
+    run(event: Event, ctx: CTX): Promise<void>;
+    /**
+     * Wait until all queued events have been processed.
+     */
+    drain(): Promise<void>;
+    /**
+     * Process a single event through a stable snapshot of handlers to avoid
+     * mid-iteration mutations (insert/remove) affecting this run.
+     */
+    private processOne;
+}
+export {};

package/dist/types/api-client.d.ts

@@ -0,0 +1,26 @@
+import type { AxiosRequestConfig, Method } from 'axios';
+import type { RequestMetadata, SendFileAPIResponse, UserResponse } from './types';
+import type { StreamChat } from './client';
+export declare class ApiClient {
+    client: StreamChat;
+    private nextRequestAbortController;
+    constructor(client?: StreamChat);
+    _getToken(): string | undefined;
+    createAbortControllerForNextRequest(): AbortController;
+    sendRequest<T>(method: Method, url: string, pathParams?: Record<string, string>, queryParams?: Record<string, unknown>, body?: unknown, requestContentType?: string): Promise<{
+        body: T;
+        metadata: RequestMetadata;
+    }>;
+    doAxiosRequest<T>(type: string, url: string, data?: unknown, options?: AxiosRequestConfig): Promise<T>;
+    get<T>(url: string, params?: AxiosRequestConfig['params']): Promise<T>;
+    put<T>(url: string, data?: unknown): Promise<T>;
+    post<T>(url: string, data?: unknown): Promise<T>;
+    patch<T>(url: string, data?: unknown): Promise<T>;
+    delete<T>(url: string, params?: AxiosRequestConfig['params']): Promise<T>;
+    sendFile(url: string, uri: string | NodeJS.ReadableStream | Buffer | File, name?: string, contentType?: string, user?: UserResponse, axiosRequestConfig?: AxiosRequestConfig): Promise<SendFileAPIResponse>;
+    private resolveUrl;
+    private getNextAbortSignal;
+    populateRequestConfigWithDefaults(additonalConfig: AxiosRequestConfig): AxiosRequestConfig;
+    private extractMetadata;
+    private _doRequest;
+}

package/dist/types/campaign.d.ts

@@ -1,44 +0,0 @@
-import type { StreamChat } from './client';
-import type { CampaignData, GetCampaignOptions } from './types';
-export declare class Campaign {
-    id: string | null;
-    data?: CampaignData;
-    client: StreamChat;
-    constructor(client: StreamChat, id: string | null, data?: CampaignData);
-    create(): Promise<{
-        campaign: import("./types").CampaignResponse;
-        users: {
-            next?: string;
-            prev?: string;
-        };
-    } & import("./types").APIResponse>;
-    verifyCampaignId(): void;
-    start(options?: {
-        scheduledFor?: string;
-        stopAt?: string;
-    }): Promise<{
-        campaign: import("./types").CampaignResponse;
-        users: {
-            next?: string;
-            prev?: string;
-        };
-    } & import("./types").APIResponse>;
-    update(data: Partial<CampaignData>): Promise<{
-        campaign: import("./types").CampaignResponse;
-        users: {
-            next?: string;
-            prev?: string;
-        };
-    }>;
-    delete(): Promise<import("./types").APIResponse>;
-    stop(): Promise<{
-        campaign: import("./types").CampaignResponse;
-    }>;
-    get(options?: GetCampaignOptions): Promise<{
-        campaign: import("./types").CampaignResponse;
-        users: {
-            next?: string;
-            prev?: string;
-        };
-    } & import("./types").APIResponse>;
-}