@ethora/chat-component 26.10.7 → 26.10.8

package/dist/{VisibilityModal-pOF9-UXR.js → VisibilityModal-BXyIy7_J.js}

@@ -1,7 +1,7 @@
 import { jsxs as r, jsx as s } from "react/jsx-runtime";
 import { useState as b, useEffect as x } from "react";
-import { U as o, a as L, M as P, u as U, b4 as D, b5 as z } from "./main-CpHMnydn.js";
-import { S as I, D as C, a as $, b as k, e as w, f as p } from "./SideDrawer-CqZl9sxK.js";
+import { a4 as o, a as L, Z as P, u as z, bg as D, bh as I } from "./main-B25iFKAC.js";
+import { S as N, D as C, a as $, b as k, e as w, f as p } from "./SideDrawer-A_1ECqD2.js";
 o.div``;
 o.div`
   font-size: 16px;
@@ -25,7 +25,7 @@ const O = o.div`
 `, u = o.input`
   accent-color: ${({ $radioColor: i }) => i || "var(--ethora-color-primary, #0052CD)"};
   margin: 0px;
-`, M = o.div`
+`, R = o.div`
   padding: 10px 15px;
   margin-top: 16px;
   color: ${({ type: i }) => i === "success" ? "#10b981" : "#ef4444"};
@@ -42,9 +42,9 @@ const O = o.div`
 `, B = ({
   handleCloseModal: i
 }) => {
-  const S = L(), e = P(), { user: n, config: l } = U(
+  const S = L(), e = P(), { user: n, config: l } = z(
     (t) => t.chatSettingStore
-  ), g = (t) => S(z(t)), [a, m] = b(n?.isProfileOpen), [c, v] = b(n?.isAssetsOpen), [f, y] = b(null), d = (t, A) => {
+  ), g = (t) => S(I(t)), [a, m] = b(n?.isProfileOpen), [c, v] = b(n?.isAssetsOpen), [f, y] = b(null), d = (t, A) => {
     y({ message: t, type: A }), setTimeout(() => y(null), 3e3);
   };
   return x(() => {
@@ -56,7 +56,7 @@ const O = o.div`
       g(t.user), d(e("notification.saved"), "success");
     }).catch(() => d(e("toast.error"), "error"));
   }, [c]), /* @__PURE__ */ r(
-    I,
+    N,
     {
       title: e("settings.visibility.title"),
       onClose: i,
@@ -128,7 +128,7 @@ const O = o.div`
             /* @__PURE__ */ s(p, { children: e("settings.visibility.individualDescription") })
           ] }) }) })
         ] }),
-        f && /* @__PURE__ */ s(M, { type: f.type, children: f.message })
+        f && /* @__PURE__ */ s(R, { type: f.type, children: f.message })
       ]
     }
   );

package/dist/assets/icons.d.ts

@@ -43,6 +43,10 @@ export declare const VideoCallIcon: ({ color, ...props }: {
     [x: string]: any;
     color?: string;
 }) => import("react/jsx-runtime").JSX.Element;
+export declare const CalendarIcon: ({ color, ...props }: {
+    [x: string]: any;
+    color?: string;
+}) => import("react/jsx-runtime").JSX.Element;
 export declare const AudioCallIcon: ({ color, ...props }: {
     [x: string]: any;
     color?: string;

package/dist/calls/callDisplay.d.ts

@@ -0,0 +1,22 @@
+/** Shown on the ring screen when no human-readable name is known. */
+export declare const NEUTRAL_INCOMING_CALL_LABEL = "Incoming call";
+/**
+ * True for strings that are a chat's internal name or an id rather than
+ * something a person would be called: two user JIDs joined (the private chat
+ * name), a lone user id, an `<appId>_<uuid>` group name, or any long run of
+ * hex / underscore / hyphen.
+ */
+export declare const looksLikeRawRoomName: (value: unknown) => boolean;
+/**
+ * Plain-text, display-safe version of a name: control characters stripped,
+ * whitespace collapsed and trimmed, capped at about 80 characters. Returns ''
+ * when nothing usable is left or the value is a raw chat name / id.
+ */
+export declare const sanitizeCallName: (value: unknown) => string;
+/** sanitizeCallName with null instead of '' (state-friendly). */
+export declare const safeCallName: (value: unknown) => string | null;
+/**
+ * An xmppUsername from a stanza attribute, or null when it is not shaped like
+ * one (it is only ever used for lookups and routing, never shown).
+ */
+export declare const sanitizeXmppUsername: (value: unknown) => string | null;

package/dist/calls/callMode.d.ts

@@ -0,0 +1,105 @@
+export type CallMode = 'livekit' | 'p2p';
+export type CallKindName = 'audio' | 'video';
+export type CallRoomType = 'private' | 'group';
+/** Serializable subset of RTCIceServer (kept free of DOM types for redux). */
+export interface IceServerConfig {
+    urls: string | string[];
+    username?: string;
+    credential?: string;
+}
+/**
+ * Accepts an array, an `{ iceServers }` envelope or a JSON string of either
+ * (the call-token stanza carries the list as a JSON attribute) and returns
+ * only well formed stun/turn entries. Anything else is dropped, never thrown.
+ */
+export declare const normalizeIceServers: (raw: unknown) => IceServerConfig[];
+/**
+ * A LiveKit server URL as the backend publishes it. Only websocket / http(s)
+ * URLs are accepted: the value ends up as the connect target of the media
+ * session, so anything else (javascript:, data:, garbage) is treated as unset.
+ */
+export declare const normalizeLivekitUrl: (raw: unknown) => string | null;
+/** Attributes of a `<data type="call-token">` element, defensively read. */
+export interface ParsedCallTokenAttrs {
+    token: string;
+    room: string;
+    /** Raw `callId` attribute, null when absent (the JWT may still carry it). */
+    callId: string | null;
+    /** Valid `kind` attribute, null when absent or unrecognised. */
+    kind: CallKindName | null;
+    mode: CallMode;
+    group: boolean;
+    /** Callee's ICE servers for `mode=p2p`, null when absent or unparseable. */
+    iceServers: IceServerConfig[] | null;
+    /**
+     * Public LiveKit wss URL for `mode=livekit`, null when the server did not
+     * send one (older backends), it is empty, or it is not a usable URL.
+     */
+    livekitUrl: string | null;
+    /**
+     * Caller's display name as plain text (control characters stripped, capped,
+     * raw chat names refused); '' when absent. Only trustworthy from the system
+     * account, see calls/senderTrust.
+     */
+    callerName: string;
+    /** Caller's xmppUsername when well formed, else null. Same trust rule. */
+    caller: string | null;
+}
+/**
+ * Tolerant reader for the call-token stanza. A server that sends neither
+ * `mode` nor `group` (every server before P2P / group calls) yields
+ * `mode: 'livekit'`, `group: false`, i.e. exactly the legacy behaviour.
+ */
+export declare const parseCallTokenAttrs: (attrs: Record<string, any> | undefined | null) => ParsedCallTokenAttrs;
+/** Normalised `POST /v1/chats/call/create/:chatName` response. */
+export interface CallCreateResult {
+    callId: string | null;
+    mode: CallMode;
+    kind: CallKindName;
+    /** Server-reported group flag, null when the server did not say. */
+    group: boolean | null;
+    /** Public LiveKit wss URL when the server knows it. */
+    livekitUrl: string | null;
+    iceServers: IceServerConfig[];
+    ttlSeconds: number | null;
+}
+/**
+ * Reads the create response. Old servers answer with no `mode`, which maps to
+ * `livekit` (the caller then waits for its own call-token as before). A p2p
+ * answer without a callId is unusable (no way to correlate signalling) and
+ * throws.
+ */
+export declare const parseCallCreateResponse: (data: unknown, fallbackKind: CallKindName) => CallCreateResult;
+/**
+ * Which room types may start / receive calls. Hosts that never set
+ * `allowedRoomTypes` get 1:1 and group chats; an explicit list is respected
+ * as written (so `['private']` keeps a host on 1:1 only).
+ */
+export declare const DEFAULT_CALL_ROOM_TYPES: CallRoomType[];
+export declare const isCallRoomTypeAllowed: (roomType: string | undefined | null, allowedRoomTypes?: CallRoomType[] | null) => boolean;
+export interface BusyCallSnapshot {
+    phase: string;
+    direction: 'incoming' | 'outgoing' | null;
+    mode: CallMode;
+    callId: string | null;
+    roomBareName: string | null;
+}
+/**
+ * What to do with an incoming call-token while another call may be active.
+ *  - accept:      nothing active, ring.
+ *  - duplicate:   same callId as the active call (server re-delivery), ignore.
+ *  - replace:     legacy LiveKit behaviour (a new token overwrites the old
+ *                 call), kept exactly for livekit-vs-livekit.
+ *  - glare-yield: both sides dialled each other; the lexicographically smaller
+ *                 callId wins on BOTH ends, and this is the loser: drop our
+ *                 outgoing call and ring for theirs.
+ *  - glare-keep:  same race, we hold the winning callId, ignore theirs (the
+ *                 other side yields).
+ *  - busy:        a different call is in progress, decline the newcomer.
+ */
+export type IncomingWhileBusyDecision = 'accept' | 'duplicate' | 'replace' | 'glare-yield' | 'glare-keep' | 'busy';
+export declare const decideIncomingWhileBusy: (current: BusyCallSnapshot, incoming: {
+    mode: CallMode;
+    callId: string | null;
+    roomBareName: string | null;
+}) => IncomingWhileBusyDecision;

package/dist/calls/openScheduledCall.d.ts

@@ -0,0 +1,20 @@
+import { ScheduledCallLinkOptions } from './scheduledCall';
+/**
+ * Asks the chat to open a scheduled call: select its room and show the
+ * pre-join panel. Returns false (and does nothing) when `slug` is not a
+ * plausible slug. The request waits in the store until a signed-in <Chat> is
+ * mounted, so a deep link can be passed in before either is ready; failures
+ * are reported through `config.scheduledCalls.onOpenError`.
+ */
+export declare function openScheduledCall(slug: string): boolean;
+/**
+ * The slug of a scheduled-call join link (`https://<host>/call/<slug>` or
+ * `<scheme>://call/<slug>`), or null when `url` is not one. The hosted web app
+ * (`DEFAULT_SCHEDULED_CALL_HOSTS`) and the page's own host are always
+ * accepted, plus `options.hosts` or, without them, the hosts of
+ * `config.scheduledCalls`. Schemes: `options.schemes`, else the configured
+ * ones, unset means any. Same name, options and defaults as the React Native SDK.
+ */
+/** The hosted web app: always accepted. */
+export declare const DEFAULT_SCHEDULED_CALL_HOSTS: string[];
+export declare function parseScheduledCallLink(url: unknown, options?: ScheduledCallLinkOptions): string | null;

package/dist/calls/p2p/P2PCallController.d.ts

@@ -0,0 +1,160 @@
+import { IceServerConfig } from '../callMode';
+import { P2PRole } from './negotiator';
+import { P2PSignal, P2PSignalName, P2PSignalPayload } from './signalStanza';
+export type P2PStatus = 'preparing' | 'waiting' | 'connecting' | 'connected' | 'reconnecting' | 'failed' | 'ended';
+export interface P2PSnapshot {
+    status: P2PStatus;
+    localStream: MediaStream | null;
+    remoteStream: MediaStream | null;
+    micEnabled: boolean;
+    camEnabled: boolean;
+    remoteVideoLive: boolean;
+    /** Dismissible, non-fatal hint (e.g. the camera could not be re-enabled). */
+    notice: string | null;
+}
+export interface P2PCallParams {
+    callId: string;
+    role: P2PRole;
+    kind: 'audio' | 'video';
+    /** Peer's xmpp localpart; signals from anyone else are ignored. */
+    peerLocal: string;
+    iceServers: IceServerConfig[];
+    startWithMicOn?: boolean;
+    startWithCameraOn?: boolean;
+}
+export interface P2PCallDeps {
+    createPeerConnection: (config: RTCConfiguration) => RTCPeerConnection;
+    getUserMedia: (constraints: MediaStreamConstraints) => Promise<MediaStream>;
+    createMediaStream: () => MediaStream;
+    /** Fresh credentials; null/empty keeps the servers already in use. */
+    fetchIceServers: () => Promise<IceServerConfig[] | null>;
+    sendSignal: (signal: P2PSignalName, payload: P2PSignalPayload) => void;
+    log?: (message: string, detail?: unknown) => void;
+}
+export interface P2PCallEvents {
+    /** The offer/answer exchange completed: media is now negotiating. */
+    onNegotiated?: () => void;
+    /** Media is flowing for the first time. */
+    onConnected?: () => void;
+    /** The peer ended the call (hang up, decline, their own failure). */
+    onRemoteEnd?: (reason: string) => void;
+    /** The call failed locally; the message is meant for the user. */
+    onFailed?: (message: string) => void;
+    /**
+     * Called exactly once when the call's resources are released. `started` is
+     * false for a callee that never accepted (nothing was negotiated).
+     */
+    onDisposed?: (info: {
+        started: boolean;
+    }) => void;
+}
+export interface P2PTimings {
+    connectTimeoutMs: number;
+    offerResendMs: number[];
+}
+export declare const describeMediaError: (error: unknown) => string;
+/**
+ * What to show when the PEER ended the call for a reason that is a failure
+ * rather than a normal hang up / decline. Null means "just close the call".
+ */
+export declare const remoteEndNotice: (reason: string) => string | null;
+export declare class P2PCallController {
+    readonly callId: string;
+    readonly role: P2PRole;
+    readonly kind: 'audio' | 'video';
+    private readonly params;
+    private readonly deps;
+    private readonly events;
+    private readonly timings;
+    private readonly negotiator;
+    private readonly policy;
+    private snapshot;
+    private readonly listeners;
+    private pc;
+    private localStream;
+    private audioTrack;
+    private videoTrack;
+    private videoSender;
+    private ownedTracks;
+    private remoteStream;
+    private remoteCleanups;
+    private queue;
+    private timers;
+    private graceTimer;
+    private deadlineTimer;
+    private connectTimer;
+    private started;
+    private disposed;
+    private endSent;
+    private connectedOnce;
+    private negotiated;
+    private cameraBusy;
+    private remoteVideoWatched;
+    private remoteVideoStalled;
+    private lastConn;
+    private candidateGateOpen;
+    private heldOutgoingCandidates;
+    private sentCandidates;
+    private lastOffer;
+    constructor(params: P2PCallParams, deps: P2PCallDeps, events?: P2PCallEvents, timings?: Partial<P2PTimings>);
+    subscribe: (listener: () => void) => (() => void);
+    getSnapshot: () => P2PSnapshot;
+    private update;
+    private log;
+    private later;
+    private cancel;
+    /**
+     * Caller: get media, build the connection, offer. Callee: get media, build
+     * the connection, then apply the offer that may already be waiting. Safe to
+     * call once; every failure ends the call with a message instead of throwing.
+     */
+    start(): Promise<void>;
+    /** Feed a signal from the peer (already routed by callId). */
+    receive(signal: P2PSignal): void;
+    /** Local user hung up (or cancelled): tell the peer and release everything. */
+    hangup(reason?: string): void;
+    /**
+     * Release every resource: timers, listeners, media tracks, the connection.
+     * Idempotent, safe from any exit path. Tells the peer unless it is already
+     * known to be over.
+     */
+    dispose(): void;
+    private sendEnd;
+    private fail;
+    private handleRemoteEnd;
+    private acquireMedia;
+    private releaseMedia;
+    toggleMic(): void;
+    /**
+     * Turning the camera off stops sending video and releases the device (the
+     * camera light goes out); turning it on opens the camera again and swaps it
+     * into the existing sender, so no renegotiation is needed.
+     */
+    toggleCamera(): Promise<void>;
+    dismissNotice(): void;
+    private createConnection;
+    private emitCandidate;
+    private openCandidateGate;
+    private onRemoteTrack;
+    private remoteVideoLive;
+    /**
+     * A peer that turns its camera off drops the sender's track (replaceTrack
+     * with null). Chrome does not mute the receiving track for that, so the
+     * `mute` event alone leaves the last frame frozen on screen. Frames that stop
+     * arriving are the signal that does work in every browser, so the received
+     * video is polled and a stall counts as "no live picture" until frames flow
+     * again.
+     */
+    private watchRemoteVideo;
+    private enqueue;
+    private sendOffer;
+    private scheduleOfferResends;
+    private runCommands;
+    private applyOffer;
+    private onNegotiated;
+    private connState;
+    private onConnectionState;
+    private runIceAction;
+    /** ICE restart with fresh TURN credentials; the caller of this is the policy. */
+    private restartIce;
+}

package/dist/calls/p2p/icePolicy.d.ts

@@ -0,0 +1,36 @@
+export type P2PConnState = 'new' | 'connecting' | 'connected' | 'disconnected' | 'failed' | 'closed';
+export type IceAction = {
+    type: 'none';
+} | {
+    type: 'wait';
+    ms: number;
+} | {
+    type: 'restart';
+    deadlineMs: number;
+} | {
+    type: 'recovered';
+} | {
+    type: 'give-up';
+    reason: string;
+};
+export interface IcePolicyOptions {
+    graceMs?: number;
+    restartDeadlineMs?: number;
+    maxRestartsPerCall?: number;
+}
+export declare class IceRestartPolicy {
+    private readonly graceMs;
+    private readonly restartDeadlineMs;
+    private readonly maxRestarts;
+    private restarts;
+    private attemptedThisOutage;
+    private inOutage;
+    constructor(options?: IcePolicyOptions);
+    get restartCount(): number;
+    private tryRestart;
+    onState(state: P2PConnState): IceAction;
+    /** The grace period after `disconnected` ran out without recovery. */
+    onGraceElapsed(): IceAction;
+    /** The restart deadline ran out; `stillDown` is the state at that moment. */
+    onRestartDeadline(stillDown: boolean): IceAction;
+}

package/dist/calls/p2p/negotiator.d.ts

@@ -0,0 +1,56 @@
+import { P2PSignal } from './signalStanza';
+export type P2PRole = 'caller' | 'callee';
+export type NegotiatorCommand = {
+    type: 'apply-offer';
+    sdp: string;
+    initial: boolean;
+    rollback: boolean;
+} | {
+    type: 'apply-answer';
+    sdp: string;
+} | {
+    type: 'add-candidate';
+    candidate: RTCIceCandidateInit;
+} | {
+    type: 'remote-end';
+    reason: string;
+};
+export declare class P2PNegotiator {
+    readonly callId: string;
+    readonly role: P2PRole;
+    private readonly peerLocal;
+    private ready;
+    private ended;
+    private remoteDescriptionSet;
+    private initialOfferTaken;
+    private heldOffer;
+    private localOfferPending;
+    private lastOfferSdp;
+    private lastAnswerSdp;
+    private heldCandidates;
+    private seenCandidates;
+    constructor(params: {
+        callId: string;
+        role: P2PRole;
+        peerLocal: string;
+    });
+    get isEnded(): boolean;
+    /** True while we have sent an offer and not yet received its answer. */
+    get awaitingAnswer(): boolean;
+    private accepts;
+    receive(signal: P2PSignal): NegotiatorCommand[];
+    /**
+     * Local media and the peer connection exist. For the callee this releases
+     * the offer that arrived while it was still on the ring screen.
+     */
+    markReady(): NegotiatorCommand[];
+    /** We created and set a local offer; its answer is now expected. */
+    markLocalOffer(): void;
+    /**
+     * A remote description (offer or answer) was applied to the connection.
+     * Returns the candidates that were waiting for it.
+     */
+    markRemoteApplied(): NegotiatorCommand[];
+    /** Local teardown: later signals are ignored. */
+    stop(): void;
+}

package/dist/calls/p2p/p2pRuntime.d.ts

@@ -0,0 +1,35 @@
+import { Element } from 'ltx';
+import { P2PSignalInbox } from './signalInbox';
+import { P2PSignalName, P2PSignalPayload } from './signalStanza';
+import { P2PCallController, P2PCallDeps } from './P2PCallController';
+/** Signals that arrive for a call nobody is handling yet wait here. */
+export declare const p2pInbox: P2PSignalInbox;
+/**
+ * Entry point for an incoming `<data type="call-p2p">` message (called from
+ * the stanza router). Stale, replayed, malformed or self-sent signals are
+ * dropped; the rest go to the inbox, which delivers or briefly holds them.
+ */
+export declare const handleP2PSignalStanza: (inner: Element) => void;
+/** Sends one signal straight to the peer's bare JID over the live XMPP client. */
+export declare const sendP2PSignal: (params: {
+    peerXmppUsername: string;
+    callId: string;
+    signal: P2PSignalName;
+    payload: P2PSignalPayload;
+}) => boolean;
+/** The real browser dependencies for one call's controller. */
+export declare const createBrowserP2PDeps: (params: {
+    callId: string;
+    peerXmppUsername: string;
+}) => P2PCallDeps;
+export declare const getActiveP2PController: () => P2PCallController | null;
+export declare const subscribeActiveP2P: (listener: () => void) => (() => void);
+/**
+ * Returns the controller for `key`, creating it on first use. Effects that
+ * unmount and immediately remount (React StrictMode, a parent re-keying) get
+ * the SAME controller back instead of tearing the call down and starting a
+ * second negotiation: release() only disposes after a tick, and acquire()
+ * within that tick cancels it.
+ */
+export declare const acquireP2PController: (key: string, create: () => P2PCallController) => P2PCallController;
+export declare const releaseP2PController: (key: string) => void;

package/dist/calls/p2p/signalInbox.d.ts

@@ -0,0 +1,34 @@
+import { P2PSignal } from './signalStanza';
+export interface SignalInboxOptions {
+    /** How long signals for a call with no listener are kept. */
+    ttlMs?: number;
+    /** Most distinct unclaimed callIds held at once (oldest dropped first). */
+    maxPendingCalls?: number;
+    /** Most signals kept per unclaimed call. */
+    maxPerCall?: number;
+    now?: () => number;
+}
+export type SignalDelivery = 'delivered' | 'buffered' | 'dropped';
+type Handler = (signal: P2PSignal) => void;
+export declare class P2PSignalInbox {
+    private readonly ttlMs;
+    private readonly maxPendingCalls;
+    private readonly maxPerCall;
+    private readonly now;
+    private readonly pending;
+    private readonly handlers;
+    private readonly closed;
+    constructor(options?: SignalInboxOptions);
+    private sweep;
+    receive(signal: P2PSignal): SignalDelivery;
+    /**
+     * Starts delivering a call's signals to `handler`, replaying anything held
+     * for it first (in arrival order). Returns a detach function that also
+     * marks the call closed.
+     */
+    attach(callId: string, handler: Handler): () => void;
+    /** The call is over: forget held signals and drop future stragglers. */
+    close(callId: string): void;
+    clear(): void;
+}
+export {};

package/dist/calls/p2p/signalStanza.d.ts

@@ -0,0 +1,51 @@
+import { Element } from 'ltx';
+export declare const P2P_SIGNAL_TYPE = "call-p2p";
+export type P2PSignalName = 'offer' | 'answer' | 'candidate' | 'end';
+export interface P2PSdpPayload {
+    type: 'offer' | 'answer';
+    sdp: string;
+}
+export interface P2PCandidatePayload {
+    candidate: string;
+    sdpMid?: string | null;
+    sdpMLineIndex?: number | null;
+    usernameFragment?: string | null;
+}
+export interface P2PEndPayload {
+    reason?: string;
+}
+export type P2PSignalPayload = P2PSdpPayload | P2PCandidatePayload | P2PEndPayload;
+export interface P2PSignal {
+    callId: string;
+    signal: P2PSignalName;
+    payload: P2PSignalPayload;
+    /** Sender's bare JID as written in `from` (lower-cased), '' when missing. */
+    fromBare: string;
+    /** Sender's xmpp localpart (the part before '@'), '' when missing. */
+    fromLocal: string;
+    /**
+     * Age of the stanza from the server's stanza-id timestamp, null when the
+     * stanza carries none (direct messages often do not).
+     */
+    ageMs: number | null;
+    /** Carries <delay/>: it was stored offline and replayed, so it is stale. */
+    delayed: boolean;
+}
+export declare const MAX_P2P_SIGNAL_AGE_MS = 15000;
+export declare const buildP2PSignalStanza: (params: {
+    to: string;
+    callId: string;
+    signal: P2PSignalName;
+    payload?: P2PSignalPayload;
+}) => Element;
+/**
+ * Reads a `call-p2p` message. Returns null for anything that is not a
+ * well formed signal (wrong type, unknown signal, bad JSON, bad payload).
+ */
+export declare const parseP2PSignalStanza: (stanza: Element, now?: number) => P2PSignal | null;
+/**
+ * Whether a parsed signal belongs to a live negotiation. An `end` is always
+ * accepted unless replayed (it only ever acts on a call that is still
+ * active, and stopping a call late is better than never).
+ */
+export declare const isP2PSignalFresh: (signal: P2PSignal) => boolean;

package/dist/calls/placeCall.d.ts

@@ -0,0 +1,20 @@
+import { Dispatch } from '@reduxjs/toolkit';
+import { IRoom } from '../types/types';
+import { CallKindName } from './callMode';
+/**
+ * Dials a call in `room`: the one path every "start or join a call" entry
+ * point shares (the chat header buttons and the scheduled-call Join button).
+ * Which transport carries it is the server's decision (p2p for 1:1, LiveKit
+ * for groups); a group call that is already running is joined, not duplicated.
+ *
+ * `chatName` is the bare room name (the JID local part), never the display
+ * title. Failures surface through the call slice's error state.
+ */
+export declare function placeRoomCall(params: {
+    dispatch: Dispatch;
+    room: Pick<IRoom, 'jid' | 'name' | 'members'> & {
+        type?: IRoom['type'];
+    };
+    kind: CallKindName;
+    selfXmppUsername?: string | null;
+}): Promise<void>;