@cometchat/chat-uikit-react 6.3.12 → 6.4.0

package/dist/types/components/CometChatCompactMessageComposer/CometChatCompactMessageComposer.d.ts

@@ -0,0 +1,247 @@
+import { JSX } from "react";
+import { CometChatTextFormatter } from "../../formatters/CometChatFormatters/CometChatTextFormatter";
+import { CometChatMessageComposerAction } from "../../modals";
+import { EnterKeyBehavior, PreviewMessageMode } from "../../Enums/Enums";
+export type ContentToDisplay = "attachments" | "emojiKeyboard" | "voiceRecording" | "ai" | "none";
+export type ActionOnClickType = (() => void) | null;
+interface MessageComposerProps {
+    /**
+     * The initial text pre-filled in the message input when the component mounts.
+     * @defaultValue ""
+     */
+    initialComposerText?: string;
+    /**
+     * Disables the typing indicator for the current message composer.
+     * @defaultValue `false`
+     */
+    disableTypingEvents?: boolean;
+    /**
+     * Disables the mentions functionality in the message composer.
+     * @defaultValue `false`
+     */
+    disableMentions?: boolean;
+    /**
+     * Hides the image attachment option in the message composer.
+     * @defaultValue `false`
+     */
+    hideImageAttachmentOption?: boolean;
+    /**
+     * Hides the video attachment option in the message composer.
+     * @defaultValue `false`
+     */
+    hideVideoAttachmentOption?: boolean;
+    /**
+     * Hides the audio attachment option in the message composer.
+     * @defaultValue `false`
+     */
+    hideAudioAttachmentOption?: boolean;
+    /**
+     * Hides the file attachment option in the message composer.
+     * @defaultValue `false`
+     */
+    hideFileAttachmentOption?: boolean;
+    /**
+     * Hides the polls option in the message composer.
+     * @defaultValue `false`
+     */
+    hidePollsOption?: boolean;
+    /**
+     * Hides the collaborative document option in the message composer.
+     * @defaultValue `false`
+     */
+    hideCollaborativeDocumentOption?: boolean;
+    /**
+     * Hides the collaborative whiteboard option in the message composer.
+     * @defaultValue `false`
+     */
+    hideCollaborativeWhiteboardOption?: boolean;
+    /**
+     * Hides the attachment button in the message composer.
+     * @defaultValue `false`
+     */
+    hideAttachmentButton?: boolean;
+    /**
+     * Hides the voice recording button in the message composer.
+     * @defaultValue `false`
+     */
+    hideVoiceRecordingButton?: boolean;
+    /**
+     * Hides the emoji keyboard button in the message composer.
+     * @defaultValue `false`
+     */
+    hideEmojiKeyboardButton?: boolean;
+    /**
+     * Hides the stickers button in the message composer.
+     * @defaultValue `false`
+     */
+    hideStickersButton?: boolean;
+    /**
+     * Hides the send button in the message composer.
+     * @defaultValue `false`
+     */
+    hideSendButton?: boolean;
+    /**
+     * The user to send messages to. This prop specifies the recipient of the message.
+     */
+    user?: CometChat.User;
+    /**
+     * The group to send messages to.
+     * @remarks This prop is used if the `user` prop is not provided.
+     */
+    group?: CometChat.Group;
+    /**
+     * The ID of the parent message. This is used for threading or replying to a specific message.
+     */
+    parentMessageId?: number;
+    /**
+     * Options for default attachments, including various attachment types available in the composer.
+     */
+    attachmentOptions?: CometChatMessageComposerAction[];
+    /**
+     * Array of text formatters to apply to the message text for customization and styling.
+     */
+    textFormatters?: Array<CometChatTextFormatter>;
+    /**
+     * Determines the behavior of the Enter key in the composer (e.g., send message or add a new line).
+     * @default EnterKeyBehavior.SendMessage
+     */
+    enterKeyBehavior?: EnterKeyBehavior;
+    /**
+     * Disables sound for incoming messages.
+     * @defaultValue `false`
+     */
+    disableSoundForMessage?: boolean;
+    /**
+     * Custom audio sound for incoming messages.
+     */
+    customSoundForMessage?: string;
+    /**
+     * Callback function triggered when the message input text changes.
+     * @param text - The current text value of the message input.
+     * @returns void
+     */
+    onTextChange?: (text: string) => void;
+    /**
+     * Callback function triggered when the message composer encounters an error.
+     * @param error - An instance of `CometChat.CometChatException` representing the error.
+     * @returns void
+     */
+    onError?: ((error: CometChat.CometChatException) => void) | null;
+    /**
+     * Callback function triggered when the send button is clicked.
+     * @param message - The message that was sent.
+     * @param previewMessageMode - Optionally, specify if the message is in preview mode.
+     */
+    onSendButtonClick?: (message: CometChat.BaseMessage, previewMessageMode?: PreviewMessageMode) => void;
+    /**
+     * A custom view for the send button to customize its appearance or behavior.
+     */
+    sendButtonView?: JSX.Element;
+    /**
+     * A custom view for an auxiliary button, which can be used alongside the send button.
+     */
+    auxiliaryButtonView?: JSX.Element;
+    /**
+     * A custom header section displayed at the top of the message composer.
+     */
+    headerView?: JSX.Element;
+    /**
+     * Controls the visibility of the scrollbar in the list.
+     * @defaultValue `false`
+     */
+    showScrollbar?: boolean;
+    /**
+     * The placeholder text to display in the message input field when it is empty.
+     * @defaultValue ""
+     */
+    placeholderText?: string;
+    /**
+     * Boolean to show or hide "@all" mention functionality in group chats.
+     * @defaultValue `false`
+     */
+    disableMentionAll?: boolean;
+    /**
+     * The mentionAll label for the app used to render "@all" mentions
+     * @defaultValue "all"
+     */
+    mentionAllLabel?: string;
+    /**
+     * Custom request builder for mentions user list.
+     * @defaultValue `undefined` - Uses default internal request builder.
+     */
+    mentionsUsersRequestBuilder?: CometChat.UsersRequestBuilder;
+    /**
+     * Custom request builder for mentions group members list.
+     * @defaultValue `undefined` - Uses default internal request builder
+     */
+    mentionsGroupMembersRequestBuilder?: CometChat.GroupMembersRequestBuilder;
+    /**
+     * Enables rich text editing capabilities in the message composer.
+     * @defaultValue `true`
+     */
+    enableRichTextEditor?: boolean;
+    /**
+     * Show floating toolbar when text is selected.
+     * NOTE: Ignored on mobile devices - falls back to fixed toolbar.
+     * @defaultValue false
+     */
+    showToolbarOnSelection?: boolean;
+    /**
+     * Hides the rich text formatting options (e.g., bold, italic, lists, links)
+     * in the message composer.
+     * @defaultValue false
+     */
+    hideRichTextFormattingOptions?: boolean;
+}
+/**
+ * Represents the state of the message composer.
+ */
+type State = {
+    text: string;
+    addToMsgInputText: string;
+    textMessageToEdit: CometChat.TextMessage | null;
+    messageToReply: CometChat.BaseMessage | null;
+    contentToDisplay: ContentToDisplay;
+    loggedInUser: CometChat.User | null;
+    showPoll: boolean;
+    showMentionsCountWarning: boolean;
+    showValidationError: boolean;
+};
+/**
+ * Represents the possible actions that can be dispatched to update the state.
+ */
+export type Action = {
+    type: "setText";
+    text: State["text"];
+} | {
+    type: "setAddToMsgInputText";
+    addToMsgInputText: State["addToMsgInputText"];
+} | {
+    type: "setTextMessageToEdit";
+    textMessageToEdit: State["textMessageToEdit"];
+} | {
+    type: "setMessageToReply";
+    messageToReply: State["messageToReply"];
+} | {
+    type: "setContentToDisplay";
+    contentToDisplay: ContentToDisplay;
+} | {
+    type: "setLoggedInUser";
+    loggedInUser: CometChat.User;
+} | {
+    type: "setShowPoll";
+    showPoll: boolean;
+} | {
+    type: "setShowMentionsCountWarning";
+    showMentionsCountWarning: boolean;
+} | {
+    type: "setShowValidationError";
+    showValidationError: boolean;
+};
+/**
+ * CometChatCompactMessageComposer - A single-line horizontal layout variant of the message composer.
+ * All UI elements (attachment button, text input, emoji button, voice recording button, stickers button,
+ * and send button) are arranged horizontally in one line.
+ */
+export declare function CometChatCompactMessageComposer(props: MessageComposerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/CometChatFormattingToolbar/CometChatFormattingToolbar.d.ts

@@ -0,0 +1,29 @@
+import React, { JSX } from 'react';
+import { FormatType, createRichTextFormatter } from '../../utils/RichTextFormatting';
+export interface FormattingToolbarProps {
+    /** Reference to the text input element for applying formatting */
+    textInputRef: React.RefObject<HTMLDivElement>;
+    /** Rich text formatter instance - can be null if rich text is disabled */
+    richTextFormatter: ReturnType<typeof createRichTextFormatter> | null;
+    /** Whether the toolbar is in floating mode (vs fixed) */
+    isFloating?: boolean;
+    /** Position for floating toolbar */
+    position?: {
+        top: number;
+        left: number;
+    };
+    /** Callback when toolbar visibility should change */
+    onVisibilityChange?: (visible: boolean) => void;
+    /** Currently active formats at caret position */
+    activeFormats?: FormatType[];
+    /** Callback when link button is clicked (to show link input) */
+    onLinkClick?: () => void;
+    /** Callback when formatting is applied - parent should update activeFormats */
+    onFormatApplied?: () => void;
+}
+/**
+ * CometChatFormattingToolbar - A formatting toolbar component
+ * Provides rich text formatting options including bold, italic, underline,
+ * strikethrough, links, lists, blockquote, and code formatting.
+ */
+export declare function CometChatFormattingToolbar(props: FormattingToolbarProps): JSX.Element | null;

package/dist/types/components/CometChatLinkDialog/CometChatLinkDialog.d.ts

@@ -0,0 +1,22 @@
+interface LinkDialogProps {
+    /** The initial URL value */
+    initialUrl?: string;
+    /** The initial display text value */
+    initialText?: string;
+    /** Whether to show the text input field (hide when text is already selected) */
+    showTextInput?: boolean;
+    /** Whether this is edit mode (changes title and button text) */
+    isEditMode?: boolean;
+    /** When true, focus the Link field on mount instead of the Text field */
+    focusLinkField?: boolean;
+    /** Callback when the link is submitted */
+    onSubmit: (url: string, displayText?: string) => void;
+    /** Callback when the dialog is cancelled */
+    onCancel: () => void;
+}
+/**
+ * CometChatLinkDialog - A dialog for adding/editing hyperlinks
+ * Shows URL input and optional display text input
+ */
+export declare function CometChatLinkDialog(props: LinkDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/CometChatLinkPopover/CometChatLinkPopover.d.ts

@@ -0,0 +1,24 @@
+import React from "react";
+interface LinkPopoverProps {
+    /** The link text displayed */
+    linkText: string;
+    /** The URL of the link */
+    linkUrl: string;
+    /** Position of the popover */
+    position: {
+        top: number;
+        left: number;
+    };
+    /** Callback when Edit button is clicked */
+    onEdit: () => void;
+    /** Callback when Remove button is clicked */
+    onRemove: () => void;
+    /** Callback when popover should close */
+    onClose: () => void;
+}
+/**
+ * CometChatLinkPopover - A popover that appears when clicking on a link
+ * Shows link text, URL (clickable), and Edit/Remove buttons
+ */
+declare const CometChatLinkPopover: React.FC<LinkPopoverProps>;
+export { CometChatLinkPopover };

package/dist/types/components/CometChatLinkPopover/index.d.ts

@@ -0,0 +1 @@
+export { CometChatLinkPopover } from "./CometChatLinkPopover";

package/dist/types/components/useRichTextComposer/useRichTextComposer.d.ts

@@ -0,0 +1,138 @@
+import { FormatType } from "../../utils/RichTextFormatting";
+import { CometChatTextFormatter } from "../../formatters/CometChatFormatters/CometChatTextFormatter";
+/**
+ * Configuration for the useRichTextComposer hook
+ */
+export interface RichTextComposerConfig {
+    enableRichTextEditor: boolean;
+    hideRichTextFormattingOptions: boolean;
+    showToolbarOnSelection: boolean;
+    getCurrentDocument: () => Document;
+    getCurrentWindow: () => Window;
+    getCurrentInput: () => Element | null | undefined;
+    composerContainerClass: string;
+    errorHandler: (error: unknown, context: string) => void;
+    setTextFormatters: React.Dispatch<React.SetStateAction<CometChatTextFormatter[]>>;
+}
+export interface LinkPopoverData {
+    linkText: string;
+    linkUrl: string;
+    linkElement: HTMLAnchorElement | null;
+    position: {
+        top: number;
+        left: number;
+    };
+}
+export interface LinkEditData {
+    url: string;
+    text: string;
+}
+/**
+ * State for undoing markdown conversions
+ */
+export interface MarkdownUndoState {
+    originalHtml: string;
+    cursorPosition: number;
+    timestamp: number;
+}
+/**
+ * Shared hook that encapsulates all rich text formatting logic
+ * used by both CometChatMessageComposer and CometChatCompactMessageComposer.
+ */
+export declare function useRichTextComposer(config: RichTextComposerConfig): {
+    isFixedToolbarVisible: boolean;
+    setIsFixedToolbarVisible: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    isFloatingToolbarVisible: boolean;
+    setIsFloatingToolbarVisible: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    floatingToolbarPosition: {
+        top: number;
+        left: number;
+    } | null;
+    activeFormats: FormatType[];
+    setActiveFormats: import("react").Dispatch<import("react").SetStateAction<FormatType[]>>;
+    showLinkInput: boolean;
+    showLinkPopover: boolean;
+    linkPopoverData: LinkPopoverData | null;
+    isLinkEditMode: boolean;
+    linkEditData: LinkEditData | null;
+    linkDialogSelectedText: string;
+    linkDialogSelectedTextRef: import("react").MutableRefObject<string>;
+    richTextFormatter: {
+        getSelection: () => Selection | null;
+        saveSelection: () => Range | null;
+        restoreSelection: (range: Range | null) => void;
+        hasSelection: () => boolean;
+        getSelectedText: (savedRange?: Range | null) => string;
+        isFormatted: (formatType: FormatType, containerElement: HTMLElement) => boolean;
+        isFormattingModeActive: () => boolean;
+        getActiveFormats: (containerElement: HTMLElement) => FormatType[];
+        getActiveFormattingModes: () => FormatType[];
+        findFormattingAncestor: () => HTMLElement | null;
+        applyFormat: () => void;
+        removeFormat: () => void;
+        toggleFormat: (formatType: FormatType, containerElement: HTMLElement) => void;
+        toggleFormattingMode: () => void;
+        toggleBold: (containerElement: HTMLElement) => void;
+        toggleItalic: (containerElement: HTMLElement) => void;
+        toggleUnderline: (containerElement: HTMLElement) => void;
+        toggleStrikethrough: (containerElement: HTMLElement) => void;
+        insertLink: (url: string, displayText: string | undefined, containerElement: HTMLElement) => void;
+        updateLink: (url: string, displayText: string | undefined, containerElement: HTMLElement) => void;
+        removeLink: (containerElement: HTMLElement) => void;
+        isInsideLink: (containerElement: HTMLElement) => boolean;
+        toggleOrderedList: (containerElement: HTMLElement) => void;
+        toggleUnorderedList: (containerElement: HTMLElement) => void;
+        fixOrderedListContinuation: (containerElement: HTMLElement) => void;
+        isInsideList: (listType: "orderedList" | "unorderedList", containerElement: HTMLElement) => HTMLElement | null;
+        isInsideAnyList: (containerElement: HTMLElement) => HTMLElement | null;
+        getCurrentListItem: (containerElement: HTMLElement) => HTMLLIElement | null;
+        isCurrentListItemEmpty: (containerElement: HTMLElement) => boolean;
+        isCursorAtListItemStart: (containerElement: HTMLElement) => boolean;
+        handleListBackspace: (containerElement: HTMLElement) => boolean;
+        handleListEnter: (containerElement: HTMLElement) => boolean;
+        handleListTab: (containerElement: HTMLElement, shiftKey: boolean) => boolean;
+        handleCodeBlockEnter: (containerElement: HTMLElement) => boolean;
+        handleCodeBlockBackspace: (containerElement: HTMLElement) => boolean;
+        handleAutoListTrigger: (containerElement: HTMLElement) => "orderedList" | "unorderedList" | null;
+        applyListInlineStyles: (containerElement: HTMLElement) => void;
+        toggleBlockquote: (containerElement: HTMLElement) => void;
+        isInsideBlockquote: (containerElement: HTMLElement) => HTMLElement | null;
+        toggleCodeInline: (containerElement: HTMLElement) => void;
+        toggleCodeBlock: (containerElement: HTMLElement) => void;
+        isInsideCodeInline: (containerElement: HTMLElement) => HTMLElement | null;
+        isInsideCodeBlock: (containerElement: HTMLElement) => HTMLElement | null;
+        handleInlineCodePreservation: (containerElement: HTMLElement, wasInsideInlineCode: boolean) => void;
+        clearFormattingModes: () => void;
+        resetFontContext: (containerElement?: HTMLElement) => void;
+        handleKeyboardShortcut: (event: KeyboardEvent, containerElement: HTMLElement) => boolean;
+        handleArrowKeyInCode: (event: KeyboardEvent, containerElement: HTMLElement) => boolean;
+        getPlainText: (htmlContent: string) => string;
+        normalizeHtml: (htmlContent: string) => string;
+        trimRichTextWhitespace: (html: string | null | undefined) => string;
+        handleMarkdownShortcuts: (containerElement: HTMLElement, onBeforeConversion?: () => void) => boolean;
+        clearPendingFormats: () => void;
+        getPendingFormats: () => FormatType[];
+        getTextOffsetAtCursor: (containerElement: HTMLElement) => number;
+        setCursorByTextOffset: (containerElement: HTMLElement, offset: number) => void;
+        convertMarkdownToFormat: (containerElement: HTMLElement, startOffset: number, endOffset: number, contentStart: number, contentEnd: number, formatType: FormatType, linkUrl?: string) => void;
+        positionCursorAfterFormat: (containerElement: HTMLElement, formattedNode: Node) => void;
+        applyMarkdownConversion: (containerElement: HTMLElement, match: {
+            startOffset: number;
+            endOffset: number;
+            contentStart: number;
+            contentEnd: number;
+            linkUrl?: string;
+        }, formatType: FormatType) => void;
+    } | null;
+    handleLinkClick: () => void;
+    handleLinkSubmit: (url: string, displayText?: string) => void;
+    handleLinkCancel: () => void;
+    handleInputClick: (event: React.MouseEvent) => void;
+    handleLinkPopoverEdit: () => void;
+    handleLinkPopoverRemove: () => void;
+    handleLinkPopoverClose: () => void;
+    handleFormatApplied: () => void;
+    handleFormattingKeyDown: (event: KeyboardEvent, contenteditable: Element) => boolean;
+    saveMarkdownUndoState: () => void;
+    handleMarkdownUndo: () => boolean;
+};

package/dist/types/formatters/CometChatFormatters/CometChatMarkdownFormatter/CometChatMarkdownFormatter.d.ts

@@ -0,0 +1,109 @@
+import { CometChatTextFormatter } from "../CometChatTextFormatter";
+import { MentionsTargetElement } from "../../../Enums/Enums";
+/**
+ * CometChatMarkdownFormatter
+ *
+ * Handles bidirectional conversion between HTML and markdown:
+ *
+ * BUBBLE SIDE (getFormattedText): Markdown → HTML for display
+ * - **bold** → <b>bold</b>
+ * - _italic_ → <i>italic</i>
+ * - <u>underline</u> → <u>underline</u> (pass-through)
+ * - ~~strikethrough~~ → <s>strikethrough</s>
+ * - `inline code` → <code>inline code</code>
+ * - ```code block``` → <pre><code>code block</code></pre>
+ * - > blockquote → <blockquote>blockquote</blockquote>
+ * - [text](url) → <a href="url">text</a>
+ *
+ * COMPOSER SIDE (getOriginalText): HTML → Markdown for storage
+ * - <b>bold</b> → **bold**
+ * - <i>italic</i> → _italic_
+ * - <u>underline</u> → <u>underline</u>
+ * - <s>strikethrough</s> → ~~strikethrough~~
+ * - <code>code</code> → `code`
+ * - <pre><code>code</code></pre> → ```code```
+ * - <blockquote>text</blockquote> → > text
+ * - <a href="url">text</a> → [text](url)
+ */
+export declare class CometChatMarkdownFormatter extends CometChatTextFormatter {
+    constructor();
+    /**
+     * BUBBLE SIDE: Convert markdown syntax to styled HTML for display
+     */
+    getFormattedText(inputText: string, params?: {
+        mentionsTargetElement?: MentionsTargetElement;
+    }): string;
+    /**
+     * COMPOSER SIDE: Pass through unchanged.
+     * HTML→Markdown conversion is handled exclusively by CometChatRichTextFormatter
+     * (via HtmlToMarkdown.ts). Running a second conversion here would double-process
+     * the text and corrupt mention spans before CometChatMentionsFormatter can replace
+     * them with <@uid:xxx> tokens.
+     */
+    getOriginalText(inputText: string | null | undefined): string;
+    /**
+     * Format code blocks: ```code``` → <pre><code>code</code></pre>
+     */
+    private formatCodeBlocks;
+    /**
+     * Apply a formatting function only to text segments outside of code blocks.
+     * Unlike formatOutsideCode, this does NOT split on inline <code> tags or mention placeholders.
+     * Used for blockquote processing which runs before inline code conversion.
+     */
+    private formatOutsideCodeBlocks;
+    /**
+     * Apply a formatting function only to text segments outside of code blocks and inline code.
+     * Splits the text by <pre><code>...</code></pre> and <code>...</code> segments,
+     * applies the formatter only to non-code parts, then reassembles.
+     */
+    private formatOutsideCode;
+    /**
+     * Format inline code: `code` → <code>code</code>
+     */
+    private formatInlineCode;
+    /**
+     * Format bold: **text** → <b>text</b>
+     */
+    private formatBold;
+    /**
+     * Format italic: _text_ → <i>text</i>
+     */
+    private formatItalic;
+    /**
+     * Format underline: <u>text</u> → <u>text</u>
+     * The markdown syntax uses HTML-style <u> tags directly.
+     * Also supports legacy ++text++ and __text__ for backward compatibility.
+     */
+    private formatUnderline;
+    /**
+     * Format strikethrough: ~~text~~ → <s>text</s>
+     */
+    private formatStrikethrough;
+    /**
+     * Format links: [text](url) → <a href="url">text</a>
+     */
+    private formatLinks;
+    /**
+     * Format blockquotes: > text → <blockquote>text</blockquote>
+     */
+    private formatBlockquotes;
+    /**
+     * Format ordered lists: 1. item → <li>item</li>
+     */
+    /**
+       * Format ordered lists: consecutive "N. item" lines → <ol><li>item</li></ol>
+       */
+    private formatOrderedLists;
+    /**
+     * Format unordered lists: • item or - item → <li>item</li>
+     */
+    /**
+       * Format unordered lists: consecutive "• item" or "- item" lines → <ul><li>item</li></ul>
+       */
+    private formatUnorderedLists;
+    /**
+     * Register click handlers for links
+     */
+    registerEventListeners(span: Element, classList: DOMTokenList): Element;
+    stripMarkdownForConversation(text: string): string;
+}

package/dist/types/formatters/CometChatFormatters/CometChatRichTextFormatter.d.ts

@@ -0,0 +1,32 @@
+import { CometChatTextFormatter } from "./CometChatTextFormatter";
+import { MentionsTargetElement } from "../../Enums/Enums";
+/**
+ * CometChatRichTextFormatter
+ *
+ * Handles rich text formatting for CometChat messages.
+ * - COMPOSER SIDE: Converts HTML from contenteditable to markdown for storage
+ * - BUBBLE SIDE: Passes through text as-is (markdown rendering handled by CometChatMarkdownFormatter)
+ */
+export declare class CometChatRichTextFormatter extends CometChatTextFormatter {
+    constructor();
+    /**
+     * BUBBLE SIDE: Pass through text as-is
+     * The CometChatMarkdownFormatter handles converting markdown to HTML for display
+     */
+    getFormattedText(inputText: string, _params?: {
+        mentionsTargetElement?: MentionsTargetElement;
+    }): string;
+    /**
+     * COMPOSER SIDE: Convert HTML from contenteditable to markdown
+     * This is called before sending the message to convert the rich HTML to markdown format
+     */
+    getOriginalText(inputText: string | null | undefined): string;
+    /**
+     * Check if the input contains HTML tags that need conversion
+     */
+    private containsHtmlTags;
+    /**
+     * Register click handlers for links in bubbles
+     */
+    registerEventListeners(span: Element, _classList: DOMTokenList): Element;
+}

package/dist/types/formatters/CometChatFormatters/CometChatUrlsFormatter/CometChatUrlsFormatter.d.ts

@@ -1,12 +1,18 @@
 import { CometChatTextFormatter } from "../CometChatTextFormatter";
 /**
  * Class that handles the text formatting for URLs in CometChat.
- * CometChatUrlsFormatter is a child class of CometChatTextFormatter.
- * It extends the functionality of text formatting to specifically handle URLs.
- * It is used in extension decorators like  link preview, message translation, and dataSource utils.
  */
 export declare class CometChatUrlsFormatter extends CometChatTextFormatter {
     constructor(regexPatterns: Array<RegExp>);
+    onKeyUp(event: KeyboardEvent): void;
+    /**
+     * DOM-based URL linkification for message bubbles.
+     * Walks ALL text nodes and wraps URLs in clickable spans.
+     * Never breaks HTML structure. URLs inside code blocks become clickable.
+     * Only skips text inside <a> tags.
+     */
     protected onRegexMatch(inputText?: string | null): string;
     registerEventListeners(element: HTMLElement, classList: DOMTokenList): HTMLElement;
+    formatComposerContent(_element: HTMLElement): void;
+    getOriginalText(inputText: string | null | undefined): string;
 }

package/dist/types/formatters/index.d.ts

@@ -2,3 +2,5 @@ export { CometChatTextFormatter } from './CometChatFormatters/CometChatTextForma
 export { CometChatUrlsFormatter } from './CometChatFormatters/CometChatUrlsFormatter/CometChatUrlsFormatter';
 export { CometChatMentionsFormatter } from './CometChatFormatters/CometChatMentionsFormatter/CometChatMentionsFormatter';
 export { CometChatTextHighlightFormatter } from './CometChatFormatters/CometChatTextHighlightFormatter/CometChatTextHighlightFormatter';
+export { CometChatRichTextFormatter } from './CometChatFormatters/CometChatRichTextFormatter';
+export { CometChatMarkdownFormatter } from './CometChatFormatters/CometChatMarkdownFormatter/CometChatMarkdownFormatter';

package/dist/types/index.d.ts

@@ -37,6 +37,7 @@ export { CometChatGroupMembers } from './components/CometChatGroupMembers/CometC
 export { CometChatGroups } from './components/CometChatGroups/CometChatGroups';
 export { CometChatMessageBubble } from './components/BaseComponents/CometChatMessageBubble/CometChatMessageBubble';
 export { CometChatMessageComposer } from './components/CometChatMessageComposer/CometChatMessageComposer';
+export { CometChatCompactMessageComposer } from './components/CometChatCompactMessageComposer/CometChatCompactMessageComposer';
 export { CometChatMessageHeader } from './components/CometChatMessageHeader/CometChatMessageHeader';
 export { CometChatMessageList } from './components/CometChatMessageList/CometChatMessageList';
 export { CometChatUsers } from './components/CometChatUsers/CometChatUsers';
@@ -123,4 +124,3 @@ export { CometChatAIAssistantTools } from './modals/CometChatAIAssistantTools';
 export { CometChatStreamMessageBubble } from './components/BaseComponents/CometChatStreamMessageBubble/CometChatStreamMessageBubble';
 export { CometChatAIAssistantMessageBubble } from './components/BaseComponents/CometChatAIAssistantMessageBubble/CometChatAIAssistantMessageBubble';
 export { CometChatAIAssistantChatHistory } from './components/CometChatAIAssistantChatHistory/CometChatAIAssistantChatHistory';
-export { useSecureMedia, resolveSecureUrl, requiresSecureMediaAccess } from './utils/useSecureMedia';

package/dist/types/utils/EmojiShortcodeUtils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Replaces all unicode emoji characters in a string with their :shortcode: equivalents.
+ * Handles multi-codepoint emoji (ZWJ sequences, variation selectors, skin tones).
+ * Unknown emoji characters (not in emojis.ts) pass through unchanged.
+ */
+export declare function emojiToShortcode(text: string): string;
+/**
+ * Replaces all :shortcode: patterns in a string with their unicode emoji characters.
+ * Unknown shortcodes pass through unchanged.
+ */
+export declare function shortcodeToEmoji(text: string): string;