> ## Documentation Index
> Fetch the complete documentation index at: https://cometchat-22654f5b-docs-agent-in-group-react-v6.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Message Composer

> Message Composer — CometChat documentation.

## Overview

MessageComposer is a [Component](/ui-kit/react/v4/components-overview#components) that enables users to write and send a variety of messages, including text, image, video, and custom messages.

Features such as **Live Reaction**, **Attachments**, and **Message Editing** are also supported by it.

<Frame>
  <img src="https://mintcdn.com/cometchat-22654f5b-docs-agent-in-group-react-v6/8U2-5SWHI94obVDJ/images/9be9312d-message_composer_overview_web_screens-2b93f69f771b6085ce3460a7c08b8a54.png?fit=max&auto=format&n=8U2-5SWHI94obVDJ&q=85&s=778c0bf95f558aec6a29df6adb435b2e" width="3600" height="2400" data-path="images/9be9312d-message_composer_overview_web_screens-2b93f69f771b6085ce3460a7c08b8a54.png" />
</Frame>

MessageComposer is comprised of the following [Base Components](/ui-kit/react/v4/components-overview#base-components):

| Base Components                                | Description                                                                                                            |
| ---------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
| [MessageInput](/ui-kit/react/v4/message-input) | This provides a basic layout for the contents of this component, such as the TextField and buttons                     |
| [ActionSheet](/ui-kit/react/v4/action-sheet)   | The ActionSheet component presents a list of options in either a list or grid mode, depending on the user's preference |

## Usage

### Integration

The following code snippet illustrates how you can directly incorporate the MessageComposer component into your app.

<Tabs>
  <Tab title="MessageComposerDemo.tsx">
    ```typescript theme={null}
    import React from "react";
    import { CometChat } from "@cometchat/chat-sdk-javascript";
    import { CometChatMessageComposer } from "@cometchat/chat-uikit-react";

      export function MessageComposerDemo() {
        const [chatUser, setChatUser] = React.useState<CometChat.User>()
        React.useEffect(() => {
            CometChat.getUser("uid").then((user) => {
                setChatUser(user);
            })
        }, [])

        return chatUser ? (
          <div>
            <CometChatMessageComposer
              user={chatUser}
            />
          </div>
        ) : null;
      }
    ```
  </Tab>

  <Tab title="App.tsx">
    ```typescript theme={null}
    import { MessageComposerDemo } from "./MessageComposerDemo";

    export default function App() {
      return (
        <div className='App'>
          <div>
            <MessageComposerDemo />
          </div>
        </div>
      );
    }
    ```
  </Tab>
</Tabs>

### Actions

[Actions](/ui-kit/react/v4/components-overview#actions) dictate how a component functions. They are divided into two types: Predefined and User-defined. You can override either type, allowing you to tailor the behavior of the component to fit your specific needs.

#### 1. OnSendButtonClick

The `OnSendButtonClick` event gets activated when the send message button is clicked. It has a predefined function of sending messages entered in the composer `EditText`. However, you can overide this action with the following code snippet.

<Tabs>
  <Tab title="MessageComposerDemo.tsx">
    ```typescript theme={null}
    import React from "react";
    import { CometChat } from "@cometchat/chat-sdk-javascript";
    import { CometChatMessageComposer } from "@cometchat/chat-uikit-react";

      export function MessageComposerDemo() {
        const [chatUser, setChatUser] = React.useState<CometChat.User>()
        React.useEffect(() => {
            CometChat.getUser("uid").then((user) => {
                setChatUser(user);
            })
        }, [])

        function getOnSendButtonClick(message: CometChat.BaseMessage): void {
            console.log("your custom on send buttonclick action");
        }
        return chatUser ? (
          <div>
            <CometChatMessageComposer
              onSendButtonClick={getOnSendButtonClick}
            />
          </div>
        ) : null;
      }
    ```
  </Tab>
</Tabs>

#### 2. onError

This action doesn't change the behavior of the component but rather listens for any errors that occur in the MessageList component.

<Tabs>
  <Tab title="MessageComposerDemo.tsx">
    ```typescript theme={null}
    import React from "react";
    import { CometChat } from "@cometchat/chat-sdk-javascript";
    import { CometChatMessageComposer } from "@cometchat/chat-uikit-react";

      export function MessageComposerDemo() {
        const [chatUser, setChatUser] = React.useState<CometChat.User>()
        React.useEffect(() => {
            CometChat.getUser("uid").then((user) => {
                setChatUser(user);
            })
        }, [])
        function handleError(error: CometChat.CometChatException) {
            throw new Error("your custom error action");
        }
        return chatUser ? (
          <div>
            <CometChatMessageComposer
              user={chatUser}
              onError={handleError}
            />
          </div>
        ) : null;
      }
    ```
  </Tab>
</Tabs>

***

### Filters

MessageComposer component does not have any available filters.

***

### Events

[Events](/ui-kit/react/v4/components-overview#events) are emitted by a `Component`. By using event you can extend existing functionality. Being global events, they can be applied in Multiple Locations and are capable of being Added or Removed.

The list of events emitted by the Messages component is as follows.

| Event               | Description                                                                                                                                     |
| ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
| **ccMessageEdited** | Triggers whenever a loggedIn user edits any message from the list of messages .it will have three states such as: inProgress, success and error |
| **ccMessageSent**   | Triggers whenever a loggedIn user sends any message, it will have three states such as: inProgress, success and error                           |
| **ccLiveReaction**  | Triggers whenever a loggedIn clicks on live reaction                                                                                            |

Adding `CometChatMessageEvents` Listener's

<Tabs>
  <Tab title="JavaScript">
    ```javascript theme={null}
    import {CometChatMessageEvents} from "@cometchat/chat-uikit-react";

    const ccMessageEdited = CometChatMessageEvents.ccMessageEdited.subscribe(
     () => {
            // Your Code
      }
    );

    const ccMessageSent = CometChatMessageEvents.ccMessageSent.subscribe(
      () => {
            // Your Code
      }
    );

    const ccLiveReaction = CometChatMessageEvents.ccLiveReaction.subscribe(
      () => {
            // Your Code
      }
    );
    ```
  </Tab>
</Tabs>

***

Removing `CometChatMessageEvents` Listener's

<Tabs>
  <Tab title="JavaScript">
    ```javascript theme={null}
    ccMessageEdited?.unsubscribe();
    ccMessageSent?.unsubscribe();
    ```
  </Tab>
</Tabs>

***

## Customization

To fit your app's design requirements, you can customize the appearance of the MessageComposer component. We provide exposed methods that allow you to modify the experience and behavior according to your specific needs.

### Style

Using Style you can customize the look and feel of the component in your app, These parameters typically control elements such as the color, size, shape, and fonts used within the component.

#### 1. MessageComposer Style

To modify the styling, you can apply the MessageComposerStyle to the MessageComposer Component using the `messageComposerStyle` property.

<Tabs>
  <Tab title="MessageComposerDemo.tsx">
    ```typescript theme={null}
    import React from "react";
    import { CometChat } from "@cometchat/chat-sdk-javascript";
    import { CometChatMessageComposer, MessageComposerStyle } from "@cometchat/chat-uikit-react";

      export function MessageComposerDemo() {
        const [chatUser, setChatUser] = React.useState<CometChat.User>()
        React.useEffect(() => {
            CometChat.getUser("uid").then((user) => {
                setChatUser(user);
            })
        }, [])
        const messageComposerStyle = new MessageComposerStyle({
            AIIconTint:"#ec03fc",
            attachIcontint:"#ec03fc",
            background:"#fffcff",
            border:"2px solid #b30fff",
            borderRadius:"20px",
            inputBackground:"#e2d5e8",
            textColor:"#ff299b",
            sendIconTint:"#ff0088",
            liveReactionIconTint:"#ff0088"
        })
        return chatUser ? (
          <div>
            <CometChatMessageComposer
              user={chatUser}
              messageComposerStyle={messageComposerStyle}
            />
          </div>
        ) : null;
      }
    ```
  </Tab>
</Tabs>

The following properties are exposed by MessageComposerStyle:

| Property                   | Description                            | Code                               |
| -------------------------- | -------------------------------------- | ---------------------------------- |
| **border**                 | Used to set border                     | `border?: string,`                 |
| **borderRadius**           | Used to set border radius              | `borderRadius?: string;`           |
| **background**             | Used to set background colour          | `background?: string;`             |
| **height**                 | Used to set height                     | `height?: string;`                 |
| **width**                  | Used to set width                      | `width?: string;`                  |
| **inputBackground**        | Used to set input background color     | `inputBackground?: string;`        |
| **inputBorder**            | used to set input border               | `inputBorder?: string;`            |
| **inputBorderRadius**      | used to set input border radius        | `inputBorderRadius?: string;`      |
| **textFont**               | Used to set input text font            | `textFont?: string;`               |
| **textColor**              | used to set input text color           | `textColor?: string;`              |
| **placeHolderTextColor**   | Used to set placeholder text color     | `placeHolderTextColor?: string;`   |
| **placeHolderTextFont**    | Used to set placeholder text font      | `placeHolderTextFont?: string;`    |
| **attachIcontint**         | Used to set attachment icon tint       | `attachIcontint?: string;`         |
| **sendIconTint**           | Used to set send button icon tint      | `sendIconTint?: string;`           |
| **dividerTint**            | Used to set separator color            | `dividerTint?: string;`            |
| **liveReactionIconTint**   | Used to set live reaction icon color   | `liveReactionIconTint?: string;`   |
| **voiceRecordingIconTint** | used to set voice recording icon color | `voiceRecordingIconTint?: string;` |
| **emojiIconTint**          | used to set emoji icon color           | `emojiIconTint?: string;`          |
| **AIIconTint**             | used to set AI icon color              | `AIIconTint?: string;`             |
| **emojiKeyboardTextFont**  | used to set emoji keyboard text font   | `emojiKeyboardTextFont?: string;`  |
| **previewTitleFont**       | used to set preview title font         | `previewTitleFont?: string;`       |
| **previewTitleColor**      | used to set preview title color        | `previewTitleColor?: string;`      |
| **previewSubtitleFont**    | used to set preview subtitle font      | `previewSubtitleFont?: string;`    |
| **previewSubtitleColor**   | used to set preview subtitle color     | `previewSubtitleColor?: string;`   |
| **closePreviewTint**       | used to set close preview color        | `closePreviewTint?: string;`       |
| **maxInputHeight**         | used to set max input height           | `maxInputHeight?: string;`         |

#### 2. MediaRecorder Style

To customize the styles of the MediaRecorder component within the MessageComposer Component, use the `mediaRecorderStyle` property. For more details, please refer to [MediaRecorder](/ui-kit/react/v4/media-recorder) styles.

<Tabs>
  <Tab title="MessageComposerDemo.tsx">
    ```typescript theme={null}
    import React from "react";
    import { CometChat } from "@cometchat/chat-sdk-javascript";
    import { CometChatMessageComposer, MediaRecorderStyle } from "@cometchat/chat-uikit-react";

      export function MessageComposerDemo() {
        const [chatUser, setChatUser] = React.useState<CometChat.User>()
        React.useEffect(() => {
            CometChat.getUser("uid").then((user) => {
                setChatUser(user);
            })
        }, [])
        const mediaRecorderStyle = new MediaRecorderStyle({
            background:"#f2f5fa",
            border:"2px solid #be0be6",
            closeIconTint:"#830be6",
            submitIconTint:"#c2a3ff",
            startIconTint:"#a313f0"
        })
        return chatUser ? (
          <div>
            <CometChatMessageComposer
              user={chatUser}
              mediaRecorderStyle={mediaRecorderStyle}
            />
          </div>
        ) : null;
      }
    ```
  </Tab>
</Tabs>

#### 3. MentionsWarning Style

To customize the styles of the MentionsWarning within the MessageComposer Component, use the `mentionsWarningStyle` property.

<Tabs>
  <Tab title="MessageComposerDemo.tsx">
    ```typescript theme={null}
    import React from "react";
    import { CometChat } from "@cometchat/chat-sdk-javascript";
    import { CometChatMessageComposer } from "@cometchat/chat-uikit-react";

      export function MessageComposerDemo() {
        const [chatUser, setChatUser] = React.useState<CometChat.User>()
        React.useEffect(() => {
            CometChat.getUser("uid").then((user) => {
                setChatUser(user);
            })
        }, [])
        const mentionsWarningStyle: any = ({
        backgroundColor:'red',
        height:'50px',
        width:'200px'
        });
        return chatUser ? (
          <div>
            <CometChatMessageComposer
              user={chatUser}
              mentionsWarningStyle={mentionsWarningStyle}
            />
          </div>
        ) : null;
      }
    ```
  </Tab>
</Tabs>

***

### Functionality

These are a set of small functional customizations that allow you to fine-tune the overall experience of the component. With these, you can change text, set custom icons, and toggle the visibility of UI elements.

<Tabs>
  <Tab title="MessageComposerDemo.tsx">
    ```typescript theme={null}
    import React from "react";
    import { CometChat } from "@cometchat/chat-sdk-javascript";
    import { CometChatMessageComposer } from "@cometchat/chat-uikit-react";

      export function MessageComposerDemo() {
        const [chatUser, setChatUser] = React.useState<CometChat.User>()
        React.useEffect(() => {
            CometChat.getUser("uid").then((user) => {
                setChatUser(user);
            })
        }, [])
        return chatUser ? (
          <div>
            <CometChatMessageComposer
              user={chatUser}
              hideLiveReaction={true}
              disableTypingEvents={true}
            />
          </div>
        ) : null;
      }
    ```
  </Tab>
</Tabs>

Below is a list of customizations along with corresponding code snippets

| Property                        | Description                                                                                                                                                                                                                                     | Code                                                                    |
| ------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------- |
| **User** [report]()             | Used to pass user object of which header specific details will be show                                                                                                                                                                          | `user={chatUser}`                                                       |
| **Group** [report]()            | Used to pass group object of which header specific details will be shown                                                                                                                                                                        | `group={chatGroup}`                                                     |
| **placeHolderText**             | Used to set composer's placeholder text                                                                                                                                                                                                         | `placeHolderText="your custom placeholder text"`                        |
| **mentionsWarningText**         | Text to be displayed when max limit reaches for valid mentions                                                                                                                                                                                  | `mentionsWarningText="Your Custom Mentions warning Text"`               |
| **disableTypingEvents**         | Used to disable/enable typing events , default false                                                                                                                                                                                            | `disableTypingEvents={true}`                                            |
| **disableSoundForMessages**     | Used to toggle sound for outgoing messages                                                                                                                                                                                                      | `disableSoundForMessages={true}`                                        |
| **sendButtonIconURL**           | Used to set send button icon                                                                                                                                                                                                                    | `sendButtonIconURL="your custom isend button icon url"`                 |
| **text**                        | Used to set predefined text                                                                                                                                                                                                                     | `text="Your custom text"`                                               |
| **voiceRecordingStartIconURL**  | Sets custom icon for voice recording start.                                                                                                                                                                                                     | `voiceRecordingStartIconURL="your custom voice recording start icon"`   |
| **voiceRecordingStopIconURL**   | Sets custom icon for voice recording stop.                                                                                                                                                                                                      | `voiceRecordingStopIconURL="your custom voice recording stop icon"`     |
| **voiceRecordingCloseIconURL**  | Sets custom icon for voice recording close.                                                                                                                                                                                                     | `voiceRecordingCloseIconURL="your custom voice recording close icon"`   |
| **voiceRecordingSubmitIconURL** | Sets custom icon for voice recording submit                                                                                                                                                                                                     | `voiceRecordingSubmitIconURL="your custom voice recording submit icon"` |
| **auxiliaryButtonAlignment**    | controls position of auxiliary button view , can be **left** or **right** . default **right**                                                                                                                                                   | `auxiliaryButtonAlignment={AuxiliaryButtonAlignment.left}`              |
| **attachmentIconURL**           | sets the icon to show in the attachment button                                                                                                                                                                                                  | `attachmentIconURL="your custom attachment icon url"`                   |
| **hideLiveReaction**            | used to toggle visibility for live reaction component                                                                                                                                                                                           | `hideLiveReaction={true}`                                               |
| **customSoundForMessage**       | Used to give custom sounds to outgoing messages                                                                                                                                                                                                 | `customSoundForMessage="your custom sound for messages"`                |
| **LiveReactionIconURL**         | used to set custom live reaction icon.                                                                                                                                                                                                          | `LiveReactionIconURL="your custom live reaction icon"`                  |
| **AIIconURL**                   | used to set custom AI icon.                                                                                                                                                                                                                     | `AIIconURL="your custom AI icon"`                                       |
| **emojiIconURL**                | used to set custom emoji icon.                                                                                                                                                                                                                  | `emojiIconURL="your custom emoji icon"`                                 |
| **hideLayoutMode**              | used to hide the layout mode.                                                                                                                                                                                                                   | `hideLayoutMode={true}`                                                 |
| **hideVoiceRecording**          | used to hide the voice recording option.                                                                                                                                                                                                        | `hideVoiceRecording={true}`                                             |
| **Disable Mentions**            | Sets whether mentions in text should be disabled. Processes the text formatters If there are text formatters available and the disableMentions flag is set to true, it removes any formatters that are instances of CometChatMentionsFormatter. | `disableMentions={true}`                                                |

***

### Advanced

For advanced-level customization, you can set custom views to the component. This lets you tailor each aspect of the component to fit your exact needs and application aesthetics. You can create and define your views, layouts, and UI elements and then incorporate those into the component.

***

#### AttachmentOptions

By using `attachmentOptions`, you can set a list of custom `MessageComposerActions` for the MessageComposer Component. This will override the existing list of `MessageComposerActions`.

**Example**

<Frame>
  <img src="https://mintcdn.com/cometchat-22654f5b-docs-agent-in-group-react-v6/8U2-5SWHI94obVDJ/images/9e67a562-message_composer_attachment_options_web_screens-9158001a6ceedd039fdf223b7e52148e.png?fit=max&auto=format&n=8U2-5SWHI94obVDJ&q=85&s=744b2dedd5a1026b0efbaeda87ae8829" width="3600" height="2400" data-path="images/9e67a562-message_composer_attachment_options_web_screens-9158001a6ceedd039fdf223b7e52148e.png" />
</Frame>

<Tabs>
  <Tab title="MessageComposerDemo.tsx">
    ```typescript theme={null}
    import React from "react";
    import { CometChat } from "@cometchat/chat-sdk-javascript";
    import { CometChatMessageComposer, CometChatMessageComposerAction } from "@cometchat/chat-uikit-react";

      export function MessageComposerDemo() {
        const [chatUser, setChatUser] = React.useState<CometChat.User>()
        React.useEffect(() => {
            CometChat.getUser("uid").then((user) => {
                setChatUser(user);
            })
        }, [])
        return chatUser ? (
          <div>
            <CometChatMessageComposer
              user={chatUser}
              attachmentOptions={(userOrGroup, composerId) => {
                const CustomAttachment = [
                    new CometChatMessageComposerAction({
                        id: 'your custom id',
                        iconURL: 'your custom icon',
                        background: 'blue',
                        title: 'Your Custom Title',
                        iconTint: '#9000ff'
                    })
                ];

                if(userOrGroup instanceof CometChat.User) {
                  //push user specific custom attachment options
                } else if(userOrGroup instanceof CometChat.Group) {
                  //push group specific custom attachment options
                }
                return CustomAttachment;
            }}
            />
          </div>
        ) : null;
      }
    ```
  </Tab>
</Tabs>

***

#### AuxiliaryButtonView

You can insert a custom view into the MessageComposer component to add additional functionality using the following method.

Please note that the MessageComposer Component utilizes the AuxiliaryButton to provide sticker functionality. Overriding the AuxiliaryButton will subsequently replace the sticker functionality.

In this example, we'll be adding a custom SOS button.

**Example**

<Frame>
  <img src="https://mintcdn.com/cometchat-22654f5b-docs-agent-in-group-react-v6/fW0PxkjcCIs_jips/images/d041d287-message_composer_auxiliary_web_screens-7c496d1ce9aeb26c7ba6710601c44503.png?fit=max&auto=format&n=fW0PxkjcCIs_jips&q=85&s=7cebc7866fd281ffc2d1388b56a6c256" width="3600" height="2400" data-path="images/d041d287-message_composer_auxiliary_web_screens-7c496d1ce9aeb26c7ba6710601c44503.png" />
</Frame>

<Tabs>
  <Tab title="MessageComposerDemo.tsx">
    ```typescript theme={null}
    import React from "react";
    import { CometChat } from "@cometchat/chat-sdk-javascript";
    import { CometChatMessageComposer, IconStyle } from "@cometchat/chat-uikit-react";

      export function MessageComposerDemo() {
        const [chatUser, setChatUser] = React.useState<CometChat.User>()
        React.useEffect(() => {
            CometChat.getUser("uid").then((user) => {
                setChatUser(user);
            })
        }, [])
        const getAuxiliaryButtonView = (userOrGroup: CometChat.User | CometChat.Group, composerId: ComposerId): JSX.Element => {
            const iconStyle = new IconStyle({
                iconTint:"#d400ff",
                height:"30px",
                width:"30px"
            })
            return (
                <cometchat-icon name="custom name" URL="your custom icon url" iconStyle={JSON.stringify(iconStyle)} />
            );
        };

        return chatUser ? (
          <div>
            <CometChatMessageComposer
              user={chatUser}
              auxiliaryButtonView={getAuxiliaryButtonView}
            />
          </div>
        ) : null;
      }
    ```
  </Tab>
</Tabs>

***

#### SecondaryButtonView

You can add a custom view into the SecondaryButton component for additional functionality using the below method.

In this example, we'll be adding a custom SOS button.

**Example**

<Frame>
  <img src="https://mintcdn.com/cometchat-22654f5b-docs-agent-in-group-react-v6/wITpHRGFWGJvJnmU/images/e8ce4c31-message_composer_secondary_web_screens-7554f7a932dbbcb9ad1a7d78fbbb4014.png?fit=max&auto=format&n=wITpHRGFWGJvJnmU&q=85&s=38fb115b8d91feb0173cab7ee874f72e" width="3600" height="2400" data-path="images/e8ce4c31-message_composer_secondary_web_screens-7554f7a932dbbcb9ad1a7d78fbbb4014.png" />
</Frame>

<Tabs>
  <Tab title="MessageComposerDemo.tsx">
    ```typescript theme={null}
    import React from "react";
    import { CometChat } from "@cometchat/chat-sdk-javascript";
    import { CometChatMessageComposer, IconStyle } from "@cometchat/chat-uikit-react";

      export function MessageComposerDemo() {
        const [chatUser, setChatUser] = React.useState<CometChat.User>()
        React.useEffect(() => {
            CometChat.getUser("uid").then((user) => {
                setChatUser(user);
            })
        }, [])
        const getSecondaryButtonView = (userOrGroup: CometChat.User | CometChat.Group, composerId: ComposerId): JSX.Element => {
            const iconStyle = new IconStyle({
                iconTint:"#d400ff",
                height:"30px",
                width:"30px"
            })
            return (
                <cometchat-icon name="SOS" URL="your custom icon url" iconStyle={JSON.stringify(iconStyle)} />
            );
        };

        return chatUser ? (
          <div>
            <CometChatMessageComposer
              user={chatUser}
              secondaryButtonView={getSecondaryButtonView}
            />
          </div>
        ) : null;
      }
    ```
  </Tab>
</Tabs>

***

#### SendButtonView

You can set a custom view in place of the already existing send button view. Using the following method.

**Example**

<Frame>
  <img src="https://mintcdn.com/cometchat-22654f5b-docs-agent-in-group-react-v6/H3wU8vJF-bF9IftS/images/7119b004-message_composer_send_button_rview_web_screens-b51cef158fa99e5ac914edaebb1f05e8.png?fit=max&auto=format&n=H3wU8vJF-bF9IftS&q=85&s=dbdeda5732a5ac4d9106e7b7874e0f3d" width="3600" height="2400" data-path="images/7119b004-message_composer_send_button_rview_web_screens-b51cef158fa99e5ac914edaebb1f05e8.png" />
</Frame>

<Tabs>
  <Tab title="MessageComposerDemo.tsx">
    ```typescript theme={null}
    import React from "react";
    import { CometChat } from "@cometchat/chat-sdk-javascript";
    import { CometChatMessageComposer, IconStyle } from "@cometchat/chat-uikit-react";

      export function MessageComposerDemo() {
        const [chatUser, setChatUser] = React.useState<CometChat.User>()
        React.useEffect(() => {
            CometChat.getUser("uid").then((user) => {
                setChatUser(user);
            })
        }, [])
        const getSendButtonView = (userOrGroup: CometChat.User | CometChat.Group, composerId: ComposerId): JSX.Element => {
            const iconStyle = new IconStyle({
                iconTint:"#d400ff",
                height:"30px",
                width:"30px"
            })
            return (
                <cometchat-icon name="send message" URL="your custom icon url" iconStyle={JSON.stringify(iconStyle)} />
            );
        };

        return chatUser ? (
          <div>
            <CometChatMessageComposer
              user={chatUser}
              sendButtonView={getSendButtonView}
            />
          </div>
        ) : null;
      }
    ```
  </Tab>
</Tabs>

***

#### HeaderView

You can set custom headerView to the MessageComposer component using the following method

In the following example, we're going to apply a mock chat bot button to the MessageComposer Component using the `headerView` property.

**Example**

<Frame>
  <img src="https://mintcdn.com/cometchat-22654f5b-docs-agent-in-group-react-v6/8U2-5SWHI94obVDJ/images/9fe95d42-message_composer_headerview_web_screens-e5a333e13a0f9ec1958004d403bd1271.png?fit=max&auto=format&n=8U2-5SWHI94obVDJ&q=85&s=fb47d08fbb35efe70e140194040ff313" width="3600" height="2400" data-path="images/9fe95d42-message_composer_headerview_web_screens-e5a333e13a0f9ec1958004d403bd1271.png" />
</Frame>

<Tabs>
  <Tab title="MessageComposerDemo.tsx">
    ```typescript theme={null}
    import React from "react";
    import { CometChat } from "@cometchat/chat-sdk-javascript";
    import { CometChatMessageComposer } from "@cometchat/chat-uikit-react";

      export function MessageComposerDemo() {
        const [chatUser, setChatUser] = React.useState<CometChat.User>()
        React.useEffect(() => {
            CometChat.getUser("uid").then((user) => {
                setChatUser(user);
            })
        }, [])
        const getHeaderView = () => {
            return (
                <div style={{ height: '40px', width: '100px', background: '#a46efa', borderRadius: '20px', display: 'flex', justifyContent: 'center', alignItems: 'center',  margin:'10px'}}>
                    <button style={{ height: '40px', width: '40px', background: '#a46efa', border: 'none', display: 'flex', justifyContent: 'center', alignItems: 'center' }}>
                        <img src="custom image" style={{ height: 'auto', width: '100%', maxWidth: '100%', maxHeight: '100%', borderRadius: '50%'}} alt="bot" />
                        <span>Chat Bot</span>
                    </button>
                </div>
            )
        }
        return chatUser ? (
          <div>
            <CometChatMessageComposer
              user={chatUser}
              headerView={getHeaderView()}
            />
          </div>
        ) : null;
      }
    ```
  </Tab>
</Tabs>

***

#### TextFormatters

Assigns the list of text formatters. If the provided list is not null, it sets the list. Otherwise, it assigns the default text formatters retrieved from the data source. To configure the existing Mentions look and feel check out [CometChatMentionsFormatter](/ui-kit/react/v4/mentions-formatter-guide)

**Example**

<Frame>
  <img src="https://mintcdn.com/cometchat-22654f5b-docs-agent-in-group-react-v6/aivwqvtoO_fTqj20/images/fb445527-shortcutformatter-4818505361f333ec7728b029e9b2da54.png?fit=max&auto=format&n=aivwqvtoO_fTqj20&q=85&s=c616653964df85c62878d38fee128a89" width="1800" height="1200" data-path="images/fb445527-shortcutformatter-4818505361f333ec7728b029e9b2da54.png" />
</Frame>

<Tabs>
  <Tab title="ShortCutFormatter.ts">
    ```typescript theme={null}
    import { CometChatTextFormatter } from "@cometchat/chat-uikit-react";
    import DialogHelper from './Dialog';
    import {CometChat} from "@cometchat/chat-sdk-javascript";

    class ShortcutFormatter extends CometChatTextFormatter {
        private shortcuts: { [key: string]: string } = {};
        private dialogIsOpen: boolean = false;
        private dialogHelper = new DialogHelper();
        private currentShortcut: string | null = null; // Track the currently open shortcut

        constructor() {
        super();
        this.setTrackingCharacter('!');
        CometChat.callExtension('message-shortcuts', 'GET', 'v1/fetch', undefined)
        .then((data: any) => {
          if (data && data.shortcuts) {
              this.shortcuts = data.shortcuts;
          }
        })
        .catch(error => console.log("error fetching shortcuts", error));
    }



        onKeyDown(event: KeyboardEvent) {
            const caretPosition = this.currentCaretPosition instanceof Selection
                ? this.currentCaretPosition.anchorOffset
                : 0;
            const textBeforeCaret = this.getTextBeforeCaret(caretPosition);

            const match = textBeforeCaret.match(/!([a-zA-Z]+)$/);
            if (match) {
                const shortcut = match[0];
                const replacement = this.shortcuts[shortcut];
                if (replacement) {
                    // Close the currently open dialog, if any
                    if (this.dialogIsOpen && this.currentShortcut !== shortcut) {
                        this.closeDialog();
                    }
                    this.openDialog(replacement, shortcut);
                }
            }
        }

        getCaretPosition() {
            if (!this.currentCaretPosition?.rangeCount) return { x: 0, y: 0 };
            const range = this.currentCaretPosition?.getRangeAt(0);
            const rect = range.getBoundingClientRect();
            return {
                x: rect.left,
                y: rect.top
            };
        }

        openDialog(buttonText: string, shortcut: string) {
            this.dialogHelper.createDialog(() => this.handleButtonClick(buttonText), buttonText);
            this.dialogIsOpen = true;
            this.currentShortcut = shortcut;
        }


        closeDialog() {
            this.dialogHelper.closeDialog(); // Use DialogHelper to close the dialog
            this.dialogIsOpen = false;
            this.currentShortcut = null;
        }

        handleButtonClick = (buttonText: string) => {
            if (this.currentCaretPosition && this.currentRange) {
                // Inserting the replacement text corresponding to the shortcut
                const shortcut = Object.keys(this.shortcuts).find(key => this.shortcuts[key] === buttonText);
                if (shortcut) {
                    const replacement = this.shortcuts[shortcut];
                    this.addAtCaretPosition(replacement, this.currentCaretPosition, this.currentRange);
                }
            }
            if (this.dialogIsOpen) {
                this.closeDialog();
            }
        };

        getFormattedText(text: string): string {
            return text;
        }

        private getTextBeforeCaret(caretPosition: number): string {
            if (this.currentRange && this.currentRange.startContainer && typeof this.currentRange.startContainer.textContent === "string") {
                const textContent = this.currentRange.startContainer.textContent;
                if (textContent.length >= caretPosition) {
                    return textContent.substring(0, caretPosition);
                }
            }
            return "";
        }
    }

    export default ShortcutFormatter;
    ```
  </Tab>

  <Tab title="Dialog.tsx">
    ```typescript theme={null}
    import React from 'react';
    import ReactDOM from 'react-dom';

    interface DialogProps {
        onClick: () => void;
        buttonText: string;
    }

    const Dialog: React.FC<DialogProps> = ({ onClick, buttonText }) => {
        console.log("buttonText",buttonText);

        return (
            <div style={{
                position: 'fixed',
                left: '300px',
                top: '664px',
                width: '800px',
                height: '45px',
            }}>
                <button
                    style={{
                        width: '800px',
                        height: '100%',
                        cursor: 'pointer',
                        backgroundColor: '#f2e6ff',
                        border: '2px solid #9b42f5',
                        borderRadius: '12px',
                        textAlign:'left',
                        paddingLeft:'20px',
                        font:'600 15px sans-serif, Inter'
                    }}
                    onClick={onClick}>
                    {buttonText}
                </button>
            </div>
        );
    };

    export default class DialogHelper {
        private dialogContainer: HTMLDivElement | null = null;

        createDialog(onClick: () => void, buttonText: string) {
            this.dialogContainer = document.createElement('div');
            document.body.appendChild(this.dialogContainer);

            ReactDOM.render(<Dialog onClick={onClick} buttonText={buttonText} />, this.dialogContainer);
        }

        closeDialog() {
            if (this.dialogContainer) {
                ReactDOM.unmountComponentAtNode(this.dialogContainer);
                this.dialogContainer.remove();
                this.dialogContainer = null;
            }
        }
    }
    ```
  </Tab>

  <Tab title="MessageComposerDemo.tsx">
    ```typescript theme={null}
    import React from "react";
    import { CometChat } from "@cometchat/chat-sdk-javascript";
    import { CometChatMessageComposer } from "@cometchat/chat-uikit-react";
    import ShortcutFormatter from "./ShortCutFormatter";

      export function MessageComposerDemo() {
        const [chatUser, setChatUser] = React.useState<CometChat.User>()
        React.useEffect(() => {
            CometChat.getUser("uid").then((user) => {
                setChatUser(user);
            })
        }, [])

        return chatUser ? (
          <div>
            <CometChatMessageComposer
              user={chatUser}
              textFormatters={[new ShortcutFormatter()]}
            />
          </div>
        ) : null;
      }
    ```
  </Tab>
</Tabs>

***

## Configuration

[Configurations](/ui-kit/react/v4/components-overview#configurations) offer the ability to customize the properties of each component within a Composite Component.

### UserMemberWrapper

From the MessageComposer, you can navigate to the [UserMemberWrapper](/ui-kit/react/v4/user-member-wrapper) component as shown in the image.

<Frame>
  <img src="https://mintcdn.com/cometchat-22654f5b-docs-agent-in-group-react-v6/wITpHRGFWGJvJnmU/images/edb6d7e4-user_member_wrapper_overview_web_screens-b909422509fa288a52a46a2712a45763.png?fit=max&auto=format&n=wITpHRGFWGJvJnmU&q=85&s=e7926c0d5b0db697048309ebcc7fbaa8" width="3600" height="2400" data-path="images/edb6d7e4-user_member_wrapper_overview_web_screens-b909422509fa288a52a46a2712a45763.png" />
</Frame>

If you wish to modify the properties of the [UserMemberWrapper](/ui-kit/react/v4/user-member-wrapper) Component, you can use the `UserMemberWrapperConfiguration` object.

<Tabs>
  <Tab title="MessageComposerDemo.tsx">
    ```typescript theme={null}
    import React from "react";
    import { CometChat } from "@cometchat/chat-sdk-javascript";
    import { CometChatMessageComposer, UserMemberWrapperConfiguration, UserPresencePlacement } from "@cometchat/chat-uikit-react";

      export function MessageComposerDemo() {
        const [chatUser, setChatUser] = React.useState<CometChat.User>()
        React.useEffect(() => {
            CometChat.getUser("uid").then((user) => {
                setChatUser(user);
            })
        }, [])

        return chatUser ? (
          <div>
            <CometChatMessageComposer
              user={chatUser}
              userMemberWrapperConfiguration={new UserMemberWrapperConfiguration({
               userPresencePlacement: UserPresencePlacement.right,
               //properties of UserMemberWrapper
              })}
            />
          </div>
        ) : null;
      }
    ```
  </Tab>
</Tabs>

The `UserMemberWrapperConfiguration` indeed provides access to all the [Action](/ui-kit/react/v4/user-member-wrapper#actions), [Filters](/ui-kit/react/v4/user-member-wrapper#filters), [Styles](/ui-kit/react/v4/user-member-wrapper#style), [Functionality](/ui-kit/react/v4/user-member-wrapper#functionality), and [Advanced](/ui-kit/react/v4/user-member-wrapper#advanced) properties of the [UserMemberWrapper](/ui-kit/react/v4/user-member-wrapper) component.

Please note that the properties marked with the [report]() symbol are not accessible within the Configuration Object.

**Example**

<Frame>
  <img src="https://mintcdn.com/cometchat-22654f5b-docs-agent-in-group-react-v6/lFF45O1CcDkVMfu4/images/aabd5d07-user_member_wrapper_configuration_web_screens-728a75d8e4b6f011d7b41704bdd4741c.png?fit=max&auto=format&n=lFF45O1CcDkVMfu4&q=85&s=70b04d3e75a0c5f796627ca2857c26c3" width="3600" height="2400" data-path="images/aabd5d07-user_member_wrapper_configuration_web_screens-728a75d8e4b6f011d7b41704bdd4741c.png" />
</Frame>

In the above example, we are styling a few properties of the [UserMemberWrapper](/ui-kit/react/v4/user-member-wrapper) component using `UserMemberWrapperConfiguration`.

***