@ethora/chat-component 26.5.7 → 26.5.9

package/dist/assets/icons.d.ts

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

package/dist/components/VideoCalls/VideoCallOverlay.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const VideoCallOverlay: React.FC;

package/dist/components/VideoCalls/VideoCallSession.d.ts

@@ -0,0 +1,25 @@
+import { default as React } from 'react';
+import { VideoCallIcons } from '../../types/models/config.model';
+interface VideoCallSessionProps {
+    token: string;
+    livekitUrl: string;
+    kind?: 'audio' | 'video';
+    primaryColor?: string;
+    /** Host icon overrides for the control bar. */
+    icons?: VideoCallIcons;
+    /** Start with the camera on (video calls). Default true. */
+    startWithCameraOn?: boolean;
+    /** Start with the microphone on. Default true. */
+    startWithMicOn?: boolean;
+    /** Show the screen-share control. Default true. */
+    showScreenShare?: boolean;
+    /** Render the compact floating-panel layout instead of the full screen. */
+    minimized?: boolean;
+    /** Toggle between full and minimized layouts (keeps the session mounted). */
+    onToggleMinimize?: () => void;
+    onConnected?: () => void;
+    onError?: (message: string) => void;
+    onHangup: () => void;
+}
+export declare const VideoCallSession: React.FC<VideoCallSessionProps>;
+export {};

package/dist/helpers/callLogMessage.d.ts

@@ -0,0 +1,11 @@
+import { IMessage } from '../types/types';
+export interface CallLogMeta {
+    callId: string;
+    direction: 'outgoing' | 'incoming';
+    durationMs: number;
+    missed: boolean;
+    kind: 'audio' | 'video';
+}
+export declare const isCallLogMessage: (message: unknown) => boolean;
+export declare const callStateHasLogData: (attrs: Record<string, any>) => boolean;
+export declare const transformCallLogMessage: (message: IMessage, selfXmppUsername: string) => IMessage;

package/dist/helpers/callPush.d.ts

@@ -0,0 +1,22 @@
+export interface ParsedCallPush {
+    callId: string | null;
+    /** LiveKit token, if the push carried one (lets us ring + accept offline). */
+    token: string | null;
+    kind: 'audio' | 'video';
+    /** Bare room name (JID localpart) the call belongs to. */
+    roomBareName: string | null;
+    /** Raw room reference from the payload (full JID or bare name). */
+    roomRef: string | null;
+    /** Display name for the ring screen (caller). */
+    callerName: string | null;
+    /** Caller's xmpp localpart, when provided. */
+    callerXmppUsername: string | null;
+}
+/**
+ * True when a push `data` payload represents an incoming call. Matches on an
+ * explicit call marker (`type`/`pushType`/`category`/`event` === "call"-ish)
+ * or on a callId paired with a call-specific field, so a normal message push
+ * is never misread as a call.
+ */
+export declare const isCallPush: (data: Record<string, any> | null | undefined) => boolean;
+export declare const parseCallPush: (data: Record<string, any> | null | undefined) => ParsedCallPush;

package/dist/helpers/mamReactions.d.ts

@@ -0,0 +1,47 @@
+import { Element } from 'ltx';
+import { IMessage } from '../types/models/message.model';
+import { ReactionAction } from '../types/models/action.model';
+/**
+ * A reaction restored from the MAM archive whose target message is NOT in the
+ * same history page. It is handed back to the caller so it can be dispatched to
+ * the store (where a target loaded by an earlier page or a live stanza lives).
+ */
+export type DeferredReaction = ReactionAction;
+/** Normalised view of a single `<reactions xmlns="urn:xmpp:reactions:0">` stanza. */
+export interface ExtractedReaction {
+    /** Stanza id of the message the reaction targets (matches `IMessage.id`). */
+    messageId: string;
+    /** Full reactor JID, e.g. `<localpart>@xmpp.host/resource`. */
+    from: string;
+    /** Bare reactor id (`from` up to `@`); the key reactions are stored under. */
+    fromId: string;
+    /** Emoji shortcodes for this reactor; empty means the reactor cleared them. */
+    emoji: string[];
+    /** `<data senderFirstName=… senderLastName=…/>` attributes, if present. */
+    data: Record<string, string>;
+    /** Room JID derived from `<stanza-id by>` or the reactor JID. */
+    roomJID: string;
+}
+/**
+ * Pull the reaction details out of a forwarded MAM message that carries a
+ * `<reactions>` child. Returns null when the stanza is not a usable reaction
+ * (missing target id or reactor).
+ */
+export declare const extractMamReaction: (msg: Element) => ExtractedReaction | null;
+/**
+ * Apply MAM reaction stanzas to a freshly parsed history page.
+ *
+ * Reactions are archived in MAM as standalone `<reactions>` stanzas. The MAM
+ * fetch path bypasses the live `onReactionHistory` handler, so without this the
+ * reactions only ever existed for the live session and disappeared on refresh.
+ *
+ * Reactions whose target message is in this same page are merged directly onto
+ * the message object (so they are present the instant the page is stored).
+ * Reactions whose target is not in the page are returned as `deferred` for the
+ * caller to dispatch to the store (the target may live in an earlier page or
+ * have arrived live).
+ */
+export declare const applyMamReactions: (messages: IMessage[], reactionStanzas: Element[]) => {
+    messages: IMessage[];
+    deferred: DeferredReaction[];
+};

package/dist/helpers/storeConsole.d.ts

@@ -2,4 +2,5 @@ export declare const useStoreConsole: () => {
     chatSettingStore: any;
     rooms: any;
     roomHeapSlice: import('../roomStore/roomHeapSlice').roomHeapSliceState;
+    call: import('immer').WritableDraft<import('../roomStore/callSlice').CallState>;
 };

package/dist/helpers/useDraggable.d.ts

@@ -0,0 +1,18 @@
+export interface DraggablePosition {
+    x: number;
+    y: number;
+}
+/**
+ * Minimal pointer-based drag hook (no deps). Returns the current offset and a
+ * pointer-down handler to attach to a drag handle. The consumer decides how to
+ * apply `pos` (e.g. as `left/top`, or as a delta from a default corner).
+ *
+ * `onChange` fires while dragging so callers can clamp to bounds. Works with
+ * mouse and touch via Pointer Events. `null` position means "not yet dragged"
+ * (use your default layout until the user moves it).
+ */
+export declare const useDraggable: (clamp?: (pos: DraggablePosition) => DraggablePosition) => {
+    pos: DraggablePosition;
+    onPointerDown: (e: React.PointerEvent) => void;
+    setPos: import('react').Dispatch<import('react').SetStateAction<DraggablePosition>>;
+};