@cometchat/chat-uikit-react 4.3.22 → 5.0.0-beta1

package/dist/types/src/components/AI/AIConversationSummary/AIConversationSummaryDecorator.d.ts

@@ -0,0 +1,22 @@
+import { DataSource } from "../../../utils/DataSource";
+import { DataSourceDecorator } from "../../../utils/DataSourceDecorator";
+import { AIConversationSummaryConfiguration } from "./AIConversationSummaryConfiguration";
+import { CometChatActionsView } from "../../../modals/CometChatActionsView";
+import { CometChatMessageComposerAction } from "../../../modals";
+export declare class AIConversationSummaryDecorator extends DataSourceDecorator {
+    configuration?: AIConversationSummaryConfiguration;
+    newDataSource: DataSource;
+    currentMessage: CometChat.BaseMessage | null;
+    unreadMessageCount: number;
+    loggedInUser: CometChat.User | null;
+    user: CometChat.User;
+    group: CometChat.Group;
+    private LISTENER_ID;
+    constructor(dataSource: DataSource, configuration?: AIConversationSummaryConfiguration);
+    getId(): string;
+    closePanel: () => void;
+    getConversationSummary: () => Promise<string>;
+    private loadConversationSummary;
+    getAIOptions(user: CometChat.User | null, group: CometChat.Group | null, id?: any): (CometChatMessageComposerAction | CometChatActionsView)[];
+    private addMessageListener;
+}

package/dist/types/src/components/AI/AIConversationSummary/AIConversationSummaryExtension.d.ts

@@ -0,0 +1,8 @@
+import { AIExtensionDataSource } from "../AIExtensionDataSource";
+import { AIConversationSummaryConfiguration } from "./AIConversationSummaryConfiguration";
+export declare class AIConversationSummaryExtension extends AIExtensionDataSource {
+    private configuration?;
+    constructor(configuration?: AIConversationSummaryConfiguration);
+    addExtension(): void;
+    getExtensionId(): string;
+}

package/dist/types/src/components/AI/AIConversationSummary/AIConversationSummaryView.d.ts

@@ -0,0 +1,9 @@
+import { AIConversationSummaryConfiguration } from './AIConversationSummaryConfiguration';
+interface IAIConversationSummaryProps {
+    getConversationSummaryCallback?: () => Promise<string>;
+    editReplyCallback?: (reply: string) => void;
+    closeCallback?: () => void;
+    configuration?: AIConversationSummaryConfiguration;
+}
+declare const AIConversationSummaryView: (props: IAIConversationSummaryProps) => import("react/jsx-runtime").JSX.Element;
+export { AIConversationSummaryView };

package/dist/types/{Shared/Framework/ExtensionsDataSource.d.ts → src/components/AI/AIExtensionDataSource.d.ts}

@@ -1,6 +1,6 @@
-declare abstract class ExtensionsDataSource {
+declare abstract class AIExtensionDataSource {
     abstract addExtension(): void;
     abstract getExtensionId(): string;
     enable(): void;
 }
-export { ExtensionsDataSource };
+export { AIExtensionDataSource };

package/dist/types/src/components/AI/AISmartReplies/AISmartRepliesConfiguration.d.ts

@@ -0,0 +1,28 @@
+import { AIBaseConfiguration } from "../AIBaseConfiguration";
+/**
+ * Represents the configuration for the AISmartReplies component.
+ *
+ * This class allows customization of various aspects of the AISmartReplies component,
+ * including styles, icons, custom views, and API configurations.
+ */
+export declare class AISmartRepliesConfiguration extends AIBaseConfiguration {
+    /**
+     * The customView callback allows you to display a custom UI for conversation starters.
+     * It receives the list of conversation starters and optional close and back callbacks.
+     *
+     * @type {(response: Object, closeCallBack?: () => void, backCallBack?: () => void) => Promise<any>}
+     */
+    customView?: (response: Object, closeCallBack?: () => void, backCallBack?: () => void) => Promise<any>;
+    /**
+     * The URL for the custom back button icon. Defaults to an embedded back button icon.
+     *
+     * @type {string}
+     */
+    backIconURL?: string;
+    /**
+     * Creates an instance of AISmartRepliesConfiguration.
+     *
+     * @param {Partial<AISmartRepliesConfiguration>} props - The properties to initialize the configuration.
+     */
+    constructor(props: Partial<AISmartRepliesConfiguration>);
+}

package/dist/types/src/components/AI/AISmartReplies/AISmartRepliesDecorator.d.ts

@@ -0,0 +1,21 @@
+import { DataSource } from "../../../utils/DataSource";
+import { DataSourceDecorator } from "../../../utils/DataSourceDecorator";
+import { AISmartRepliesConfiguration } from "./AISmartRepliesConfiguration";
+import { CometChatActionsView, CometChatMessageComposerAction } from "../../../modals";
+export declare class AISmartRepliesDecorator extends DataSourceDecorator {
+    configuration?: AISmartRepliesConfiguration;
+    newDataSource: DataSource;
+    loggedInUser: CometChat.User | null;
+    user: CometChat.User;
+    group: CometChat.Group;
+    buttonRef: any;
+    isModalClosed: boolean;
+    private closeCallback?;
+    constructor(dataSource: DataSource, configuration?: AISmartRepliesConfiguration);
+    getId(): string;
+    editReply(reply: string): void;
+    closeIfMessageReceived(message: CometChat.BaseMessage): void;
+    getSmartReplies: () => Promise<string[]>;
+    getAIOptions(user: CometChat.User | null, group: CometChat.Group | null, id?: any): (CometChatMessageComposerAction | CometChatActionsView)[];
+    private addMessageListener;
+}

package/dist/types/src/components/AI/AISmartReplies/AISmartRepliesExtension.d.ts

@@ -0,0 +1,8 @@
+import { AIExtensionDataSource } from "../AIExtensionDataSource";
+import { AISmartRepliesConfiguration } from "./AISmartRepliesConfiguration";
+export declare class AISmartRepliesExtension extends AIExtensionDataSource {
+    private configuration?;
+    constructor(configuration?: AISmartRepliesConfiguration);
+    addExtension(): void;
+    getExtensionId(): string;
+}

package/dist/types/src/components/AI/AISmartReplies/AISmartRepliesView.d.ts

@@ -0,0 +1,11 @@
+import { AISmartRepliesConfiguration } from './AISmartRepliesConfiguration';
+interface IAISmartRepliesProps {
+    title: string;
+    getSmartRepliesCallback?: () => Promise<Object>;
+    editReplyCallback?: (reply: string) => void;
+    closeCallback?: () => void;
+    backCallback?: () => void;
+    configuration?: AISmartRepliesConfiguration;
+}
+declare const AISmartRepliesView: (props: IAISmartRepliesProps) => import("react/jsx-runtime").JSX.Element;
+export { AISmartRepliesView };

package/dist/types/src/components/BaseComponents/CometChatActionBubble/CometChatActionBubble.d.ts

@@ -0,0 +1,8 @@
+interface ActionBubbleProps {
+    messageText: string;
+}
+/**
+ * CometChatActionBubble is a generic component used to show an action message
+ */
+declare const CometChatActionBubble: (props: ActionBubbleProps) => import("react/jsx-runtime").JSX.Element;
+export { CometChatActionBubble };

package/dist/types/src/components/BaseComponents/CometChatActionSheet/CometChatActionSheet.d.ts

@@ -0,0 +1,7 @@
+import { CometChatActionsView, CometChatMessageComposerAction } from "../../../modals";
+interface ActionSheetProps {
+    actions: (CometChatMessageComposerAction | CometChatActionsView)[];
+    onActionItemClick: (action: CometChatMessageComposerAction | CometChatActionsView) => void;
+}
+declare const CometChatActionSheet: (props: ActionSheetProps) => import("react/jsx-runtime").JSX.Element;
+export { CometChatActionSheet };

package/dist/types/src/components/BaseComponents/CometChatAudioBubble/CometChatAudioBubble.d.ts

@@ -0,0 +1,6 @@
+interface AudioBubbleProps {
+    src: string;
+    isSentByMe?: boolean;
+}
+declare const CometChatAudioBubble: (props: AudioBubbleProps) => import("react/jsx-runtime").JSX.Element;
+export { CometChatAudioBubble };

package/dist/types/src/components/BaseComponents/CometChatAudioBubble/src/base-plugin.d.ts

@@ -0,0 +1,21 @@
+import EventEmitter from './event-emitter';
+import type WaveSurfer from './wavesurfer';
+export type BasePluginEvents = {
+    destroy: [];
+};
+export type GenericPlugin = BasePlugin<BasePluginEvents, unknown>;
+/** Base class for wavesurfer plugins */
+export declare class BasePlugin<EventTypes extends BasePluginEvents, Options> extends EventEmitter<EventTypes> {
+    protected wavesurfer?: WaveSurfer;
+    protected subscriptions: (() => void)[];
+    protected options: Options;
+    /** Create a plugin instance */
+    constructor(options: Options);
+    /** Called after this.wavesurfer is available */
+    protected onInit(): void;
+    /** Do not call directly, only called by WavesSurfer internally */
+    _init(wavesurfer: WaveSurfer): void;
+    /** Destroy the plugin and unsubscribe from all events */
+    destroy(): void;
+}
+export default BasePlugin;

package/dist/types/src/components/BaseComponents/CometChatAudioBubble/src/decoder.d.ts

@@ -0,0 +1,9 @@
+/** Decode an array buffer into an audio buffer */
+declare function decode(audioData: ArrayBuffer, sampleRate: number): Promise<AudioBuffer>;
+/** Create an audio buffer from pre-decoded audio data */
+declare function createBuffer(channelData: Array<Float32Array | number[]>, duration: number): AudioBuffer;
+declare const Decoder: {
+    decode: typeof decode;
+    createBuffer: typeof createBuffer;
+};
+export default Decoder;

package/dist/types/src/components/BaseComponents/CometChatAudioBubble/src/dom.d.ts

@@ -0,0 +1,13 @@
+type TreeNode = {
+    [key: string]: string | number | boolean | CSSStyleDeclaration | TreeNode | Node;
+} & {
+    xmlns?: string;
+    style?: Partial<CSSStyleDeclaration>;
+    textContent?: string | Node;
+    children?: TreeNode;
+};
+export declare function createElement(tagName: string, content: TreeNode & {
+    xmlns: string;
+}, container?: Node): SVGElement;
+export declare function createElement(tagName: string, content?: TreeNode, container?: Node): HTMLElement;
+export default createElement;

package/dist/types/src/components/BaseComponents/CometChatAudioBubble/src/draggable.d.ts

@@ -0,0 +1 @@
+export declare function makeDraggable(element: HTMLElement | null, onDrag: (dx: number, dy: number, x: number, y: number) => void, onStart?: (x: number, y: number) => void, onEnd?: (x: number, y: number) => void, threshold?: number, mouseButton?: number, touchDelay?: number): () => void;

package/dist/types/src/components/BaseComponents/CometChatAudioBubble/src/event-emitter.d.ts

@@ -0,0 +1,21 @@
+export type GeneralEventTypes = {
+    [EventName: string]: unknown[];
+};
+type EventListener<EventTypes extends GeneralEventTypes, EventName extends keyof EventTypes> = (...args: EventTypes[EventName]) => void;
+/** A simple event emitter that can be used to listen to and emit events. */
+declare class EventEmitter<EventTypes extends GeneralEventTypes> {
+    private listeners;
+    /** Subscribe to an event. Returns an unsubscribe function. */
+    on<EventName extends keyof EventTypes>(event: EventName, listener: EventListener<EventTypes, EventName>, options?: {
+        once?: boolean;
+    }): () => void;
+    /** Unsubscribe from an event */
+    un<EventName extends keyof EventTypes>(event: EventName, listener: EventListener<EventTypes, EventName>): void;
+    /** Subscribe to an event only once */
+    once<EventName extends keyof EventTypes>(event: EventName, listener: EventListener<EventTypes, EventName>): () => void;
+    /** Clear all events */
+    unAll(): void;
+    /** Emit an event */
+    protected emit<EventName extends keyof EventTypes>(eventName: EventName, ...args: EventTypes[EventName]): void;
+}
+export default EventEmitter;

package/dist/types/src/components/BaseComponents/CometChatAudioBubble/src/fetcher.d.ts

@@ -0,0 +1,5 @@
+declare function fetchBlob(url: string, progressCallback: (percentage: number) => void, requestInit?: RequestInit): Promise<Blob>;
+declare const Fetcher: {
+    fetchBlob: typeof fetchBlob;
+};
+export default Fetcher;

package/dist/types/src/components/BaseComponents/CometChatAudioBubble/src/player.d.ts

@@ -0,0 +1,50 @@
+import EventEmitter, { type GeneralEventTypes } from './event-emitter';
+type PlayerOptions = {
+    media?: HTMLMediaElement;
+    mediaControls?: boolean;
+    autoplay?: boolean;
+    playbackRate?: number;
+};
+declare class Player<T extends GeneralEventTypes> extends EventEmitter<T> {
+    protected media: HTMLMediaElement;
+    private isExternalMedia;
+    constructor(options: PlayerOptions);
+    protected onMediaEvent<K extends keyof HTMLElementEventMap>(event: K, callback: (ev: HTMLElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions): () => void;
+    protected getSrc(): string;
+    private revokeSrc;
+    private canPlayType;
+    protected setSrc(url: string, blob?: Blob): void;
+    protected destroy(): void;
+    protected setMediaElement(element: HTMLMediaElement): void;
+    /** Start playing the audio */
+    play(): Promise<void>;
+    /** Pause the audio */
+    pause(): void;
+    /** Check if the audio is playing */
+    isPlaying(): boolean;
+    /** Jump to a specific time in the audio (in seconds) */
+    setTime(time: number): void;
+    /** Get the duration of the audio in seconds */
+    getDuration(): number;
+    /** Get the current audio position in seconds */
+    getCurrentTime(): number;
+    /** Get the audio volume */
+    getVolume(): number;
+    /** Set the audio volume */
+    setVolume(volume: number): void;
+    /** Get the audio muted state */
+    getMuted(): boolean;
+    /** Mute or unmute the audio */
+    setMuted(muted: boolean): void;
+    /** Get the playback speed */
+    getPlaybackRate(): number;
+    /** Check if the audio is seeking */
+    isSeeking(): boolean;
+    /** Set the playback speed, pass an optional false to NOT preserve the pitch */
+    setPlaybackRate(rate: number, preservePitch?: boolean): void;
+    /** Get the HTML media element */
+    getMediaElement(): HTMLMediaElement;
+    /** Set a sink id to change the audio output device */
+    setSinkId(sinkId: string): Promise<void>;
+}
+export default Player;

package/dist/types/src/components/BaseComponents/CometChatAudioBubble/src/plugins/envelope.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Envelope is a visual UI for controlling the audio volume and add fade-in and fade-out effects.
+ */
+import BasePlugin, { type BasePluginEvents } from '../base-plugin';
+export type EnvelopePoint = {
+    id?: string;
+    time: number;
+    volume: number;
+};
+export type EnvelopePluginOptions = {
+    points?: any;
+    volume?: number;
+    lineWidth?: string;
+    lineColor?: string;
+    dragLine?: boolean;
+    dragPointSize?: number;
+    dragPointFill?: string;
+    dragPointStroke?: string;
+};
+declare const defaultOptions: {
+    points: any;
+    lineWidth: number;
+    lineColor: string;
+    dragPointSize: number;
+    dragPointFill: string;
+    dragPointStroke: string;
+};
+type Options = EnvelopePluginOptions & typeof defaultOptions;
+export type EnvelopePluginEvents = BasePluginEvents & {
+    'points-change': [newPoints: EnvelopePoint[]];
+    'volume-change': [volume: number];
+};
+declare class EnvelopePlugin extends BasePlugin<EnvelopePluginEvents, EnvelopePluginOptions> {
+    protected options: Options;
+    private polyline;
+    private points;
+    private throttleTimeout;
+    private volume;
+    /**
+     * Create a new Envelope plugin.
+     */
+    constructor(options: EnvelopePluginOptions);
+    static create(options: EnvelopePluginOptions): EnvelopePlugin;
+    /**
+     * Add an envelope point with a given time and volume.
+     */
+    addPoint(point: EnvelopePoint): void;
+    /**
+     * Remove an envelope point.
+     */
+    removePoint(point: EnvelopePoint): void;
+    /**
+     * Get all envelope points. Should not be modified directly.
+     */
+    getPoints(): EnvelopePoint[];
+    /**
+     * Set new envelope points.
+     */
+    setPoints(newPoints: EnvelopePoint[]): void;
+    /**
+     * Destroy the plugin instance.
+     */
+    destroy(): void;
+    /**
+     * Get the envelope volume.
+     */
+    getCurrentVolume(): number;
+    /**
+     * Set the envelope volume. 0..1 (more than 1 will boost the volume).
+     */
+    setVolume(floatValue: number): void;
+    /** Called by wavesurfer, don't call manually */
+    onInit(): void;
+    private emitPoints;
+    private initPolyline;
+    private addPolyPoint;
+    private onTimeUpdate;
+}
+export default EnvelopePlugin;

package/dist/types/src/components/BaseComponents/CometChatAudioBubble/src/plugins/hover.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The Hover plugin follows the mouse and shows a timestamp
+ */
+import BasePlugin, { type BasePluginEvents } from '../base-plugin';
+export type HoverPluginOptions = {
+    lineColor?: string;
+    lineWidth?: string | number;
+    labelColor?: string;
+    labelSize?: string | number;
+    labelBackground?: string;
+    formatTimeCallback?: (seconds: number) => string;
+};
+declare const defaultOptions: {
+    lineWidth: number;
+    labelSize: number;
+    formatTimeCallback(seconds: number): string;
+};
+export type HoverPluginEvents = BasePluginEvents & {
+    hover: [relX: number];
+};
+declare class HoverPlugin extends BasePlugin<HoverPluginEvents, HoverPluginOptions> {
+    protected options: HoverPluginOptions & typeof defaultOptions;
+    private wrapper;
+    private label;
+    private unsubscribe;
+    constructor(options?: HoverPluginOptions);
+    static create(options?: HoverPluginOptions): HoverPlugin;
+    private addUnits;
+    /** Called by wavesurfer, don't call manually */
+    onInit(): void;
+    private onPointerMove;
+    private onPointerLeave;
+    /** Unmount */
+    destroy(): void;
+}
+export default HoverPlugin;

package/dist/types/src/components/BaseComponents/CometChatAudioBubble/src/plugins/minimap.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Minimap is a tiny copy of the main waveform serving as a navigation tool.
+ */
+import BasePlugin, { type BasePluginEvents } from '../base-plugin';
+import { type WaveSurferOptions } from '../wavesurfer';
+export type MinimapPluginOptions = {
+    overlayColor?: string;
+    insertPosition?: InsertPosition;
+} & Partial<WaveSurferOptions>;
+declare const defaultOptions: {
+    height: number;
+    overlayColor: string;
+    insertPosition: string;
+};
+export type MinimapPluginEvents = BasePluginEvents & {
+    /** An alias of timeupdate but only when the audio is playing */
+    audioprocess: [currentTime: number];
+    /** When the user clicks on the waveform */
+    click: [relativeX: number, relativeY: number];
+    /** When the user double-clicks on the waveform */
+    dblclick: [relativeX: number, relativeY: number];
+    /** When the audio has been decoded */
+    decode: [duration: number];
+    /** When the user drags the cursor */
+    drag: [relativeX: number];
+    /** When the user ends dragging the cursor */
+    dragend: [relativeX: number];
+    /** When the user starts dragging the cursor */
+    dragstart: [relativeX: number];
+    /** When the user interacts with the waveform (i.g. clicks or drags on it) */
+    interaction: [];
+    /** After the minimap is created */
+    init: [];
+    /** When the audio is both decoded and can play */
+    ready: [];
+    /** When visible waveform is drawn */
+    redraw: [];
+    /** When all audio channel chunks of the waveform have drawn */
+    redrawcomplete: [];
+    /** When the user seeks to a new position */
+    seeking: [currentTime: number];
+    /** On audio position change, fires continuously during playback */
+    timeupdate: [currentTime: number];
+};
+declare class MinimapPlugin extends BasePlugin<MinimapPluginEvents, MinimapPluginOptions> {
+    protected options: MinimapPluginOptions & typeof defaultOptions;
+    private minimapWrapper;
+    private miniWavesurfer;
+    private overlay;
+    private container;
+    constructor(options: MinimapPluginOptions);
+    static create(options: MinimapPluginOptions): MinimapPlugin;
+    /** Called by wavesurfer, don't call manually */
+    onInit(): void;
+    private initMinimapWrapper;
+    private initOverlay;
+    private initMinimap;
+    private getOverlayWidth;
+    private onRedraw;
+    private onScroll;
+    private initWaveSurferEvents;
+    /** Unmount */
+    destroy(): void;
+}
+export default MinimapPlugin;

package/dist/types/src/components/BaseComponents/CometChatAudioBubble/src/plugins/record.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Record audio from the microphone with a real-time waveform preview
+ */
+import BasePlugin, { type BasePluginEvents } from '../base-plugin';
+export type RecordPluginOptions = {
+    /** The MIME type to use when recording audio */
+    mimeType?: MediaRecorderOptions['mimeType'];
+    /** The audio bitrate to use when recording audio, defaults to 128000 to avoid a VBR encoding. */
+    audioBitsPerSecond?: MediaRecorderOptions['audioBitsPerSecond'];
+    /** Whether to render the recorded audio at the end, true by default */
+    renderRecordedAudio?: boolean;
+    /** Whether to render the scrolling waveform, false by default */
+    scrollingWaveform?: boolean;
+    /** The duration of the scrolling waveform window, defaults to 5 seconds */
+    scrollingWaveformWindow?: number;
+    /** Accumulate and render the waveform data as the audio is being recorded, false by default */
+    continuousWaveform?: boolean;
+    /** The duration of the continuous waveform, in seconds */
+    continuousWaveformDuration?: number;
+    /** The timeslice to use for the media recorder */
+    mediaRecorderTimeslice?: number;
+};
+export type RecordPluginDeviceOptions = {
+    /** The device ID of the microphone to use */
+    deviceId?: string | {
+        exact: string;
+    };
+};
+export type RecordPluginEvents = BasePluginEvents & {
+    /** Fires when the recording starts */
+    'record-start': [];
+    /** Fires when the recording is paused */
+    'record-pause': [blob: Blob];
+    /** Fires when the recording is resumed */
+    'record-resume': [];
+    'record-end': [blob: Blob];
+    /** Fires continuously while recording */
+    'record-progress': [duration: number];
+    /** On every new recorded chunk */
+    'record-data-available': [blob: Blob];
+};
+type MicStream = {
+    onDestroy: () => void;
+    onEnd: () => void;
+};
+declare class RecordPlugin extends BasePlugin<RecordPluginEvents, RecordPluginOptions> {
+    private stream;
+    private mediaRecorder;
+    private dataWindow;
+    private isWaveformPaused;
+    private originalOptions?;
+    private timer;
+    private lastStartTime;
+    private lastDuration;
+    private duration;
+    /** Create an instance of the Record plugin */
+    constructor(options: RecordPluginOptions);
+    /** Create an instance of the Record plugin */
+    static create(options?: RecordPluginOptions): RecordPlugin;
+    renderMicStream(stream: MediaStream): MicStream;
+    /** Request access to the microphone and start monitoring incoming audio */
+    startMic(options?: RecordPluginDeviceOptions): Promise<MediaStream>;
+    /** Stop monitoring incoming audio */
+    stopMic(): void;
+    /** Start recording audio from the microphone */
+    startRecording(options?: RecordPluginDeviceOptions): Promise<void>;
+    /** Get the duration of the recording */
+    getDuration(): number;
+    /** Check if the audio is being recorded */
+    isRecording(): boolean;
+    isPaused(): boolean;
+    isActive(): boolean;
+    /** Stop the recording */
+    stopRecording(): void;
+    /** Pause the recording */
+    pauseRecording(): void;
+    /** Resume the recording */
+    resumeRecording(): void;
+    /** Get a list of available audio devices
+     * You can use this to get the device ID of the microphone to use with the startMic and startRecording methods
+     * Will return an empty array if the browser doesn't support the MediaDevices API or if the user has not granted access to the microphone
+     * You can ask for permission to the microphone by calling startMic
+     */
+    static getAvailableAudioDevices(): Promise<MediaDeviceInfo[]>;
+    /** Destroy the plugin */
+    destroy(): void;
+    private applyOriginalOptionsIfNeeded;
+}
+export default RecordPlugin;