stream-chat 9.50.2 → 10.0.0-rc.1

package/dist/types/ChannelPaginatorsOrchestrator.d.ts

@@ -0,0 +1,130 @@
+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 ChannelPaginatorsOrchestratorEventHandlerContext = {
+    orchestrator: ChannelPaginatorsOrchestrator;
+};
+type EventHandlerContext = ChannelPaginatorsOrchestratorEventHandlerContext;
+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 ChannelPaginatorsOrchestratorState = {
+    paginators: ChannelPaginator[];
+};
+export type ChannelPaginatorsOrchestratorEventHandlers = Partial<Record<SupportedEventType, LabeledEventHandler<EventHandlerContext>[]>>;
+export type ChannelPaginatorsOrchestratorOptions = {
+    client: StreamChat;
+    paginators?: ChannelPaginator[];
+    eventHandlers?: ChannelPaginatorsOrchestratorEventHandlers;
+    /**
+     * 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 ChannelPaginatorsOrchestrator extends WithSubscriptions {
+    client: StreamChat;
+    state: StateStore<ChannelPaginatorsOrchestratorState>;
+    protected _pipelines: Map<SupportedEventType, EventHandlerPipeline<ChannelPaginatorsOrchestratorEventHandlerContext>>;
+    protected ownershipResolver?: PaginatorOwnershipResolver;
+    /** Track paginators already wrapped with ownership-aware filtering */
+    protected ownershipFilterAppliedPaginators: WeakSet<ChannelPaginator>;
+    protected static readonly defaultEventHandlers: ChannelPaginatorsOrchestratorEventHandlers;
+    constructor({ client, eventHandlers, paginators, ownershipResolver, }: ChannelPaginatorsOrchestratorOptions);
+    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(): ChannelPaginatorsOrchestratorEventHandlers;
+    /**
+     * 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[];
+    /**
+     * Wrap paginator.filterQueryResults so that ownership rules are applied whenever
+     * the paginator ingests results from a server query (first page and subsequent pages).
+     */
+    protected wrapPaginatorFiltering(paginator: ChannelPaginator): void;
+    getPaginatorById(id: string): ChannelPaginator | undefined;
+    /**
+     * 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;
+    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>;
-}