@cometchat/chat-uikit-angular 4.0.0-beta.1

package/esm2020/CometChatConversations/cometchat-conversations/cometchat-conversations.component.mjs

@@ -0,0 +1,1400 @@
+import { ChangeDetectionStrategy, Component, Input, } from "@angular/core";
+import { CometChat } from "@cometchat-pro/chat";
+import { SelectionMode, States, TitleAlignment, ConversationUtils, MessageReceiptUtils, CometChatSoundManager, CometChatUIKitUtility, ConversationsStyle, ListStyle, MessageStatus } from "@cometchat/uikit-shared";
+import { fontHelper, localize, CometChatGroupEvents, CometChatUIKitConstants, CometChatUserEvents, CometChatMessageEvents, CometChatConversationEvents, DatePatterns, CometChatCallEvents } from '@cometchat/uikit-resources';
+import '@cometchat/uikit-elements';
+import { AvatarStyle, ListItemStyle, ConfirmDialogStyle, ReceiptStyle, DateStyle, BadgeStyle } from '@cometchat/uikit-elements';
+import { ChatConfigurator } from "../../Shared/Framework/ChatConfigurator";
+import * as i0 from "@angular/core";
+import * as i1 from "../../CometChatTheme.service";
+import * as i2 from "../../CometChatList/cometchat-list.component";
+import * as i3 from "@angular/common";
+/**
+*
+* CometChatConversation is a wrapper component consists of CometChatListBaseComponent and ConversationListComponent.
+*
+* @version 1.0.0
+* @author CometChatTeam
+* @copyright © 2022 CometChat Inc.
+*
+*/
+export class CometChatConversationsComponent {
+    constructor(ngZone, ref, themeService) {
+        this.ngZone = ngZone;
+        this.ref = ref;
+        this.themeService = themeService;
+        this.title = localize("CHATS"); //Title of the component
+        this.searchPlaceHolder = localize("SEARCH"); // placeholder text of search input
+        this.disableUsersPresence = false;
+        this.disableReceipt = true;
+        this.disableTyping = false;
+        this.deliveredIcon = "assets/message-delivered.svg";
+        this.readIcon = "assets/message-read.svg";
+        this.errorIcon = "assets/warning-small.svg";
+        this.datePattern = DatePatterns.DayDateTime;
+        this.onError = (error) => {
+            console.log(error);
+        };
+        this.sentIcon = "assets/message-sent.svg";
+        this.privateGroupIcon = "assets/Private.svg";
+        this.protectedGroupIcon = "assets/Locked.svg";
+        this.customSoundForMessages = "";
+        this.activeConversation = null; //selected conversation
+        this.searchIconURL = "assets/search.svg"; //image URL of the search icon
+        this.hideSearch = true; //switch on/ff search input
+        this.loadingIconURL = "assets/Spinner.svg";
+        this.emptyStateText = localize("NO_CHATS_FOUND");
+        this.errorStateText = localize("SOMETHING_WRONG");
+        this.titleAlignment = TitleAlignment.left;
+        this.hideSeparator = false;
+        this.searchPlaceholder = localize("SEARCH");
+        this.hideError = false;
+        this.selectionMode = SelectionMode.none;
+        this.disableSoundForMessages = false;
+        this.confirmDialogTitle = localize("DELETE_CONVERSATION");
+        this.confirmButtonText = localize("DELETE");
+        this.cancelButtonText = localize("CANCEL");
+        this.confirmDialogMessage = localize("WOULD__YOU_LIKE_TO_DELETE_THIS_CONVERSATION");
+        this.deleteConversationDialogStyle = {
+            confirmButtonBackground: "",
+            cancelButtonBackground: "",
+            confirmButtonTextColor: "",
+            confirmButtonTextFont: "",
+            cancelButtonTextColor: "",
+            cancelButtonTextFont: "",
+            titleFont: "",
+            titleColor: "",
+            messageTextFont: "",
+            messageTextColor: "",
+            background: "",
+            border: "1px solid #f2f2f2",
+            height: "100%",
+            width: "100%"
+        };
+        this.backdropStyle = {
+            height: "100%",
+            width: "100%",
+            background: "rgba(0, 0, 0, 0.5)"
+        };
+        this.badgeStyle = {
+            width: "25px",
+            height: "15px",
+            background: "#5aaeff",
+            textColor: "white",
+            textFont: "400 13px Inter, sans-serif",
+            borderRadius: "16px"
+        };
+        this.dateStyle = {
+            textFont: "400 11px Inter, sans-serif",
+            textColor: "rgba(20, 20, 20, 0.58)",
+        };
+        this.conversationsStyle = {
+            width: "",
+            height: "",
+            border: "",
+            borderRadius: "",
+        };
+        this.listItemStyle = {
+            height: "100%",
+            width: "100%",
+            background: "",
+            activeBackground: "",
+            borderRadius: "grey",
+            titleFont: "",
+            titleColor: "",
+            border: "",
+            separatorColor: "rgb(232, 232, 232)"
+        };
+        this.statusIndicatorStyle = {
+            height: "10px",
+            width: "10px",
+            borderRadius: "16px"
+        };
+        this.typingIndicatorText = localize("IS_TYPING");
+        this.threadIndicatorText = localize("IN_A_THREAD");
+        this.avatarStyle = {};
+        this.receiptStyle = {};
+        this.iconStyle = {
+            iconTint: "lightgrey",
+            height: "20px",
+            width: "20px"
+        };
+        this.listStyle = new ListStyle({});
+        this.menustyle = {
+            width: "",
+            height: "",
+            border: "none",
+            borderRadius: "8px",
+            background: "transparent",
+            textFont: "",
+            textColor: "black",
+            iconTint: "grey",
+            iconBackground: "transparent",
+            iconBorder: "none",
+            iconBorderRadius: "0",
+            submenuWidth: "70px",
+            submenuHeight: "20px",
+            submenuBorder: "1px solid #e8e8e8",
+            submenuBorderRadius: "8px",
+            submenuBackground: "white",
+        };
+        this.typingListenerId = "conversation__LISTENER" + new Date().getTime();
+        this.callListenerId = "call_" + new Date().getTime();
+        this.selectionmodeEnum = SelectionMode;
+        this.isDialogOpen = false;
+        // public loggedInUser!: CometChat.User | null;
+        this.isEmpty = false;
+        this.isLoading = true;
+        this.state = States.loading;
+        this.statusColor = {
+            online: "",
+            private: "",
+            password: "#F7A500",
+            public: ""
+        };
+        this.limit = 30;
+        this.isError = false;
+        this.conversationList = [];
+        this.scrolledToBottom = false;
+        this.checkItemChange = false;
+        this.showConfirmDialog = false;
+        this.conversationToBeDeleted = null;
+        this.conversationListenerId = "chatlist_" + new Date().getTime();
+        this.userListenerId = "chatlist_user_" + new Date().getTime();
+        this.groupListenerId = "chatlist_group_" + new Date().getTime();
+        this.groupToUpdate = {};
+        this.enablePolls = false;
+        this.enableStickers = false;
+        this.enableWhiteboard = false;
+        this.enableDocument = false;
+        this.threadIconURL = "assets/thread-arrow.svg";
+        this.confirmDialogStyle = {
+            height: "100%",
+            width: "100%",
+            borderRadius: "8px"
+        };
+        this.modalStyle = {
+            height: "230px",
+            width: "270px"
+        };
+        /**
+          * Properties for internal use
+          */
+        this.localize = localize;
+        /**
+        * Properties for internal use
+        */
+        /**
+         * passing this callback to menuList component on delete click
+         * @param  {CometChat.Conversation} conversation
+         */
+        this.deleteConversationOnClick = () => {
+            this.showConfirmationDialog(this.conversationToBeDeleted);
+        };
+        // callback for confirmDialogComponent
+        this.onConfirmClick = () => {
+            this.deleteSelectedConversation();
+        };
+        this.setStatusIndicatorStyle = (conversation) => {
+            if (conversation.getConversationType() == CometChatUIKitConstants.MessageReceiverType.group) {
+                return {
+                    height: "12px",
+                    width: "12px",
+                    borderRadius: "16px"
+                };
+            }
+            else {
+                return this.statusIndicatorStyle;
+            }
+        };
+        this.setSubtitle = (conversationObject) => {
+            if (this.typingIndicator) {
+                const isTyping = conversationObject?.conversationWith?.guid == this.typingIndicator.getReceiverId();
+                if (isTyping) {
+                    return `${this.typingIndicator.getSender().getName()} ${this.typingIndicatorText}`;
+                }
+                else if (conversationObject?.conversationWith?.uid == this.typingIndicator?.getSender().getUid() && this.typingIndicator.getReceiverType() !== CometChatUIKitConstants.MessageReceiverType.group) {
+                    return this.typingIndicatorText;
+                }
+            }
+            let subtitle = ChatConfigurator.getDataSource().getLastConversationMessage(conversationObject, this.loggedInUser);
+            let icon = conversationObject?.getLastMessage()?.getType() == CometChatUIKitConstants.MessageTypes.audio ? "📞 " : "📹 ";
+            return conversationObject?.getLastMessage()?.getCategory() == CometChatUIKitConstants.MessageCategory.call ? icon + subtitle : subtitle;
+        };
+        // callback for confirmDialogComponent
+        this.onCancelClick = () => {
+            this.isDialogOpen = false;
+            this.conversationToBeDeleted = null;
+            this.ref.detectChanges();
+        };
+        this.getMessageReceipt = (conversation) => {
+            let receipt = MessageReceiptUtils.getReceiptStatus(conversation.getLastMessage());
+            return receipt;
+        };
+        this.optionsStyle = {
+            background: "transparent",
+            border: "none"
+        };
+        this.isActive = true;
+        this.contactsNotFound = false;
+        /**
+         * Fetches Conversations Details with all the users
+         */
+        this.getConversation = () => {
+            if ((this.conversationsRequestBuilder && !this.conversationsRequestBuilder?.pagination) || (this.conversationsRequestBuilder.pagination.current_page == 0 || this.conversationsRequestBuilder.pagination.current_page != this.conversationsRequestBuilder.pagination.total_pages)) {
+                this.state = States.loading;
+                try {
+                    CometChat.getLoggedinUser()
+                        .then((user) => {
+                        this.loggedInUser = user;
+                        this.fetchNextConversation()
+                            .then((conversationList) => {
+                            conversationList.forEach((conversation) => {
+                                if (this.activeConversation && this.activeConversation !== null &&
+                                    this.activeConversation.getConversationType() === conversation.getConversationType()) {
+                                    if (this.activeConversation.getConversationId() == conversation.getConversationId()) {
+                                        conversation.setUnreadMessageCount(0);
+                                    }
+                                }
+                            });
+                            this.conversationList = [
+                                ...this.conversationList,
+                                ...conversationList,
+                            ];
+                            if ((conversationList.length <= 0 && this.conversationList?.length <= 0) || (conversationList.length === 0 && this.conversationList?.length <= 0)) {
+                                this.ngZone.run(() => {
+                                    if (this.state != States.empty) {
+                                        this.state = States.empty;
+                                        this.ref.detectChanges();
+                                    }
+                                    this.ref.detach(); // Detach the change detector
+                                });
+                            }
+                            else {
+                                this.ngZone.run(() => {
+                                    if (this.state != States.loaded) {
+                                        this.state = States.loaded;
+                                        this.ref.detectChanges();
+                                    }
+                                    this.ref.detach(); // Detach the change detector
+                                });
+                            }
+                        })
+                            .catch((error) => {
+                            this.state = States.error;
+                            this.ref.detectChanges();
+                        });
+                    })
+                        .catch((error) => {
+                        this.state = States.error;
+                        this.ref.detectChanges();
+                    });
+                }
+                catch (error) {
+                    if (this.onError) {
+                        this.onError(error);
+                    }
+                }
+            }
+            else {
+                this.state = States.loaded;
+            }
+        };
+        /**
+         * Updates the conversation list's last message , badgeCount , user presence based on activities propagated by listeners
+         */
+        this.conversationUpdated = (key, item = null, message, options = null) => {
+            try {
+                switch (key) {
+                    case CometChatUIKitConstants.userStatusType.online:
+                    case CometChatUIKitConstants.userStatusType.online: {
+                        this.updateUser(item);
+                        break;
+                    }
+                    case CometChatUIKitConstants.messages.MESSAGE_READ: {
+                        this.updateConversation(message, false);
+                        break;
+                    }
+                    case CometChatUIKitConstants.messages.MESSAGE_DELIVERED: {
+                        this.updateConversation(message, false);
+                        break;
+                    }
+                    case CometChatUIKitConstants.messages.TEXT_MESSAGE_RECEIVED:
+                    case CometChatUIKitConstants.messages.MEDIA_MESSAGE_RECEIVED:
+                    case CometChatUIKitConstants.messages.CUSTOM_MESSAGE_RECEIVED:
+                        if (!this.disableReceipt) {
+                            this.markMessageAsDelivered(message);
+                        }
+                        this.updateConversation(message);
+                        break;
+                    case CometChatUIKitConstants.groupMemberAction.ADDED:
+                    case CometChatUIKitConstants.groupMemberAction.BANNED:
+                    case CometChatUIKitConstants.groupMemberAction.JOINED:
+                    case CometChatUIKitConstants.groupMemberAction.KICKED:
+                    case CometChatUIKitConstants.groupMemberAction.LEFT:
+                    case CometChatUIKitConstants.groupMemberAction.UNBANNED:
+                    case CometChatUIKitConstants.groupMemberAction.SCOPE_CHANGE:
+                        this.updateConversation(message);
+                        break;
+                    case CometChatUIKitConstants.messages.MESSAGE_EDITED:
+                    case CometChatUIKitConstants.messages.MESSAGE_DELETED:
+                        this.conversationEditedDeleted(message);
+                        break;
+                }
+            }
+            catch (error) {
+                if (this.onError) {
+                    this.onError(error);
+                }
+            }
+        };
+        /**
+         * @param  {CometChat.BaseMessage} message
+         */
+        this.markMessageAsDelivered = (message) => {
+            //if chat window is not open, mark message as delivered
+            if (this.activeConversation?.getConversationType() == CometChatUIKitConstants.MessageReceiverType.user) {
+                if ((!this.activeConversation || this.activeConversation?.getConversationWith()?.getUid() !== message?.getSender()?.getUid())
+                    && !message.hasOwnProperty("deliveredAt")) {
+                    CometChat.markAsDelivered(message);
+                }
+            }
+            else {
+                if ((!this.activeConversation || this.activeConversation?.getConversationWith()?.getGuid() !== message?.getReceiverId())
+                    && !message.hasOwnProperty("deliveredAt")) {
+                    CometChat.markAsDelivered(message);
+                }
+            }
+        };
+        /**
+         * @param  {CometChat.BaseMessage} readMessage
+         */
+        this.getUinx = () => {
+            return String(Math.round(+new Date() / 1000));
+        };
+        /**
+         * showing dialog for confirm and cancel
+         * @param  {CometChat.Conversation|{}} conversation
+         */
+        this.showConfirmationDialog = (conversation) => {
+            this.isDialogOpen = true;
+            this.conversationToBeDeleted = conversation;
+            this.ref.detectChanges();
+        };
+        this.styles = {
+            wrapperStyle: () => {
+                return {
+                    height: this.conversationsStyle.height,
+                    width: this.conversationsStyle.width,
+                    border: this.conversationsStyle.border || `1px solid ${this.themeService.theme.palette.getAccent400()}`,
+                    borderRadius: this.conversationsStyle.borderRadius,
+                    background: this.conversationsStyle.background || this.themeService.theme.palette.getBackground(),
+                };
+            },
+        };
+        this.subtitleStyle = (conversation) => {
+            if (this.typingIndicator && (this.typingIndicator.getReceiverType() == CometChatUIKitConstants.MessageReceiverType.user && this.typingIndicator.getSender().getUid() == conversation.conversationWith?.uid || this.typingIndicator.getReceiverId() == conversation.conversationWith?.guid)) {
+                return {
+                    font: this.conversationsStyle.typingIndictorTextColor,
+                    color: this.conversationsStyle.typingIndictorTextColor
+                };
+            }
+            return {
+                font: this.conversationsStyle.lastMessageTextFont,
+                color: this.conversationsStyle.lastMessageTextColor
+            };
+        };
+        this.itemThreadIndicatorStyle = () => {
+            return {
+                textFont: this.conversationsStyle.threadIndicatorTextFont || fontHelper(this.themeService.theme.typography.caption2),
+                textColor: this.conversationsStyle.threadIndicatorTextColor || this.themeService.theme.palette.getAccent400(),
+            };
+        };
+    }
+    /**
+   * @param  {CometChat.Conversation} conversation
+   */
+    checkStatusType(conversation) {
+        let user = conversation.getConversationWith();
+        if (conversation.getConversationType() == CometChatUIKitConstants.MessageReceiverType.user && !this.disableUsersPresence) {
+            return this.statusColor[user.getStatus()];
+        }
+        else {
+            return this.statusColor[conversation.getConversationType()];
+        }
+    }
+    getExtensionData(messageObject) {
+        let messageText;
+        //xss extensions data
+        const xssData = CometChatUIKitUtility.checkMessageForExtensionsData(messageObject, "xss-filter");
+        if (xssData && CometChatUIKitUtility.checkHasOwnProperty(xssData, "sanitized_text") && CometChatUIKitUtility.checkHasOwnProperty(xssData, "hasXSS") && xssData.hasXSS === "yes") {
+            messageText = xssData.sanitized_text;
+        }
+        //datamasking extensions data
+        const maskedData = CometChatUIKitUtility.checkMessageForExtensionsData(messageObject, "data-masking");
+        if (maskedData && CometChatUIKitUtility.checkHasOwnProperty(maskedData, "data") && CometChatUIKitUtility.checkHasOwnProperty(maskedData.data, "sensitive_data") && CometChatUIKitUtility.checkHasOwnProperty(maskedData.data, "message_masked") && maskedData.data.sensitive_data === "yes") {
+            messageText = maskedData.data.message_masked;
+        }
+        //profanity extensions data
+        const profaneData = CometChatUIKitUtility.checkMessageForExtensionsData(messageObject, "profanity-filter");
+        if (profaneData && CometChatUIKitUtility.checkHasOwnProperty(profaneData, "profanity") && CometChatUIKitUtility.checkHasOwnProperty(profaneData, "message_clean") && profaneData.profanity === "yes") {
+            messageText = profaneData.message_clean;
+        }
+        return messageText || messageObject.text;
+    }
+    checkGroupType(conversation) {
+        let image = "";
+        if (conversation.getConversationType() == CometChatUIKitConstants.MessageReceiverType.group) {
+            switch (conversation.getConversationType()) {
+                case CometChatUIKitConstants.GroupTypes.password:
+                    image = this.protectedGroupIcon;
+                    break;
+                case CometChatUIKitConstants.GroupTypes.private:
+                    image = this.privateGroupIcon;
+                    break;
+                default:
+                    image = "";
+                    break;
+            }
+        }
+        return image;
+    }
+    getDate() {
+        return this.datePattern || DatePatterns.DayDateTime;
+    }
+    ngOnInit() {
+        this.setThemeStyle();
+        this.subscribeToEvents();
+        if (this.conversationsRequestBuilder) {
+            this.conversationsRequestBuilder?.build();
+        }
+        else {
+            this.conversationsRequestBuilder = new CometChat.ConversationsRequestBuilder().setLimit(this.limit).build();
+        }
+        this.state = States.loading;
+        this.setConversationOptions();
+        try {
+            this.getConversation();
+            this.attachListeners(this.conversationUpdated);
+        }
+        catch (error) {
+            if (this.onError) {
+                this.onError(error);
+            }
+        }
+        this.ref.detectChanges();
+    }
+    updateConversationObject(conversation) {
+        let index = this.conversationList.findIndex((element) => element.getConversationId() == conversation.getConversationId());
+        this.conversationList.splice(index, 1, conversation);
+        this.ref.detectChanges();
+    }
+    subscribeToEvents() {
+        this.ccGroupMemberScopeChanged = CometChatGroupEvents.ccGroupMemberScopeChanged.subscribe((item) => {
+            let conversation = this.getConversationFromGroup(item.group);
+            if (conversation) {
+                conversation.setLastMessage(item.message);
+                this.updateConversationObject(conversation);
+            }
+        });
+        this.ccGroupMemberAdded = CometChatGroupEvents.ccGroupMemberAdded.subscribe((item) => {
+            let group = item.userAddedIn;
+            let actionMessage = item.messages;
+            let conversation = this.getConversationFromGroup(item.userAddedIn);
+            conversation?.setConversationWith(group);
+            conversation?.setLastMessage(actionMessage[actionMessage?.length - 1]);
+            this.updateConversationObject(conversation);
+        });
+        this.ccGroupMemberKicked = CometChatGroupEvents.ccGroupMemberKicked.subscribe((item) => {
+            let conversation = this.getConversationFromGroup(item.kickedFrom);
+            if (conversation) {
+                conversation.setLastMessage(item.message);
+                this.updateConversationObject(conversation);
+            }
+        });
+        this.ccGroupMemberBanned = CometChatGroupEvents.ccGroupMemberBanned.subscribe((item) => {
+            let conversation = this.getConversationFromGroup(item.kickedFrom);
+            if (conversation) {
+                conversation.setLastMessage(item.message);
+                this.updateConversationObject(conversation);
+            }
+        });
+        this.ccGroupDeleted = CometChatGroupEvents.ccGroupDeleted.subscribe((item) => {
+            let conversation = this.getConversationFromGroup(item);
+            if (conversation) {
+                this.removeConversation(conversation);
+            }
+        });
+        this.ccGroupLeft = CometChatGroupEvents.ccGroupLeft.subscribe((item) => {
+            this.updateConversation(item.message);
+            this.ref.detectChanges();
+        });
+        this.ccUserBlocked = CometChatUserEvents.ccUserBlocked.subscribe((item) => {
+            let conversation = this.getConversationFromUser(item);
+            if (conversation) {
+                this.removeConversation(conversation);
+            }
+        });
+        this.ccMessageEdit = CometChatMessageEvents.ccMessageEdited.subscribe((object) => {
+            let message = object.message;
+            if (object.status == MessageStatus.success) {
+                this.updateEditedMessage(message);
+            }
+        });
+        this.ccMessageSent = CometChatMessageEvents.ccMessageSent.subscribe((obj) => {
+            let message = obj.message;
+            if (obj.status == MessageStatus.success) {
+                this.updateConversation(message);
+            }
+        });
+        this.ccMessageDelete = CometChatMessageEvents.ccMessageDeleted.subscribe((messageObject) => {
+            this.updateConversation(messageObject);
+            this.ref.detectChanges();
+        });
+        this.ccMessageRead = CometChatMessageEvents.ccMessageRead.subscribe((messageObject) => {
+            CometChat.CometChatHelper.getConversationFromMessage(messageObject).then((conversation) => {
+                if (conversation && this.activeConversation && conversation?.getConversationId() == this.activeConversation?.getConversationId()) {
+                    this.updateEditedMessage(messageObject);
+                    this.resetUnreadCount();
+                }
+            });
+        });
+        this.ccCallEnded = CometChatCallEvents.ccCallEnded.subscribe((call) => {
+            if (call) {
+                this.updateConversation(call);
+            }
+        });
+        this.ccCallRejected = CometChatCallEvents.ccCallRejected.subscribe((call) => {
+            this.updateConversation(call);
+        });
+        this.ccOutgoingCall = CometChatCallEvents.ccOutgoingCall.subscribe((call) => {
+            this.updateConversation(call);
+        });
+        this.ccCallAccepted = CometChatCallEvents.ccCallAccepted.subscribe((call) => {
+            this.updateConversation(call);
+        });
+    }
+    unsubscribeToEvents() {
+        this.ccGroupMemberAdded?.unsubscribe();
+        this.ccGroupMemberKicked?.unsubscribe();
+        this.ccGroupMemberBanned?.unsubscribe();
+        this.ccMessageEdit?.unsubscribe();
+        this.ccMessageSent?.unsubscribe();
+        this.ccMessageEdited?.unsubscribe();
+        this.ccMessageDelete?.unsubscribe();
+        this.ccGroupDeleted?.unsubscribe();
+        this.ccGroupLeft?.unsubscribe();
+        this.ccUserBlocked?.unsubscribe();
+        this.ccMessageRead?.unsubscribe();
+    }
+    getConversationFromUser(user) {
+        let index = this.conversationList.findIndex((element) => element.getConversationType() == CometChatUIKitConstants.MessageReceiverType.user && element.getConversationWith().getUid() == user.getUid());
+        if (index >= 0) {
+            return this.conversationList[index];
+        }
+        return null;
+    }
+    getConversationFromGroup(group) {
+        let index = this.conversationList.findIndex((element) => element.getConversationType() == CometChatUIKitConstants.MessageReceiverType.group && element.getConversationWith().getGuid() == group.getGuid());
+        if (index >= 0) {
+            return this.conversationList[index];
+        }
+        return null;
+    }
+    ngOnChanges(change) {
+        try {
+            if (change["activeConversation"]) {
+                this.resetUnreadCount();
+            }
+            /**
+             * When user sends message conversationList is updated with latest message
+             */
+        }
+        catch (error) {
+            if (this.onError) {
+                this.onError(error);
+            }
+        }
+    }
+    ngOnDestroy() {
+        try {
+            this.removeListeners();
+            this.unsubscribeToEvents();
+        }
+        catch (error) {
+            if (this.onError) {
+                this.onError(error);
+            }
+        }
+        this.ref.detectChanges();
+    }
+    // getting default conversation option and adding callback in it
+    setConversationOptions() {
+        if (this.options) {
+            return;
+        }
+        this.conversationOptions = ConversationUtils.getDefaultOptions();
+        this.conversationOptions.forEach((element) => {
+            if (!element.onClick && element.id == CometChatUIKitConstants.ConversationOptions.delete) {
+                element.onClick = this.deleteConversationOnClick;
+            }
+        });
+        return;
+    }
+    // reset unread count
+    onClick(conversation) {
+        if (this.onItemClick) {
+            this.onItemClick(conversation);
+        }
+    }
+    // set unread count
+    resetUnreadCount() {
+        if (this.activeConversation) {
+            const conversationlist = [...this.conversationList];
+            //Gets the index of user which comes offline/online
+            const conversationKey = conversationlist.findIndex((conversationObj) => conversationObj?.getConversationId() === this.activeConversation?.getConversationId());
+            if (conversationKey > -1) {
+                let conversationObj = conversationlist[conversationKey];
+                let newConversationObj = conversationObj;
+                newConversationObj.setUnreadMessageCount(0);
+                newConversationObj.getLastMessage()?.setMuid(this.getUinx());
+                conversationlist.splice(conversationKey, 1, newConversationObj);
+                this.conversationList = [...conversationlist];
+                this.ref.detectChanges();
+            }
+        }
+    }
+    // sets property from theme to style object
+    setThemeStyle() {
+        this.setAvatarStyle();
+        this.setBadgeStyle();
+        this.setConfirmDialogStyle();
+        this.setConversationsStyle();
+        this.setListItemStyle();
+        this.setDateStyle();
+        this.setStatusStyle();
+        this.setReceiptStyle();
+        this.statusColor.private = this.conversationsStyle?.privateGroupIconBackground;
+        this.statusColor.online = this.conversationsStyle?.onlineStatusColor;
+        this.statusColor.password = this.conversationsStyle?.passwordGroupIconBackground;
+        this.listStyle = {
+            titleTextFont: this.conversationsStyle.titleTextFont,
+            titleTextColor: this.conversationsStyle.titleTextColor,
+            emptyStateTextFont: this.conversationsStyle.emptyStateTextFont,
+            emptyStateTextColor: this.conversationsStyle.emptyStateTextColor,
+            errorStateTextFont: this.conversationsStyle.errorStateTextFont,
+            errorStateTextColor: this.conversationsStyle.errorStateTextColor,
+            loadingIconTint: this.conversationsStyle.loadingIconTint,
+            separatorColor: this.conversationsStyle.separatorColor,
+        };
+        this.iconStyle.iconTint = this.themeService.theme.palette.getAccent400();
+    }
+    setListItemStyle() {
+        let defaultStyle = new ListItemStyle({
+            height: "100%",
+            width: "100%",
+            background: this.themeService.theme.palette.getBackground(),
+            activeBackground: this.themeService.theme.palette.getAccent50(),
+            borderRadius: "0",
+            titleFont: fontHelper(this.themeService.theme.typography.title2),
+            titleColor: this.themeService.theme.palette.getAccent(),
+            border: "none",
+            separatorColor: this.themeService.theme.palette.getAccent200(),
+            hoverBackground: this.themeService.theme.palette.getAccent50()
+        });
+        this.listItemStyle = { ...defaultStyle, ...this.listItemStyle };
+    }
+    setAvatarStyle() {
+        let defaultStyle = new AvatarStyle({
+            borderRadius: "24px",
+            width: "36px",
+            height: "36px",
+            border: `1px solid ${this.themeService.theme.palette.getAccent200()}`,
+            backgroundColor: this.themeService.theme.palette.getAccent700(),
+            nameTextColor: this.themeService.theme.palette.getAccent900(),
+            backgroundSize: "cover",
+            nameTextFont: fontHelper(this.themeService.theme.typography.subtitle1),
+            outerViewBorder: "",
+            outerViewBorderSpacing: "",
+        });
+        this.avatarStyle = { ...defaultStyle, ...this.avatarStyle };
+    }
+    setStatusStyle() {
+        let defaultStyle = {
+            height: "12px",
+            width: "12px",
+            border: "none",
+            borderRadius: "24px",
+        };
+        this.statusIndicatorStyle = { ...defaultStyle, ...this.statusIndicatorStyle };
+    }
+    setConversationsStyle() {
+        let defaultStyle = new ConversationsStyle({
+            lastMessageTextFont: fontHelper(this.themeService.theme.typography.subtitle2),
+            lastMessageTextColor: this.themeService.theme.palette.getAccent600(),
+            background: this.themeService.theme.palette.getBackground(),
+            border: `1px solid ${this.themeService.theme.palette.getAccent50()}`,
+            titleTextFont: fontHelper(this.themeService.theme.typography.title1),
+            titleTextColor: this.themeService.theme.palette.getAccent(),
+            emptyStateTextFont: fontHelper(this.themeService.theme.typography.title1),
+            emptyStateTextColor: this.themeService.theme.palette.getAccent600(),
+            errorStateTextFont: fontHelper(this.themeService.theme.typography.title1),
+            errorStateTextColor: this.themeService.theme.palette.getAccent600(),
+            loadingIconTint: this.themeService.theme.palette.getAccent600(),
+            onlineStatusColor: this.themeService.theme.palette.getSuccess(),
+            separatorColor: this.themeService.theme.palette.getAccent400(),
+            privateGroupIconBackground: this.themeService.theme.palette.getSuccess(),
+            passwordGroupIconBackground: "RGB(247, 165, 0)",
+            typingIndictorTextColor: this.themeService.theme.palette.getPrimary(),
+            typingIndictorTextFont: fontHelper(this.themeService.theme.typography.subtitle2),
+            threadIndicatorTextFont: fontHelper(this.themeService.theme.typography.caption2),
+            threadIndicatorTextColor: this.themeService.theme.palette.getAccent600(),
+        });
+        this.conversationsStyle = { ...defaultStyle, ...this.conversationsStyle };
+    }
+    setDateStyle() {
+        let defaultStyle = new DateStyle({
+            textFont: fontHelper(this.themeService.theme.typography.caption2),
+            textColor: this.themeService.theme.palette.getAccent600(),
+            background: "transparent"
+        });
+        this.dateStyle = { ...defaultStyle, ...this.dateStyle };
+    }
+    setReceiptStyle() {
+        let defaultStyle = new ReceiptStyle({
+            waitIconTint: this.themeService.theme.palette.getAccent700(),
+            sentIconTint: this.themeService.theme.palette.getAccent600(),
+            deliveredIconTint: this.themeService.theme.palette.getAccent600(),
+            readIconTint: this.themeService.theme.palette.getPrimary(),
+            errorIconTint: this.themeService.theme.palette.getError(),
+        });
+        this.receiptStyle = { ...defaultStyle, ...this.receiptStyle };
+    }
+    setBadgeStyle() {
+        let defaultStyle = new BadgeStyle({
+            textFont: fontHelper(this.themeService.theme.typography.subtitle2),
+            textColor: this.themeService.theme.palette.getAccent("dark"),
+            background: this.themeService.theme.palette.getPrimary(),
+            borderRadius: "16px",
+            width: "24px",
+        });
+        this.badgeStyle = { ...defaultStyle, ...this.badgeStyle };
+    }
+    setConfirmDialogStyle() {
+        let defaultStyle = new ConfirmDialogStyle({
+            confirmButtonBackground: this.themeService.theme.palette.getError(),
+            cancelButtonBackground: this.themeService.theme.palette.getSecondary(),
+            confirmButtonTextColor: this.themeService.theme.palette.getAccent900("light"),
+            confirmButtonTextFont: fontHelper(this.themeService.theme.typography.text2),
+            cancelButtonTextColor: this.themeService.theme.palette.getAccent900("dark"),
+            cancelButtonTextFont: fontHelper(this.themeService.theme.typography.text2),
+            titleFont: fontHelper(this.themeService.theme.typography.title1),
+            titleColor: this.themeService.theme.palette.getAccent(),
+            messageTextFont: fontHelper(this.themeService.theme.typography.subtitle2),
+            messageTextColor: this.themeService.theme.palette.getAccent600(),
+            background: this.themeService.theme.palette.getBackground(),
+            height: "100%",
+            width: "350px",
+        });
+        this.deleteConversationDialogStyle = { ...defaultStyle, ...this.deleteConversationDialogStyle };
+    }
+    // checking if user has his own configuration else will use default configuration
+    /**
+     * @param  {Object={}} config
+     * @param  {Object} defaultConfig?
+     * @returns defaultConfig
+     */
+    // calling subtitle callback from configurations
+    /**
+     * @param  {CometChat.Conversation} conversation
+     */
+    /**
+     * Fetches the coversation based on the conversationRequest config
+     */
+    fetchNextConversation() {
+        try {
+            return this.conversationsRequestBuilder?.fetchNext();
+        }
+        catch (error) {
+            if (this.onError) {
+                this.onError(error);
+            }
+        }
+    }
+    updateEditedMessage(message) {
+        let index = this.conversationList.findIndex((conversationObj) => conversationObj.getLastMessage() && conversationObj.getLastMessage().getId() == message?.getId());
+        if (index >= 0) {
+            this.conversationEditedDeleted(message);
+        }
+    }
+    /**
+     * attaches Listeners for user activity , group activities and calling
+     * @param callback
+     */
+    /**
+     * @param  {Function} callback
+     */
+    attachListeners(callback) {
+        try {
+            if (!this.disableUsersPresence) {
+                CometChat.addUserListener(this.userListenerId, new CometChat.UserListener({
+                    onUserOnline: (onlineUser) => {
+                        /* when someuser/friend comes online, user will be received here */
+                        callback(CometChatUIKitConstants.userStatusType.online, onlineUser);
+                    },
+                    onUserOffline: (offlineUser) => {
+                        /* when someuser/friend went offline, user will be received here */
+                        callback(CometChatUIKitConstants.userStatusType.offline, offlineUser);
+                    },
+                }));
+            }
+            CometChat.addGroupListener(this.groupListenerId, new CometChat.GroupListener({
+                onGroupMemberScopeChanged: (message, changedUser, newScope, oldScope, changedGroup) => {
+                    this.updateConversation(message);
+                },
+                onGroupMemberKicked: (message, kickedUser, kickedBy, kickedFrom) => {
+                    this.updateConversation(message);
+                },
+                onGroupMemberBanned: (message, bannedUser, bannedBy, bannedFrom) => {
+                    this.updateConversation(message);
+                },
+                onGroupMemberUnbanned: (message, unbannedUser, unbannedBy, unbannedFrom) => {
+                    // this.updateConversation(message)
+                },
+                onMemberAddedToGroup: (message, userAdded, userAddedBy, userAddedIn) => {
+                    this.updateConversation(message);
+                },
+                onGroupMemberLeft: (message, leavingUser, group) => {
+                    this.updateConversation(message);
+                },
+                onGroupMemberJoined: (message, joinedUser, joinedGroup) => {
+                    this.updateConversation(message);
+                },
+            }));
+            CometChat.addMessageListener(this.conversationListenerId, new CometChat.MessageListener({
+                onTextMessageReceived: (textMessage) => {
+                    callback(CometChatUIKitConstants.messages.TEXT_MESSAGE_RECEIVED, null, textMessage);
+                },
+                onMediaMessageReceived: (mediaMessage) => {
+                    callback(CometChatUIKitConstants.messages.MEDIA_MESSAGE_RECEIVED, null, mediaMessage);
+                },
+                onCustomMessageReceived: (customMessage) => {
+                    callback(CometChatUIKitConstants.messages.CUSTOM_MESSAGE_RECEIVED, null, customMessage);
+                },
+                onMessagesRead: (messageReceipt) => {
+                    if (!this.disableReceipt) {
+                        this.markAsRead(messageReceipt);
+                    }
+                },
+                onMessageDeleted: (deletedMessage) => {
+                    callback(CometChatUIKitConstants.messages.MESSAGE_DELETED, null, deletedMessage);
+                },
+                onMessageEdited: (editedMessage) => {
+                    callback(CometChatUIKitConstants.messages.MESSAGE_EDITED, null, editedMessage);
+                },
+                onMessagesDelivered: (messageReceipt) => {
+                    if (!this.disableReceipt) {
+                        this.updateDeliveredMessage(messageReceipt);
+                    }
+                },
+                onTypingStarted: (typingIndicator) => {
+                    if (!this.disableTyping) {
+                        this.typingIndicator = typingIndicator;
+                        this.ref.detectChanges();
+                    }
+                },
+                onTypingEnded: (typingIndicator) => {
+                    this.typingIndicator = null;
+                    this.ref.detectChanges();
+                }
+            }));
+            CometChat.addCallListener(this.callListenerId, new CometChat.CallListener({
+                onIncomingCallReceived: (call) => {
+                    this.updateConversation(call);
+                },
+                onIncomingCallCancelled: (call) => {
+                    this.updateConversation(call);
+                },
+                onOutgoingCallRejected: (call) => {
+                    this.updateConversation(call);
+                },
+                onOutgoingCallAccepted: (call) => {
+                    this.updateConversation(call);
+                },
+            }));
+        }
+        catch (error) {
+            if (this.onError) {
+                this.onError(error);
+            }
+        }
+    }
+    /**
+     * Removes all listeners
+     */
+    removeListeners() {
+        try {
+            CometChat.removeMessageListener(this.conversationListenerId);
+            CometChat.removeUserListener(this.userListenerId);
+            CometChat.removeGroupListener(this.groupListenerId);
+        }
+        catch (error) {
+            if (this.onError) {
+                this.onError(error);
+            }
+        }
+    }
+    isReceiptDisable(conversation) {
+        let item = conversation.getConversationWith();
+        let message = conversation.getLastMessage();
+        if (!this.disableReceipt && message && message?.getCategory() != CometChatUIKitConstants.MessageCategory.action && message?.getCategory() != CometChatUIKitConstants.MessageCategory.call
+            && (!this.typingIndicator || (item?.uid != this.typingIndicator.getReceiverId() && item?.guid != this.typingIndicator.getReceiverId()))
+            && message.getSender()?.getUid() == this.loggedInUser?.getUid()) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    markAsRead(readMessage) {
+        let conversationlist = [...this.conversationList];
+        const conversationKey = conversationlist.findIndex((conversationObj) => conversationObj.getLastMessage().getReceiverId() == readMessage.getSender().getUid());
+        if (conversationKey > -1) {
+            let newConversationObject;
+            if (!conversationlist[conversationKey].getLastMessage().getReadAt()) {
+                newConversationObject = conversationlist[conversationKey];
+                newConversationObject.getLastMessage().setReadAt(readMessage.getReadAt());
+                newConversationObject.getLastMessage().setMuid(this.getUinx());
+                conversationlist.splice(conversationKey, 1, newConversationObject);
+                this.conversationList = [...conversationlist];
+            }
+        }
+    }
+    /**
+     * Updates Detail when user comes online/offline
+     * @param
+     */
+    /**
+     * @param  {CometChat.User|CometChat.Group|null} user
+     */
+    updateUser(user) {
+        try {
+            //when user updates
+            const conversationlist = [...this.conversationList];
+            //Gets the index of user which comes offline/online
+            const conversationKey = conversationlist.findIndex((conversationObj) => conversationObj.getConversationType() === CometChatUIKitConstants.MessageReceiverType.user &&
+                conversationObj.getConversationWith().getUid() === user.getUid());
+            if (conversationKey > -1) {
+                let conversationObj = conversationlist[conversationKey];
+                let conversationWithObj = conversationObj.getConversationWith();
+                conversationWithObj.setStatus(user.getStatus());
+                let newConversationObj = conversationObj;
+                newConversationObj.setConversationWith(conversationWithObj);
+                newConversationObj.getLastMessage().setMuid(this.getUinx());
+                conversationlist.splice(conversationKey, 1, newConversationObj);
+                this.conversationList = conversationlist;
+                this.ref.detectChanges();
+            }
+        }
+        catch (error) {
+            if (this.onError) {
+                this.onError(error);
+            }
+            this.ref.detectChanges();
+        }
+    }
+    /**
+     *
+     * Gets the last message
+     * @param conversation
+    /**
+     * @param  {CometChat.BaseMessage} message
+     * @param  {CometChat.Conversation|{}} conversation
+     */
+    makeLastMessage(message, conversation = {}) {
+        const newMessage = message;
+        return newMessage;
+    }
+    /**
+     *
+     * Updates Conversations as Text/Custom Messages are received
+     * @param
+     *
+     */
+    /**
+     * @param  {CometChat.BaseMessage} message
+     * @param  {boolean} notification
+     */
+    updateConversation(message, notification = true) {
+        try {
+            this.makeConversation(message)
+                .then((response) => {
+                const conversationKey = response.conversationKey;
+                const conversationObj = response.conversationObj;
+                const conversationList = response.conversationList;
+                if (conversationKey > -1) {
+                    // if sender is not logged in user then  increment count
+                    let unreadMessageCount = this.loggedInUser?.getUid() != message.getSender().getUid() || this.loggedInUser?.getUid() == message.getReceiverId() ? this.makeUnreadMessageCount(conversationObj) : this.makeUnreadMessageCount(conversationObj) - 1;
+                    let lastMessageObj = this.makeLastMessage(message, conversationObj);
+                    let newConversationObj = conversationObj;
+                    newConversationObj.setLastMessage(lastMessageObj);
+                    newConversationObj.setUnreadMessageCount(unreadMessageCount);
+                    newConversationObj.getLastMessage().setMuid(this.getUinx());
+                    conversationList.splice(conversationKey, 1);
+                    conversationList.unshift(newConversationObj);
+                    this.conversationList = [...conversationList];
+                    if (notification && this.loggedInUser?.getUid() != message?.getSender()?.getUid()) {
+                        this.playAudio();
+                        this.ref.detectChanges();
+                    }
+                }
+                else {
+                    let lastMessageObj = this.makeLastMessage(message);
+                    conversationObj.setLastMessage(lastMessageObj);
+                    conversationObj.setUnreadMessageCount(1);
+                    conversationList.unshift(conversationObj);
+                    this.conversationList = conversationList;
+                    this.ref.detectChanges();
+                    // this.ref.detectChanges()
+                    if (notification && this.loggedInUser?.getUid() != message?.getSender()?.getUid()) {
+                        this.playAudio();
+                        this.ref.detectChanges();
+                    }
+                }
+                this.ref.detectChanges();
+            })
+                .catch((error) => {
+                if (this.onError) {
+                    this.onError(error);
+                }
+                this.ref.detectChanges();
+            });
+        }
+        catch (error) {
+            if (this.onError) {
+                this.onError(error);
+            }
+        }
+        this.ref.detectChanges();
+    }
+    updateDeliveredMessage(messageReceipt) {
+        let conversationList = [...this.conversationList];
+        let conversationKey = conversationList.findIndex((c) => c.getLastMessage().getId() == Number(messageReceipt.getMessageId()));
+        let conversationObj;
+        if (conversationKey > -1) {
+            conversationObj = conversationList[conversationKey];
+            if (!conversationObj.getLastMessage().getDeliveredAt()) {
+                conversationObj.getLastMessage().setDeliveredAt(Number(this.getUinx()));
+                conversationObj.getLastMessage().setMuid(this.getUinx());
+                conversationList.splice(conversationKey, 1, conversationObj);
+                this.conversationList = [...conversationList];
+                this.ref.detectChanges();
+            }
+        }
+    }
+    /**
+     *
+     * Gets The Count of Unread Messages
+     * @param
+     */
+    /**
+     * @param  {any} conversation
+     * @param  {any} operator
+     */
+    makeUnreadMessageCount(conversation, operator = null) {
+        if (Object.keys(conversation).length === 0) {
+            return 1;
+        }
+        let unreadMessageCount = conversation.getUnreadMessageCount();
+        if (this.activeConversation &&
+            this.activeConversation.getConversationId() === conversation.getConversationId()) {
+            unreadMessageCount += 1;
+        }
+        else if ((this.activeConversation &&
+            this.activeConversation.hasOwnProperty("guid") &&
+            conversation.getConversationWith().hasOwnProperty("guid") &&
+            this.activeConversation.getConversationWith().getGuid() === conversation.getConversationWith().getGuid()) ||
+            (this.activeConversation &&
+                this.activeConversation.hasOwnProperty("uid") &&
+                conversation.getConversationWith().hasOwnProperty("uid") &&
+                this.activeConversation.getConversationWith().getUid() === conversation.getConversationWith().getUid())) {
+            unreadMessageCount = 0;
+        }
+        else {
+            if (operator && operator === "decrement") {
+                unreadMessageCount = unreadMessageCount ? unreadMessageCount - 1 : 0;
+            }
+            else {
+                unreadMessageCount = unreadMessageCount + 1;
+            }
+        }
+        return unreadMessageCount;
+    }
+    /**
+     * Changes detail of conversations
+     * @param
+     */
+    /**
+     * @param  {CometChat.BaseMessage} message
+     */
+    makeConversation(message) {
+        const promise = new Promise((resolve, reject) => {
+            CometChat.CometChatHelper.getConversationFromMessage(message)
+                .then((conversation) => {
+                let conversationList = [...this.conversationList];
+                let conversationKey = conversationList.findIndex((c) => c?.getConversationId() === conversation.getConversationId());
+                let conversationObj = conversation;
+                if (conversationKey > -1) {
+                    conversationObj = conversationList[conversationKey];
+                }
+                resolve({
+                    conversationKey: conversationKey,
+                    conversationObj: conversationObj,
+                    conversationList: conversationList,
+                });
+                this.ref.detectChanges();
+            })
+                .catch((error) => reject(error));
+        });
+        return promise;
+    }
+    /**
+     * Updates Conversation View when message is edited or deleted
+     */
+    conversationEditedDeleted(message) {
+        try {
+            this.makeConversation(message)
+                .then((response) => {
+                const conversationKey = response.conversationKey;
+                const conversationObj = response.conversationObj;
+                const conversationList = response.conversationList;
+                if (conversationKey > -1) {
+                    let lastMessageObj = conversationObj.getLastMessage();
+                    if (lastMessageObj.getId() === message.getId()) {
+                        conversationObj.setLastMessage(message);
+                        conversationObj.getLastMessage().setMuid(this.getUinx());
+                        conversationList.splice(conversationKey, 1, conversationObj);
+                        this.conversationList = [...conversationList];
+                        this.ref.detectChanges();
+                    }
+                }
+            })
+                .catch((error) => {
+                if (this.onError) {
+                    this.onError(error);
+                }
+                this.ref.detectChanges();
+            });
+        }
+        catch (error) {
+            if (this.onError) {
+                this.onError(error);
+            }
+        }
+    }
+    /**
+     * If User scrolls to the bottom of the current Conversation list than fetch next items of the Conversation list and append
+     * @param Event
+     */
+    /**
+     * Plays Audio When Message is Received
+     */
+    playAudio() {
+        try {
+            if (!this.disableSoundForMessages) {
+                if (this.customSoundForMessages) {
+                    CometChatSoundManager.play(this.customSoundForMessages);
+                }
+                else {
+                    CometChatSoundManager.play(CometChatSoundManager.Sound.incomingMessageFromOther);
+                }
+            }
+            else {
+                return;
+            }
+        }
+        catch (error) {
+            if (this.onError) {
+                this.onError(error);
+            }
+        }
+    }
+    /*
+     * Updates the convesation list when deleted.
+     * Adding Conversation Object to CometchatService
+     */
+    /**
+     * @param  {CometChat.Conversation|{}} conversation
+     */
+    updateConversationList(conversation) {
+        let index = this.conversationList.findIndex((element) => element?.getConversationId() == conversation?.getConversationId());
+        this.conversationList.splice(index, 1);
+        this.ref.detectChanges();
+    }
+    onOptionClick(event, conversation) {
+        let option = event?.detail?.data;
+        this.conversationToBeDeleted = conversation;
+        if (option) {
+            option.onClick();
+        }
+    }
+    /**
+     * show confirm dialog screen
+     * @param  {CometChat.Conversation|{}} conversaton
+     */
+    // check is there is any active conversation and mark it as active
+    getActiveConversation(conversation) {
+        if (this.selectionMode == SelectionMode.none || !this.selectionMode) {
+            return this.activeConversation && this.activeConversation?.conversationId == conversation?.conversationId;
+        }
+        else {
+            return false;
+        }
+    }
+    /**
+     * handle confirm dialog response
+     * @param  {string} value
+     */
+    // calling cometchat.deleteConversation method
+    deleteSelectedConversation() {
+        if (this.conversationToBeDeleted) {
+            if (this.activeConversation && this.activeConversation.getConversationId() == this.conversationToBeDeleted.getConversationId()) {
+                this.activeConversation = null;
+            }
+            let conversationWith;
+            let conversationType = this.conversationToBeDeleted.getConversationType();
+            if (conversationType === CometChatUIKitConstants.MessageReceiverType.user) {
+                conversationWith = this.conversationToBeDeleted.getConversationWith().getUid();
+            }
+            else {
+                conversationWith = this.conversationToBeDeleted.getConversationWith().getGuid();
+            }
+            CometChat.deleteConversation(conversationWith, conversationType).then(deletedConversation => {
+                CometChatConversationEvents.ccConversationDeleted.next(this.conversationToBeDeleted);
+                this.updateConversationList(this.conversationToBeDeleted);
+                this.conversationToBeDeleted = null;
+                this.ref.detectChanges();
+            });
+            this.isDialogOpen = false;
+            this.ref.detectChanges();
+        }
+    }
+    // exposed methods to users.
+    updateLastMessage(message) {
+        this.updateConversation(message);
+    }
+    removeConversation(conversation) {
+        this.updateConversationList(conversation);
+    }
+}
+CometChatConversationsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CometChatConversationsComponent, deps: [{ token: i0.NgZone }, { token: i0.ChangeDetectorRef }, { token: i1.CometChatThemeService }], target: i0.ɵɵFactoryTarget.Component });
+CometChatConversationsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: CometChatConversationsComponent, selector: "cometchat-conversations", inputs: { subtitleView: "subtitleView", title: "title", options: "options", searchPlaceHolder: "searchPlaceHolder", disableUsersPresence: "disableUsersPresence", disableReceipt: "disableReceipt", disableTyping: "disableTyping", deliveredIcon: "deliveredIcon", readIcon: "readIcon", errorIcon: "errorIcon", datePattern: "datePattern", onError: "onError", sentIcon: "sentIcon", privateGroupIcon: "privateGroupIcon", protectedGroupIcon: "protectedGroupIcon", customSoundForMessages: "customSoundForMessages", activeConversation: "activeConversation", searchIconURL: "searchIconURL", hideSearch: "hideSearch", conversationsRequestBuilder: "conversationsRequestBuilder", emptyStateView: "emptyStateView", onSelect: "onSelect", loadingIconURL: "loadingIconURL", errorStateView: "errorStateView", loadingStateView: "loadingStateView", emptyStateText: "emptyStateText", errorStateText: "errorStateText", titleAlignment: "titleAlignment", listItemView: "listItemView", menu: "menu", hideSeparator: "hideSeparator", searchPlaceholder: "searchPlaceholder", hideError: "hideError", selectionMode: "selectionMode", disableSoundForMessages: "disableSoundForMessages", confirmDialogTitle: "confirmDialogTitle", confirmButtonText: "confirmButtonText", cancelButtonText: "cancelButtonText", confirmDialogMessage: "confirmDialogMessage", onItemClick: "onItemClick", deleteConversationDialogStyle: "deleteConversationDialogStyle", backdropStyle: "backdropStyle", badgeStyle: "badgeStyle", dateStyle: "dateStyle", conversationsStyle: "conversationsStyle", listItemStyle: "listItemStyle", statusIndicatorStyle: "statusIndicatorStyle", typingIndicatorText: "typingIndicatorText", threadIndicatorText: "threadIndicatorText", avatarStyle: "avatarStyle", receiptStyle: "receiptStyle", loggedInUser: "loggedInUser" }, usesOnChanges: true, ngImport: i0, template: "<div  class=\"cc-conversations\" [ngStyle]=\"styles.wrapperStyle()\">\n  <cometchat-backdrop [backdropStyle]=\"backdropStyle\" *ngIf=\"isDialogOpen\">\n    <cometchat-confirm-dialog [title]=\"confirmDialogTitle\" [messageText]=\"confirmDialogMessage\" [cancelButtonText]=\"cancelButtonText\" [confirmButtonText]=\"confirmButtonText\" (cc-confirm-clicked)=\"onConfirmClick()\" (cc-cancel-clicked)=\"onCancelClick()\" [confirmDialogStyle]=\"deleteConversationDialogStyle\">\n    </cometchat-confirm-dialog>\n  </cometchat-backdrop>\n  <div class=\"cc-conversations__menus\" *ngIf=\"menu\">\n\n      <ng-container *ngTemplateOutlet=\"menu\">\n      </ng-container>\n\n  </div>\n<cometchat-list [state]=\"state\"\n[searchIconURL]=\"searchIconURL\"  [hideError]=\"hideError\"\n[emptyStateText]=\"emptyStateText\" [loadingIconURL]=\"loadingIconURL\"\n[titleAlignment]=\"titleAlignment\" [loadingView]=\"loadingStateView\" [listStyle]=\"listStyle\" [emptyStateView]=\"emptyStateView\"\n[errorStateText]=\"errorStateText\" [errorView]=\"errorStateView\"\n[onScrolledToBottom]=\"getConversation\" [list]=\"conversationList\"  [listItemView]=\"listItemView ? listItemView : listItem\" [title]=\"title\"  [hideSearch]=\"hideSearch\"></cometchat-list>\n</div>\n<ng-template #listItem let-conversation>\n  <cometchat-list-item [hideSeparator]=\"hideSeparator\" [avatarStyle]=\"avatarStyle\" [statusIndicatorStyle]=\"setStatusIndicatorStyle(conversation)\"\n  [id]=\"conversation?.conversationId\" [isActive]=\"getActiveConversation(conversation)\"\n  (cc-listitem-clicked)=\"onClick(conversation)\" [title]=\"conversation?.conversationWith?.name\"\n  [statusIndicatorIcon]=\"checkGroupType(conversation)\" [statusIndicatorColor]=\"checkStatusType(conversation)\"\n  [listItemStyle]=\"listItemStyle\" [avatarURL]=\"conversation?.conversationWith?.avatar\" [avatarName]=\"conversation?.conversationWith?.name\">\n    <div slot=\"subtitleView\" *ngIf=\"subtitleView;else conversationSubtitle\">\n      <ng-container *ngTemplateOutlet=\"subtitleView\">\n      </ng-container>\n  </div>\n  <ng-template #conversationSubtitle>\n\n  <div class=\"cc-conversations__subtitle-view \" slot=\"subtitleView\" >\n    <div class=\"cc-conversations__threadview\" *ngIf=\"conversation?.lastMessage?.parentMessageId\">\n      <cometchat-label [labelStyle]=\"itemThreadIndicatorStyle()\" [text]=\"threadIndicatorText\"> </cometchat-label>\n      <cometchat-icon [URL]=\"threadIconURL\" [iconStyle]=\"iconStyle\"></cometchat-icon>\n\n    </div>\n<div class=\"cc-conversations__subtitle\">\n  <div class=\"cc-conversations__readreceipt\" *ngIf=\"isReceiptDisable(conversation)\">\n    <cometchat-receipt  [receipt]=\"getMessageReceipt(conversation)\" [receiptStyle]=\"receiptStyle\" [sentIcon]=\"sentIcon\" [errorIcon]=\"errorIcon\" [deliveredIcon]=\"deliveredIcon\" [readIcon]=\"readIcon\"></cometchat-receipt>\n  </div>\n\n  <div [ngStyle]=\"subtitleStyle(conversation)\" class=\"cc-subtitle__text\"> {{setSubtitle(conversation)}} </div>\n</div>\n\n  </div>\n  </ng-template>\n  <div slot=\"menuView\" class=\"cc-conversations__optionsview\" *ngIf=\"selectionMode == selectionmodeEnum.none\">\n    <div *ngIf=\"options\">\n      <cometchat-menu-list [data]=\"options(conversation)\" (cc-menu-clicked)=\"onOptionClick($event,conversation)\" [menuListStyle]=\"menustyle\">\n\n      </cometchat-menu-list>\n    </div>\n    <div *ngIf=\"!options && conversationOptions\">\n      <cometchat-menu-list [data]=\"conversationOptions\" (cc-menu-clicked)=\"onOptionClick($event,conversation)\" [menuListStyle]=\"menustyle\">\n\n      </cometchat-menu-list>\n    </div>\n</div>\n<div slot=\"tailView\"  class=\"cc-conversations__tail-view\">\n<div class=\"tail__view\" *ngIf=\"selectionMode == selectionmodeEnum.none\">\n  <div class=\"cc-date\">\n    <cometchat-date [dateStyle]=\"dateStyle\" [timestamp]=\"conversation?.lastMessage?.sentAt\" [pattern]=\"getDate()\"></cometchat-date>\n  </div>\n  <div class=\"cc-conversations__badge\">\n     <cometchat-badge [count]=\"conversation?.unreadMessageCount\" [badgeStyle]=\"badgeStyle\"></cometchat-badge>\n  </div>\n</div>\n<div class=\"cc-conversations__selection-view\" *ngIf=\"selectionMode != selectionmodeEnum.none\">\n  <ng-container *ngTemplateOutlet=\"tailView\">\n  </ng-container>\n</div>\n</div>\n  </cometchat-list-item>\n  <ng-template #tailView>\n    <div  *ngIf=\"selectionMode == selectionmodeEnum.single\">\n      <cometchat-radio-button (cc-radio-button-changed)=\"onSelect ? onSelect(conversation) : null\"></cometchat-radio-button>\n    </div>\n    <div  *ngIf=\"selectionMode == selectionmodeEnum.multiple\">\n      <cometchat-checkbox (cc-checkbox-changed)=\"onSelect ? onSelect(conversation) : null\"></cometchat-checkbox>\n    </div>\n  </ng-template>\n</ng-template>\n\n\n", styles: [".cc-conversations{height:100%;width:100%;box-sizing:border-box;margin-bottom:16px;position:relative}.cc-conversations__selection-view{position:relative}.tail__view{display:flex;flex-direction:column;justify-content:flex-start;align-items:center}.cc-subtitle__text{text-overflow:ellipsis;overflow:hidden;white-space:nowrap}.cc-conversations__menus{position:absolute;right:12px;padding:12px;cursor:pointer}.cc-menus__icon{height:24px;width:24px}.cc-conversations__subtitle-view{display:flex;align-items:center;width:90%;flex-direction:column;justify-content:flex-start}.cc-conversations__subtitle{display:flex;justify-content:flex-start;width:100%;align-items:center;min-height:22px}.cc-conversations__threadview{height:12px;display:flex;justify-content:flex-start;width:100%;align-items:center}.cc-conversations__badge{display:flex;align-items:flex-end;justify-content:flex-end;width:100%;padding-right:8px}\n"], components: [{ type: i2.CometchatListComponent, selector: "cometchat-list", inputs: ["listItemView", "onScrolledToBottom", "onScrolledToTop", "list", "onSearch", "searchText", "searchIconURL", "listStyle", "searchPlaceholderText", "hideSearch", "hideError", "title", "titleAlignment", "errorStateView", "loadingStateView", "emptyStateView", "state", "errorStateText", "emptyStateText", "loadingIconURL", "showSectionHeader", "sectionHeaderField"] }], directives: [{ type: i3.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i3.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CometChatConversationsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "cometchat-conversations", changeDetection: ChangeDetectionStrategy.OnPush, template: "<div  class=\"cc-conversations\" [ngStyle]=\"styles.wrapperStyle()\">\n  <cometchat-backdrop [backdropStyle]=\"backdropStyle\" *ngIf=\"isDialogOpen\">\n    <cometchat-confirm-dialog [title]=\"confirmDialogTitle\" [messageText]=\"confirmDialogMessage\" [cancelButtonText]=\"cancelButtonText\" [confirmButtonText]=\"confirmButtonText\" (cc-confirm-clicked)=\"onConfirmClick()\" (cc-cancel-clicked)=\"onCancelClick()\" [confirmDialogStyle]=\"deleteConversationDialogStyle\">\n    </cometchat-confirm-dialog>\n  </cometchat-backdrop>\n  <div class=\"cc-conversations__menus\" *ngIf=\"menu\">\n\n      <ng-container *ngTemplateOutlet=\"menu\">\n      </ng-container>\n\n  </div>\n<cometchat-list [state]=\"state\"\n[searchIconURL]=\"searchIconURL\"  [hideError]=\"hideError\"\n[emptyStateText]=\"emptyStateText\" [loadingIconURL]=\"loadingIconURL\"\n[titleAlignment]=\"titleAlignment\" [loadingView]=\"loadingStateView\" [listStyle]=\"listStyle\" [emptyStateView]=\"emptyStateView\"\n[errorStateText]=\"errorStateText\" [errorView]=\"errorStateView\"\n[onScrolledToBottom]=\"getConversation\" [list]=\"conversationList\"  [listItemView]=\"listItemView ? listItemView : listItem\" [title]=\"title\"  [hideSearch]=\"hideSearch\"></cometchat-list>\n</div>\n<ng-template #listItem let-conversation>\n  <cometchat-list-item [hideSeparator]=\"hideSeparator\" [avatarStyle]=\"avatarStyle\" [statusIndicatorStyle]=\"setStatusIndicatorStyle(conversation)\"\n  [id]=\"conversation?.conversationId\" [isActive]=\"getActiveConversation(conversation)\"\n  (cc-listitem-clicked)=\"onClick(conversation)\" [title]=\"conversation?.conversationWith?.name\"\n  [statusIndicatorIcon]=\"checkGroupType(conversation)\" [statusIndicatorColor]=\"checkStatusType(conversation)\"\n  [listItemStyle]=\"listItemStyle\" [avatarURL]=\"conversation?.conversationWith?.avatar\" [avatarName]=\"conversation?.conversationWith?.name\">\n    <div slot=\"subtitleView\" *ngIf=\"subtitleView;else conversationSubtitle\">\n      <ng-container *ngTemplateOutlet=\"subtitleView\">\n      </ng-container>\n  </div>\n  <ng-template #conversationSubtitle>\n\n  <div class=\"cc-conversations__subtitle-view \" slot=\"subtitleView\" >\n    <div class=\"cc-conversations__threadview\" *ngIf=\"conversation?.lastMessage?.parentMessageId\">\n      <cometchat-label [labelStyle]=\"itemThreadIndicatorStyle()\" [text]=\"threadIndicatorText\"> </cometchat-label>\n      <cometchat-icon [URL]=\"threadIconURL\" [iconStyle]=\"iconStyle\"></cometchat-icon>\n\n    </div>\n<div class=\"cc-conversations__subtitle\">\n  <div class=\"cc-conversations__readreceipt\" *ngIf=\"isReceiptDisable(conversation)\">\n    <cometchat-receipt  [receipt]=\"getMessageReceipt(conversation)\" [receiptStyle]=\"receiptStyle\" [sentIcon]=\"sentIcon\" [errorIcon]=\"errorIcon\" [deliveredIcon]=\"deliveredIcon\" [readIcon]=\"readIcon\"></cometchat-receipt>\n  </div>\n\n  <div [ngStyle]=\"subtitleStyle(conversation)\" class=\"cc-subtitle__text\"> {{setSubtitle(conversation)}} </div>\n</div>\n\n  </div>\n  </ng-template>\n  <div slot=\"menuView\" class=\"cc-conversations__optionsview\" *ngIf=\"selectionMode == selectionmodeEnum.none\">\n    <div *ngIf=\"options\">\n      <cometchat-menu-list [data]=\"options(conversation)\" (cc-menu-clicked)=\"onOptionClick($event,conversation)\" [menuListStyle]=\"menustyle\">\n\n      </cometchat-menu-list>\n    </div>\n    <div *ngIf=\"!options && conversationOptions\">\n      <cometchat-menu-list [data]=\"conversationOptions\" (cc-menu-clicked)=\"onOptionClick($event,conversation)\" [menuListStyle]=\"menustyle\">\n\n      </cometchat-menu-list>\n    </div>\n</div>\n<div slot=\"tailView\"  class=\"cc-conversations__tail-view\">\n<div class=\"tail__view\" *ngIf=\"selectionMode == selectionmodeEnum.none\">\n  <div class=\"cc-date\">\n    <cometchat-date [dateStyle]=\"dateStyle\" [timestamp]=\"conversation?.lastMessage?.sentAt\" [pattern]=\"getDate()\"></cometchat-date>\n  </div>\n  <div class=\"cc-conversations__badge\">\n     <cometchat-badge [count]=\"conversation?.unreadMessageCount\" [badgeStyle]=\"badgeStyle\"></cometchat-badge>\n  </div>\n</div>\n<div class=\"cc-conversations__selection-view\" *ngIf=\"selectionMode != selectionmodeEnum.none\">\n  <ng-container *ngTemplateOutlet=\"tailView\">\n  </ng-container>\n</div>\n</div>\n  </cometchat-list-item>\n  <ng-template #tailView>\n    <div  *ngIf=\"selectionMode == selectionmodeEnum.single\">\n      <cometchat-radio-button (cc-radio-button-changed)=\"onSelect ? onSelect(conversation) : null\"></cometchat-radio-button>\n    </div>\n    <div  *ngIf=\"selectionMode == selectionmodeEnum.multiple\">\n      <cometchat-checkbox (cc-checkbox-changed)=\"onSelect ? onSelect(conversation) : null\"></cometchat-checkbox>\n    </div>\n  </ng-template>\n</ng-template>\n\n\n", styles: [".cc-conversations{height:100%;width:100%;box-sizing:border-box;margin-bottom:16px;position:relative}.cc-conversations__selection-view{position:relative}.tail__view{display:flex;flex-direction:column;justify-content:flex-start;align-items:center}.cc-subtitle__text{text-overflow:ellipsis;overflow:hidden;white-space:nowrap}.cc-conversations__menus{position:absolute;right:12px;padding:12px;cursor:pointer}.cc-menus__icon{height:24px;width:24px}.cc-conversations__subtitle-view{display:flex;align-items:center;width:90%;flex-direction:column;justify-content:flex-start}.cc-conversations__subtitle{display:flex;justify-content:flex-start;width:100%;align-items:center;min-height:22px}.cc-conversations__threadview{height:12px;display:flex;justify-content:flex-start;width:100%;align-items:center}.cc-conversations__badge{display:flex;align-items:flex-end;justify-content:flex-end;width:100%;padding-right:8px}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i0.ChangeDetectorRef }, { type: i1.CometChatThemeService }]; }, propDecorators: { subtitleView: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], searchPlaceHolder: [{
+                type: Input
+            }], disableUsersPresence: [{
+                type: Input
+            }], disableReceipt: [{
+                type: Input
+            }], disableTyping: [{
+                type: Input
+            }], deliveredIcon: [{
+                type: Input
+            }], readIcon: [{
+                type: Input
+            }], errorIcon: [{
+                type: Input
+            }], datePattern: [{
+                type: Input
+            }], onError: [{
+                type: Input
+            }], sentIcon: [{
+                type: Input
+            }], privateGroupIcon: [{
+                type: Input
+            }], protectedGroupIcon: [{
+                type: Input
+            }], customSoundForMessages: [{
+                type: Input
+            }], activeConversation: [{
+                type: Input
+            }], searchIconURL: [{
+                type: Input
+            }], hideSearch: [{
+                type: Input
+            }], conversationsRequestBuilder: [{
+                type: Input
+            }], emptyStateView: [{
+                type: Input
+            }], onSelect: [{
+                type: Input
+            }], loadingIconURL: [{
+                type: Input
+            }], errorStateView: [{
+                type: Input
+            }], loadingStateView: [{
+                type: Input
+            }], emptyStateText: [{
+                type: Input
+            }], errorStateText: [{
+                type: Input
+            }], titleAlignment: [{
+                type: Input
+            }], listItemView: [{
+                type: Input
+            }], menu: [{
+                type: Input
+            }], hideSeparator: [{
+                type: Input
+            }], searchPlaceholder: [{
+                type: Input
+            }], hideError: [{
+                type: Input
+            }], selectionMode: [{
+                type: Input
+            }], disableSoundForMessages: [{
+                type: Input
+            }], confirmDialogTitle: [{
+                type: Input
+            }], confirmButtonText: [{
+                type: Input
+            }], cancelButtonText: [{
+                type: Input
+            }], confirmDialogMessage: [{
+                type: Input
+            }], onItemClick: [{
+                type: Input
+            }], deleteConversationDialogStyle: [{
+                type: Input
+            }], backdropStyle: [{
+                type: Input
+            }], badgeStyle: [{
+                type: Input
+            }], dateStyle: [{
+                type: Input
+            }], conversationsStyle: [{
+                type: Input
+            }], listItemStyle: [{
+                type: Input
+            }], statusIndicatorStyle: [{
+                type: Input
+            }], typingIndicatorText: [{
+                type: Input
+            }], threadIndicatorText: [{
+                type: Input
+            }], avatarStyle: [{
+                type: Input
+            }], receiptStyle: [{
+                type: Input
+            }], loggedInUser: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cometchat-conversations.component.js","sourceRoot":"","sources":["../../../../../projects/chat-uikit-angular/src/CometChatConversations/cometchat-conversations/cometchat-conversations.component.ts","../../../../../projects/chat-uikit-angular/src/CometChatConversations/cometchat-conversations/cometchat-conversations.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ApplicationRef,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  Input,\n  NgZone,\n  OnChanges,\n  OnInit,\n  SimpleChanges,\n  TemplateRef,\n  ViewChild,\n} from \"@angular/core\";\nimport { CometChat } from \"@cometchat-pro/chat\";\nimport { Subscription } from \"rxjs\";\nimport {SelectionMode,States, TitleAlignment,ConversationUtils , MessageReceiptUtils, CometChatSoundManager,CometChatUIKitUtility, BaseStyle, ConversationsStyle, ListStyle,  MessageStatus } from \"@cometchat/uikit-shared\";\nimport {CometChatTheme, fontHelper, localize,CometChatOption, CometChatGroupEvents, CometChatUIKitConstants,IGroupLeft, IGroupMemberAdded, IGroupMemberKickedBanned, IGroupMemberScopeChanged,IMessages, CometChatUserEvents, CometChatMessageEvents, CometChatConversationEvents,DatePatterns, CometChatCallEvents} from '@cometchat/uikit-resources'\nimport '@cometchat/uikit-elements'\nimport  { AvatarStyle, ListItemStyle,ConfirmDialogStyle,ReceiptStyle, DateStyle, BadgeStyle} from '@cometchat/uikit-elements'\nimport { CometchatListComponent } from \"../../CometChatList/cometchat-list.component\";\nimport { Message } from \"@angular/compiler/src/i18n/i18n_ast\";\nimport { CometChatThemeService } from \"../../CometChatTheme.service\";\nimport { ChatConfigurator } from \"../../Shared/Framework/ChatConfigurator\";\n/**\n*\n* CometChatConversation is a wrapper component consists of CometChatListBaseComponent and ConversationListComponent.\n*\n* @version 1.0.0\n* @author CometChatTeam\n* @copyright © 2022 CometChat Inc.\n*\n*/\n@Component({\n  selector: \"cometchat-conversations\",\n  templateUrl: \"./cometchat-conversations.component.html\",\n  styleUrls: [\"./cometchat-conversations.component.scss\"],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class CometChatConversationsComponent implements OnInit, OnChanges {\n  /**\n* This properties will come from Parent.\n*/\n  @Input() subtitleView!: TemplateRef<any>;\n  @Input() title: string = localize(\"CHATS\"); //Title of the component\n  @Input()   options!: ((member:CometChat.Conversation)=>CometChatOption[]) | null;\n  @Input() searchPlaceHolder: string = localize(\"SEARCH\"); // placeholder text of search input\n  @Input() disableUsersPresence: boolean = false;\n  @Input() disableReceipt: boolean = true;\n  @Input() disableTyping:boolean = false;\n  @Input() deliveredIcon:string = \"assets/message-delivered.svg\"\n  @Input() readIcon:string = \"assets/message-read.svg\";\n  @Input() errorIcon:string = \"assets/warning-small.svg\";\n  @Input() datePattern:DatePatterns = DatePatterns.DayDateTime;\n  @Input() onError:(error:CometChat.CometChatException)=>void = (error:CometChat.CometChatException)=>{\n    console.log(error)\n  }\n  @Input() sentIcon:string = \"assets/message-sent.svg\";\n  @Input() privateGroupIcon:string =\"assets/Private.svg\";\n  @Input() protectedGroupIcon:string = \"assets/Locked.svg\";\n  @Input() customSoundForMessages:string = \"\";\n  @Input() activeConversation: CometChat.Conversation | null = null; //selected conversation\n  @Input() searchIconURL: string = \"assets/search.svg\"; //image URL of the search icon\n  @Input() hideSearch: boolean = true; //switch on/ff search input\n  @Input() conversationsRequestBuilder: any;\n  @Input() emptyStateView!: TemplateRef<any>;\n  @Input() onSelect!: (conversation:CometChat.Conversation)=>void;\n  @Input() loadingIconURL:string = \"assets/Spinner.svg\"\n  @Input() errorStateView!: TemplateRef<any>;\n  @Input() loadingStateView!: TemplateRef<any>;\n  @Input() emptyStateText: string = localize(\"NO_CHATS_FOUND\")\n  @Input() errorStateText: string = localize(\"SOMETHING_WRONG\");\n  @Input() titleAlignment: TitleAlignment = TitleAlignment.left;\n\n  @Input() listItemView!: TemplateRef<any>;\n  @Input() menu!: TemplateRef<any>;\n  @Input() hideSeparator: boolean = false;\n  @Input() searchPlaceholder: string = localize(\"SEARCH\");\n  @Input() hideError: boolean = false;\n  @Input() selectionMode: SelectionMode = SelectionMode.none;\n  @Input() disableSoundForMessages:boolean = false;\n  @Input() confirmDialogTitle = localize(\"DELETE_CONVERSATION\")\n  @Input() confirmButtonText: string = localize(\"DELETE\");\n  @Input() cancelButtonText: string = localize(\"CANCEL\");\n  @Input() confirmDialogMessage: string = localize(\"WOULD__YOU_LIKE_TO_DELETE_THIS_CONVERSATION\");\n  @Input() onItemClick!:(conversation:CometChat.Conversation)=>void;\n  @Input() deleteConversationDialogStyle: ConfirmDialogStyle = {\n    confirmButtonBackground: \"\",\n    cancelButtonBackground: \"\",\n    confirmButtonTextColor: \"\",\n    confirmButtonTextFont: \"\",\n    cancelButtonTextColor: \"\",\n    cancelButtonTextFont: \"\",\n    titleFont: \"\",\n    titleColor: \"\",\n    messageTextFont: \"\",\n    messageTextColor: \"\",\n    background: \"\",\n    border:\"1px solid #f2f2f2\",\n    height:\"100%\",\n    width:\"100%\"\n  }\n  @Input() backdropStyle :BaseStyle = {\n    height:\"100%\",\n    width:\"100%\",\n    background:\"rgba(0, 0, 0, 0.5)\"\n  }\n  @Input() badgeStyle: BadgeStyle = {\n    width: \"25px\",\n    height: \"15px\",\n    background: \"#5aaeff\",\n    textColor: \"white\",\n    textFont: \"400 13px Inter, sans-serif\",\n    borderRadius:\"16px\"\n  }\n  @Input() dateStyle: DateStyle = {\n    textFont: \"400 11px Inter, sans-serif\",\n    textColor: \"rgba(20, 20, 20, 0.58)\",\n  }\n  @Input() conversationsStyle: ConversationsStyle = {\n    width:\"\",\n    height:\"\",\n    border:\"\",\n    borderRadius:\"\",\n  }\n  @Input() listItemStyle: ListItemStyle = {\n    height: \"100%\",\n    width: \"100%\",\n    background: \"\",\n    activeBackground: \"\",\n    borderRadius: \"grey\",\n    titleFont: \"\",\n    titleColor: \"\",\n    border: \"\",\n    separatorColor:\"rgb(232, 232, 232)\"\n  };\n  @Input() statusIndicatorStyle: any = {\n    height: \"10px\",\n    width: \"10px\",\n    borderRadius: \"16px\"\n  };\n  @Input() typingIndicatorText:string = localize(\"IS_TYPING\");\n  @Input() threadIndicatorText:string = localize(\"IN_A_THREAD\");\n  @Input() avatarStyle: AvatarStyle = {};\n  @Input() receiptStyle:ReceiptStyle = {}\n  ccGroupMemberAdded!:Subscription;\n  ccGroupMemberJoined!:Subscription;\n  ccGroupMemberKicked!:Subscription;\n  ccGroupMemberBanned!:Subscription;\n  ccGroupMemberScopeChanged!:Subscription;\n  ccOwnershipChanged!:Subscription;\n   ccMessageEdit!: Subscription;\n   ccMessageSent!: Subscription;\n   ccMessageEdited!: Subscription;\n   ccMessageDelete!: Subscription;\n   ccGroupDeleted!: Subscription;\n   ccGroupLeft!: Subscription;\n   ccUserBlocked!: Subscription;\n   ccMessageRead!: Subscription;\n   public ccOutgoingCall!: Subscription;\n   public ccCallRejected!: Subscription;\n   public ccCallEnded!: Subscription;\n   public ccCallAccepted!:Subscription;\n  iconStyle:any = {\n    iconTint:\"lightgrey\",\n    height:\"20px\",\n    width:\"20px\"\n  }\n  listStyle:ListStyle = new ListStyle({})\n  menustyle = {\n    width: \"\",\n    height: \"\",\n    border: \"none\",\n    borderRadius: \"8px\",\n    background: \"transparent\",\n    textFont: \"\",\n    textColor: \"black\",\n    iconTint: \"grey\",\n    iconBackground: \"transparent\",\n    iconBorder: \"none\",\n    iconBorderRadius: \"0\",\n    submenuWidth: \"70px\",\n    submenuHeight: \"20px\",\n    submenuBorder: \"1px solid #e8e8e8\",\n    submenuBorderRadius: \"8px\",\n    submenuBackground: \"white\",\n  }\n  public typingIndicator!:CometChat.TypingIndicator | null\n  public typingListenerId: string = \"conversation__LISTENER\" + new Date().getTime();\n  public callListenerId = \"call_\"+ new Date().getTime();\n  selectionmodeEnum: typeof SelectionMode = SelectionMode;\n  public isDialogOpen: boolean = false;\n  // public loggedInUser!: CometChat.User | null;\n  public isEmpty: boolean = false;\n  public isLoading: boolean = true;\n  public state: States = States.loading;\n  public statusColor: any = {\n    online: \"\",\n    private: \"\",\n    password: \"#F7A500\",\n    public: \"\"\n  }\n  public limit:number = 30;\n  public isError: boolean = false;\n  public conversationList: CometChat.Conversation[] = [];\n  public scrolledToBottom: boolean = false;\n  public checkItemChange: boolean = false;\n  conversationOptions!:CometChatOption[];\n  public showConfirmDialog: boolean = false;\n  public conversationToBeDeleted: CometChat.Conversation | null = null;\n  public conversationListenerId: string = \"chatlist_\" + new Date().getTime();\n  public userListenerId: string = \"chatlist_user_\" + new Date().getTime();\n  public groupListenerId: string = \"chatlist_group_\" + new Date().getTime();\n  public groupToUpdate: CometChat.Group | {} = {};\n  enablePolls:boolean = false;\n  enableStickers:boolean = false;\n  enableWhiteboard:boolean = false\n  enableDocument:boolean = false\n  threadIconURL:string = \"assets/thread-arrow.svg\"\n  public confirmDialogStyle: ConfirmDialogStyle = {\n    height: \"100%\",\n    width: \"100%\",\n    borderRadius: \"8px\"\n  }\n  subtitleValue!: string;\n  modalStyle:BaseStyle = {\n    height:\"230px\",\n    width:\"270px\"\n\n  }\n  /**\n    * Properties for internal use\n    */\n  public localize = localize;\n  /**\n* This properties will come from Parent.\n*/\n  @Input() loggedInUser!: CometChat.User | null;\n  /**\n  * Properties for internal use\n  */\n  /**\n   * passing this callback to menuList component on delete click\n   * @param  {CometChat.Conversation} conversation\n   */\n  deleteConversationOnClick: (()=>void) | null =  ()=> {\n   this.showConfirmationDialog(this.conversationToBeDeleted!)\n  }\n  // callback for confirmDialogComponent\n  onConfirmClick = () => {\n      this.deleteSelectedConversation();\n  }\n  setStatusIndicatorStyle = (conversation: CometChat.Conversation) => {\n    if (conversation.getConversationType() == CometChatUIKitConstants.MessageReceiverType.group) {\n      return {\n        height: \"12px\",\n        width: \"12px\",\n        borderRadius: \"16px\"\n      }\n    }\n    else {\n      return this.statusIndicatorStyle\n    }\n  }\n\n  /**\n * @param  {CometChat.Conversation} conversation\n */\n  checkStatusType(conversation: CometChat.Conversation) {\n    let user:CometChat.User = conversation.getConversationWith() as CometChat.User\n    if (conversation.getConversationType() == CometChatUIKitConstants.MessageReceiverType.user && !this.disableUsersPresence) {\n      return this.statusColor[user.getStatus()]\n    }\n    else {\n      return this.statusColor[conversation.getConversationType()]\n    }\n  }\n  getExtensionData(messageObject: CometChat.BaseMessage) {\n    let messageText\n    //xss extensions data\n    const xssData = CometChatUIKitUtility.checkMessageForExtensionsData(messageObject, \"xss-filter\");\n    if (xssData && CometChatUIKitUtility.checkHasOwnProperty(xssData, \"sanitized_text\") && CometChatUIKitUtility.checkHasOwnProperty(xssData, \"hasXSS\") && xssData.hasXSS === \"yes\") {\n      messageText = xssData.sanitized_text;\n    }\n    //datamasking extensions data\n    const maskedData = CometChatUIKitUtility.checkMessageForExtensionsData(messageObject, \"data-masking\");\n    if (maskedData && CometChatUIKitUtility.checkHasOwnProperty(maskedData, \"data\") && CometChatUIKitUtility.checkHasOwnProperty(maskedData.data, \"sensitive_data\") && CometChatUIKitUtility.checkHasOwnProperty(maskedData.data, \"message_masked\") && maskedData.data.sensitive_data === \"yes\") {\n      messageText = maskedData.data.message_masked;\n    }\n    //profanity extensions data\n    const profaneData = CometChatUIKitUtility.checkMessageForExtensionsData(messageObject, \"profanity-filter\");\n    if (profaneData && CometChatUIKitUtility.checkHasOwnProperty(profaneData, \"profanity\") && CometChatUIKitUtility.checkHasOwnProperty(profaneData, \"message_clean\") && profaneData.profanity === \"yes\") {\n      messageText = profaneData.message_clean;\n    }\n    return messageText || (messageObject as any).text\n  }\n  setSubtitle = (conversationObject: CometChat.Conversation) => {\n    if (this.typingIndicator) {\n      const isTyping = (conversationObject as any)?.conversationWith?.guid == this.typingIndicator.getReceiverId();\n      if (isTyping) {\n        return `${this.typingIndicator.getSender().getName()} ${this.typingIndicatorText}`;\n      } else if ((conversationObject as any)?.conversationWith?.uid == this.typingIndicator?.getSender().getUid() && this.typingIndicator.getReceiverType() !== CometChatUIKitConstants.MessageReceiverType.group) {\n        return this.typingIndicatorText;\n      }\n    }\n    let subtitle =  ChatConfigurator.getDataSource().getLastConversationMessage(conversationObject, this.loggedInUser!)\n    let icon = conversationObject?.getLastMessage()?.getType() == CometChatUIKitConstants.MessageTypes.audio ? \"📞 \" : \"📹 \"\n    return conversationObject?.getLastMessage()?.getCategory() == CometChatUIKitConstants.MessageCategory.call ? icon + subtitle : subtitle\n  }\n  checkGroupType(conversation: CometChat.Conversation): string {\n    let image: string = \"\";\n    if (conversation.getConversationType() == CometChatUIKitConstants.MessageReceiverType.group) {\n      switch (conversation.getConversationType()) {\n        case CometChatUIKitConstants.GroupTypes.password:\n          image = this.protectedGroupIcon;\n          break;\n        case CometChatUIKitConstants.GroupTypes.private:\n          image = this.privateGroupIcon;\n          break;\n        default:\n          image = \"\"\n          break;\n      }\n    }\n    return image\n  }\n  // callback for confirmDialogComponent\n  onCancelClick = () => {\n    this.isDialogOpen = false\n    this.conversationToBeDeleted = null\n    this.ref.detectChanges()\n  }\n  getMessageReceipt = (conversation: CometChat.Conversation) => {\n    let receipt = MessageReceiptUtils.getReceiptStatus(conversation.getLastMessage())\n    return receipt\n  }\n  getDate(){\n    return this.datePattern || DatePatterns.DayDateTime\n  }\n  optionsStyle = {\n    background: \"transparent\",\n    border: \"none\"\n  }\n  isActive: boolean = true;\n  contactsNotFound: boolean = false;\n  chatSearch!: boolean;\n  constructor(private ngZone: NgZone,private ref: ChangeDetectorRef,private themeService:CometChatThemeService) {\n  }\n\n  ngOnInit() {\n    this.setThemeStyle();\n    this.subscribeToEvents()\nif(this.conversationsRequestBuilder){\n  this.conversationsRequestBuilder?.build()\n}\nelse{\n  this.conversationsRequestBuilder = new CometChat.ConversationsRequestBuilder().setLimit(this.limit).build()\n}\n    this.state = States.loading;\n    this.setConversationOptions();\n    try {\n      this.getConversation();\n      this.attachListeners(this.conversationUpdated);\n    } catch (error: any) {\n      if(this.onError){\n        this.onError(error)\n      }\n    }\n    this.ref.detectChanges()\n  }\nupdateConversationObject(conversation:CometChat.Conversation){\n  let index = this.conversationList.findIndex((element: CometChat.Conversation) => element.getConversationId() == conversation.getConversationId());\n  this.conversationList.splice(index, 1, conversation);\n  this.ref.detectChanges()\n}\n  subscribeToEvents(){\n    this.ccGroupMemberScopeChanged = CometChatGroupEvents.ccGroupMemberScopeChanged.subscribe((item:IGroupMemberScopeChanged)=>{\n      let conversation = this.getConversationFromGroup(item.group!)\n      if(conversation){\n        conversation.setLastMessage(item.message)\n        this.updateConversationObject(conversation)\n      }\n    })\n    this.ccGroupMemberAdded = CometChatGroupEvents.ccGroupMemberAdded.subscribe((item:IGroupMemberAdded)=>{\n      let group:CometChat.Group = item.userAddedIn!\n      let actionMessage:CometChat.Action[] = item.messages!\n      let conversation:CometChat.Conversation | null = this.getConversationFromGroup(item.userAddedIn!)\n      conversation?.setConversationWith(group)\n      conversation?.setLastMessage(actionMessage[actionMessage?.length -1])\n      this.updateConversationObject(conversation!)\n    })\n    this.ccGroupMemberKicked = CometChatGroupEvents.ccGroupMemberKicked.subscribe((item:IGroupMemberKickedBanned)=>{\n         let conversation = this.getConversationFromGroup(item.kickedFrom!)\n         if(conversation){\n           conversation.setLastMessage(item.message)\n           this.updateConversationObject(conversation)\n         }\n    });\n    this.ccGroupMemberBanned = CometChatGroupEvents.ccGroupMemberBanned.subscribe((item:IGroupMemberKickedBanned)=>{\n      let conversation = this.getConversationFromGroup(item.kickedFrom!)\n      if(conversation){\n        conversation.setLastMessage(item.message)\n        this.updateConversationObject(conversation)\n      }\n    });\n    this.ccGroupDeleted = CometChatGroupEvents.ccGroupDeleted.subscribe((item:CometChat.Group)=>{\n      let conversation:CometChat.Conversation | null = this.getConversationFromGroup(item)\n      if(conversation){\n     this.removeConversation(conversation)\n      }\n    });\n    this.ccGroupLeft = CometChatGroupEvents.ccGroupLeft.subscribe((item:IGroupLeft)=>{\n\n      this.updateConversation(item.message!)\n      this.ref.detectChanges();\n    });\n    this.ccUserBlocked = CometChatUserEvents.ccUserBlocked.subscribe((item:CometChat.User)=>{\n      let conversation:CometChat.Conversation | null = this.getConversationFromUser(item)\n      if(conversation){\n        this.removeConversation(conversation)\n         }\n    });\n    this.ccMessageEdit = CometChatMessageEvents.ccMessageEdited.subscribe((object: IMessages) => {\n      let message: CometChat.BaseMessage = object.message!\n      if(object.status == MessageStatus.success){\n        this.updateEditedMessage(message as CometChat.TextMessage)\n      }\n   })\n   this.ccMessageSent = CometChatMessageEvents.ccMessageSent.subscribe((obj: IMessages) => {\n     let message: CometChat.BaseMessage = obj.message!\n     if(obj.status == MessageStatus.success){\n       this.updateConversation(message)\n     }\n   })\n   this.ccMessageDelete = CometChatMessageEvents.ccMessageDeleted.subscribe((messageObject: CometChat.BaseMessage) => {\n       this.updateConversation(messageObject)\n       this.ref.detectChanges();\n   })\n   this.ccMessageRead = CometChatMessageEvents.ccMessageRead.subscribe((messageObject: CometChat.BaseMessage) => {\n  CometChat.CometChatHelper.getConversationFromMessage(messageObject).then((conversation:CometChat.Conversation)=>{\n    if(conversation &&  this.activeConversation && conversation?.getConversationId() == this.activeConversation?.getConversationId()){\n      this.updateEditedMessage(messageObject as CometChat.TextMessage)\n      this.resetUnreadCount();\n    }\n  })\n  })\n  this.ccCallEnded = CometChatCallEvents.ccCallEnded.subscribe((call:CometChat.Call)=>{\n    if(call){\n      this.updateConversation(call)\n    }\n  })\n  this.ccCallRejected = CometChatCallEvents.ccCallRejected.subscribe((call: CometChat.Call) => {\n    this.updateConversation(call)\n  })\n  this.ccOutgoingCall = CometChatCallEvents.ccOutgoingCall.subscribe((call: CometChat.Call) => {\n    this.updateConversation(call)\n  })\n  this.ccCallAccepted = CometChatCallEvents.ccCallAccepted.subscribe((call: CometChat.Call) => {\n    this.updateConversation(call)\n  })\n  }\n  unsubscribeToEvents(){\n    this.ccGroupMemberAdded?.unsubscribe();\n    this.ccGroupMemberKicked?.unsubscribe();\n    this.ccGroupMemberBanned?.unsubscribe();\n    this.ccMessageEdit?.unsubscribe();\n    this.ccMessageSent?.unsubscribe();\n    this.ccMessageEdited?.unsubscribe();\n    this.ccMessageDelete?.unsubscribe();\n    this.ccGroupDeleted?.unsubscribe();\n    this.ccGroupLeft?.unsubscribe();\n    this.ccUserBlocked?.unsubscribe();\n    this.ccMessageRead?.unsubscribe();\n  }\n  getConversationFromUser(user:CometChat.User){\n    let index = this.conversationList.findIndex((element: CometChat.Conversation) => element.getConversationType() == CometChatUIKitConstants.MessageReceiverType.user &&  (element.getConversationWith() as CometChat.User).getUid() == user.getUid());\n    if(index >= 0){\n      return this.conversationList[index]\n    }\n    return null\n  }\n  getConversationFromGroup(group:CometChat.Group):CometChat.Conversation | null{\n  let index = this.conversationList.findIndex((element: CometChat.Conversation) => element.getConversationType() == CometChatUIKitConstants.MessageReceiverType.group &&  (element.getConversationWith() as CometChat.Group).getGuid() == group.getGuid());\n    if(index >= 0){\n      return this.conversationList[index]\n    }\n    return null\n  }\n  ngOnChanges(change: SimpleChanges) {\n    try {\n      if(change[\"activeConversation\"]){\n        this.resetUnreadCount()\n      }\n      /**\n       * When user sends message conversationList is updated with latest message\n       */\n    } catch (error: any) {\n            if(this.onError){\n        this.onError(error)\n      }\n    }\n  }\n  ngOnDestroy() {\n    try {\n      this.removeListeners();\n      this.unsubscribeToEvents()\n    } catch (error: any) {\n            if(this.onError){\n        this.onError(error)\n      }\n    }\n    this.ref.detectChanges()\n  }\n  // getting default conversation option and adding callback in it\n  setConversationOptions() {\n if(this.options){\n return;\n }\n this.conversationOptions = ConversationUtils.getDefaultOptions();\n this.conversationOptions.forEach((element: CometChatOption) => {\n   if (!element.onClick && element.id == CometChatUIKitConstants.ConversationOptions.delete) {\n     element.onClick = this.deleteConversationOnClick\n   }\n });\n return;\n  }\n  // reset unread count\n  onClick(conversation: CometChat.Conversation) {\n   if(this.onItemClick){\n     this.onItemClick(conversation)\n   }\n  }\n  // set unread count\n  resetUnreadCount() {\n    if (this.activeConversation) {\n      const conversationlist: CometChat.Conversation[] = [...this.conversationList];\n      //Gets the index of user which comes offline/online\n      const conversationKey = conversationlist.findIndex(\n        (conversationObj: CometChat.Conversation) =>\n          conversationObj?.getConversationId() === this.activeConversation?.getConversationId()\n      );\n      if (conversationKey > -1) {\n        let conversationObj: CometChat.Conversation = conversationlist[conversationKey];\n        let newConversationObj: CometChat.Conversation = conversationObj\n        newConversationObj.setUnreadMessageCount(0);\n        (newConversationObj.getLastMessage() as CometChat.TextMessage)?.setMuid(this.getUinx())\n        conversationlist.splice(conversationKey, 1, newConversationObj);\n        this.conversationList = [...conversationlist];\n        this.ref.detectChanges()\n      }\n    }\n  }\n  // sets property from theme to style object\n  setThemeStyle() {\n    this.setAvatarStyle();\n    this.setBadgeStyle();\n    this.setConfirmDialogStyle();\n    this.setConversationsStyle();\n    this.setListItemStyle();\n    this.setDateStyle();\n    this.setStatusStyle();\n    this.setReceiptStyle();\n    this.statusColor.private =this.conversationsStyle?.privateGroupIconBackground ;\n    this.statusColor.online =this.conversationsStyle?.onlineStatusColor ;\n    this.statusColor.password =this.conversationsStyle?.passwordGroupIconBackground;\n    this.listStyle ={\n      titleTextFont : this.conversationsStyle.titleTextFont,\n      titleTextColor : this.conversationsStyle.titleTextColor,\n      emptyStateTextFont : this.conversationsStyle.emptyStateTextFont,\n      emptyStateTextColor : this.conversationsStyle.emptyStateTextColor,\n      errorStateTextFont : this.conversationsStyle.errorStateTextFont,\n      errorStateTextColor : this.conversationsStyle.errorStateTextColor,\n      loadingIconTint : this.conversationsStyle.loadingIconTint,\n      separatorColor : this.conversationsStyle.separatorColor,\n    }\n    this.iconStyle.iconTint =    this.themeService.theme.palette.getAccent400();\n  }\n  setListItemStyle(){\n    let defaultStyle:ListItemStyle = new ListItemStyle({\n      height: \"100%\",\n      width: \"100%\",\n      background: this.themeService.theme.palette.getBackground(),\n      activeBackground: this.themeService.theme.palette.getAccent50(),\n      borderRadius: \"0\",\n      titleFont: fontHelper(this.themeService.theme.typography.title2),\n      titleColor: this.themeService.theme.palette.getAccent(),\n      border: \"none\",\n      separatorColor:this.themeService.theme.palette.getAccent200(),\n      hoverBackground:this.themeService.theme.palette.getAccent50()\n    })\n    this.listItemStyle = {...defaultStyle,...this.listItemStyle}\n  }\n  setAvatarStyle(){\n    let defaultStyle:AvatarStyle = new AvatarStyle({\n      borderRadius: \"24px\",\n      width: \"36px\",\n      height: \"36px\",\n      border: `1px solid ${this.themeService.theme.palette.getAccent200()}`,\n      backgroundColor: this.themeService.theme.palette.getAccent700(),\n      nameTextColor: this.themeService.theme.palette.getAccent900(),\n      backgroundSize: \"cover\",\n      nameTextFont: fontHelper(this.themeService.theme.typography.subtitle1),\n      outerViewBorder: \"\",\n      outerViewBorderSpacing: \"\",\n    })\n    this.avatarStyle = {...defaultStyle,...this.avatarStyle}\n  }\n  setStatusStyle(){\n    let defaultStyle:BaseStyle = {\n        height: \"12px\",\n        width:\"12px\",\n        border:\"none\",\n        borderRadius:\"24px\",\n    }\n    this.statusIndicatorStyle = {...defaultStyle,...this.statusIndicatorStyle}\n  }\n  setConversationsStyle(){\n    let defaultStyle:ConversationsStyle = new ConversationsStyle({\n      lastMessageTextFont: fontHelper(this.themeService.theme.typography.subtitle2),\n      lastMessageTextColor: this.themeService.theme.palette.getAccent600(),\n      background:this.themeService.theme.palette.getBackground(),\n      border:`1px solid ${this.themeService.theme.palette.getAccent50()}`,\n      titleTextFont:fontHelper(this.themeService.theme.typography.title1),\n      titleTextColor:this.themeService.theme.palette.getAccent(),\n      emptyStateTextFont:fontHelper(this.themeService.theme.typography.title1),\n      emptyStateTextColor:this.themeService.theme.palette.getAccent600(),\n      errorStateTextFont:fontHelper(this.themeService.theme.typography.title1),\n      errorStateTextColor:this.themeService.theme.palette.getAccent600(),\n      loadingIconTint:this.themeService.theme.palette.getAccent600(),\n      onlineStatusColor:this.themeService.theme.palette.getSuccess(),\n      separatorColor:this.themeService.theme.palette.getAccent400(),\n      privateGroupIconBackground:this.themeService.theme.palette.getSuccess(),\n      passwordGroupIconBackground:\"RGB(247, 165, 0)\",\n      typingIndictorTextColor:this.themeService.theme.palette.getPrimary(),\n      typingIndictorTextFont:fontHelper(this.themeService.theme.typography.subtitle2),\n      threadIndicatorTextFont:fontHelper(this.themeService.theme.typography.caption2),\n      threadIndicatorTextColor:this.themeService.theme.palette.getAccent600(),\n    })\n    this.conversationsStyle = {...defaultStyle,...this.conversationsStyle}\n  }\n  setDateStyle(){\n    let defaultStyle:DateStyle = new DateStyle({\n      textFont: fontHelper(this.themeService.theme.typography.caption2),\n      textColor: this.themeService.theme.palette.getAccent600(),\n      background:\"transparent\"\n    })\n    this.dateStyle = {...defaultStyle,...this.dateStyle}\n  }\n  setReceiptStyle(){\n\n    let defaultStyle:ReceiptStyle = new ReceiptStyle({\nwaitIconTint:this.themeService.theme.palette.getAccent700(),\nsentIconTint:this.themeService.theme.palette.getAccent600(),\ndeliveredIconTint:this.themeService.theme.palette.getAccent600(),\nreadIconTint:this.themeService.theme.palette.getPrimary(),\nerrorIconTint:this.themeService.theme.palette.getError(),\n    })\n    this.receiptStyle = {...defaultStyle,...this.receiptStyle}\n  }\n  setBadgeStyle(){\n    let defaultStyle:BadgeStyle = new BadgeStyle({\n      textFont: fontHelper(this.themeService.theme.typography.subtitle2),\n      textColor: this.themeService.theme.palette.getAccent(\"dark\"),\n      background:this.themeService.theme.palette.getPrimary(),\n      borderRadius:\"16px\",\n      width:\"24px\",\n    })\n    this.badgeStyle = {...defaultStyle,...this.badgeStyle}\n  }\n  setConfirmDialogStyle(){\n    let defaultStyle:ConfirmDialogStyle = new ConfirmDialogStyle({\n      confirmButtonBackground: this.themeService.theme.palette.getError(),\n      cancelButtonBackground: this.themeService.theme.palette.getSecondary(),\n      confirmButtonTextColor: this.themeService.theme.palette.getAccent900(\"light\"),\n      confirmButtonTextFont: fontHelper(this.themeService.theme.typography.text2),\n      cancelButtonTextColor: this.themeService.theme.palette.getAccent900(\"dark\"),\n      cancelButtonTextFont: fontHelper(this.themeService.theme.typography.text2),\n      titleFont: fontHelper(this.themeService.theme.typography.title1),\n      titleColor: this.themeService.theme.palette.getAccent(),\n      messageTextFont: fontHelper(this.themeService.theme.typography.subtitle2),\n      messageTextColor: this.themeService.theme.palette.getAccent600(),\n      background: this.themeService.theme.palette.getBackground(),\n      height:\"100%\",\n      width:\"350px\",\n    })\n    this.deleteConversationDialogStyle = {...defaultStyle,...this.deleteConversationDialogStyle}\n  }\n  // checking if user has his own configuration else will use default configuration\n  /**\n   * @param  {Object={}} config\n   * @param  {Object} defaultConfig?\n   * @returns defaultConfig\n   */\n  // calling subtitle callback from configurations\n  /**\n   * @param  {CometChat.Conversation} conversation\n   */\n  /**\n   * Fetches the coversation based on the conversationRequest config\n   */\n  fetchNextConversation() {\n    try {\n      return this.conversationsRequestBuilder?.fetchNext();\n    } catch (error: any) {\n      if(this.onError){\n        this.onError(error)\n      }\n    }\n  }\n  updateEditedMessage(message:CometChat.TextMessage){\n    let index = this.conversationList.findIndex(\n      (conversationObj: CometChat.Conversation) => conversationObj.getLastMessage() && (conversationObj.getLastMessage() as CometChat.BaseMessage).getId() == message?.getId()\n    );\n    if(index >= 0){\n      this.conversationEditedDeleted(message)\n    }\n  }\n  /**\n   * attaches Listeners for user activity , group activities and calling\n   * @param callback\n   */\n  /**\n   * @param  {Function} callback\n   */\n  attachListeners(callback: any) {\n    try {\n      if (!this.disableUsersPresence) {\n        CometChat.addUserListener(\n          this.userListenerId,\n          new CometChat.UserListener({\n            onUserOnline: (onlineUser: object) => {\n              /* when someuser/friend comes online, user will be received here */\n              callback(CometChatUIKitConstants.userStatusType.online, onlineUser);\n            },\n            onUserOffline: (offlineUser: object) => {\n              /* when someuser/friend went offline, user will be received here */\n              callback(CometChatUIKitConstants.userStatusType.offline, offlineUser);\n            },\n          })\n        );\n      }\n      CometChat.addGroupListener(\n        this.groupListenerId,\n        new CometChat.GroupListener({\n          onGroupMemberScopeChanged: (\n            message: any,\n            changedUser: any,\n            newScope: any,\n            oldScope: any,\n            changedGroup: any\n          ) => {\n            this.updateConversation(message)\n          },\n          onGroupMemberKicked: (message: any, kickedUser: any, kickedBy: any, kickedFrom: any) => {\n            this.updateConversation(message)\n          },\n          onGroupMemberBanned: (message: any, bannedUser: any, bannedBy: any, bannedFrom: any) => {\n            this.updateConversation(message)\n          },\n          onGroupMemberUnbanned: (\n            message: any,\n            unbannedUser: any,\n            unbannedBy: any,\n            unbannedFrom: any\n          ) => {\n            // this.updateConversation(message)\n          },\n          onMemberAddedToGroup: (\n            message: any,\n            userAdded: any,\n            userAddedBy: any,\n            userAddedIn: any\n          ) => {\n            this.updateConversation(message)\n          },\n          onGroupMemberLeft: (message: any, leavingUser: any, group: any) => {\n            this.updateConversation(message)\n          },\n          onGroupMemberJoined: (message: any, joinedUser: any, joinedGroup: any) => {\n            this.updateConversation(message)\n          },\n        })\n      );\n      CometChat.addMessageListener(\n        this.conversationListenerId,\n        new CometChat.MessageListener({\n          onTextMessageReceived: (textMessage: CometChat.TextMessage) => {\n            callback(CometChatUIKitConstants.messages.TEXT_MESSAGE_RECEIVED, null, textMessage);\n          },\n          onMediaMessageReceived: (mediaMessage: CometChat.MediaMessage) => {\n            callback(CometChatUIKitConstants.messages.MEDIA_MESSAGE_RECEIVED, null, mediaMessage);\n          },\n          onCustomMessageReceived: (customMessage: CometChat.BaseMessage) => {\n              callback(CometChatUIKitConstants.messages.CUSTOM_MESSAGE_RECEIVED, null, customMessage);\n\n          },\n          onMessagesRead: (messageReceipt: CometChat.MessageReceipt) => {\n            if (!this.disableReceipt) {\n              this.markAsRead(messageReceipt);\n            }\n          },\n          onMessageDeleted: (deletedMessage: CometChat.BaseMessage) => {\n            callback(CometChatUIKitConstants.messages.MESSAGE_DELETED, null, deletedMessage);\n          },\n          onMessageEdited: (editedMessage: CometChat.BaseMessage) => {\n            callback(CometChatUIKitConstants.messages.MESSAGE_EDITED, null, editedMessage);\n          },\n          onMessagesDelivered: (messageReceipt: CometChat.MessageReceipt) => {\n            if (!this.disableReceipt) {\n              this.updateDeliveredMessage(messageReceipt);\n            }\n          },\n          onTypingStarted: (typingIndicator: CometChat.TypingIndicator) => {\n            if(!this.disableTyping){\n              this.typingIndicator = typingIndicator\n           this.ref.detectChanges()\n            }\n          },\n          onTypingEnded: (typingIndicator: CometChat.TypingIndicator) => {\n            this.typingIndicator = null\n            this.ref.detectChanges()\n          }\n        })\n      );\n        CometChat.addCallListener(\n          this.callListenerId,\n          new CometChat.CallListener({\n            onIncomingCallReceived: (call: CometChat.Call) => {\n              this.updateConversation(call)\n            },\n            onIncomingCallCancelled: (call: CometChat.Call) => {\n              this.updateConversation(call)\n            },\n            onOutgoingCallRejected: (call: CometChat.Call) => {\n              this.updateConversation(call)\n\n            },\n            onOutgoingCallAccepted: (call: CometChat.Call) => {\n              this.updateConversation(call)\n            },\n\n          })\n        );\n\n    } catch (error: any) {\n            if(this.onError){\n        this.onError(error)\n      }\n    }\n  }\n  /**\n   * Removes all listeners\n   */\n  removeListeners() {\n    try {\n      CometChat.removeMessageListener(this.conversationListenerId);\n      CometChat.removeUserListener(this.userListenerId);\n      CometChat.removeGroupListener(this.groupListenerId);\n    } catch (error: any) {\n            if(this.onError){\n        this.onError(error)\n      }\n    }\n  }\n  /**\n   * Fetches Conversations Details with all the users\n   */\n  getConversation = () => {\n    if((this.conversationsRequestBuilder && !this.conversationsRequestBuilder?.pagination) ||  (this.conversationsRequestBuilder.pagination.current_page == 0 || this.conversationsRequestBuilder.pagination.current_page !=  this.conversationsRequestBuilder.pagination.total_pages)){\n      this.state = States.loading\n      try {\n        CometChat.getLoggedinUser()\n          .then((user: CometChat.User | null) => {\n            this.loggedInUser = user;\n            this.fetchNextConversation()\n              .then((conversationList: CometChat.Conversation[]) => {\n                conversationList.forEach((conversation: CometChat.Conversation) => {\n                  if (\n                    this.activeConversation && this.activeConversation !== null &&\n                    this.activeConversation.getConversationType() === conversation.getConversationType()\n                  ) {\n                    if (\n                      this.activeConversation.getConversationId() == conversation.getConversationId()\n                    ) {\n                      conversation.setUnreadMessageCount(0);\n                    }\n                  }\n                });\n                this.conversationList = [\n                  ...this.conversationList,\n                  ...conversationList,\n                ];\n                if ((conversationList.length <= 0 && this.conversationList?.length <= 0) || (conversationList.length === 0 && this.conversationList?.length <= 0)) {\n                  this.ngZone.run(() => {\n                    if(this.state != States.empty){\n                     this.state = States.empty\n                     this.ref.detectChanges()\n                    }\n                      this.ref.detach(); // Detach the change detector\n                    });\n                } else {\n                  this.ngZone.run(() => {\n                    if(this.state != States.loaded){\n                     this.state = States.loaded\n                     this.ref.detectChanges()\n                    }\n                      this.ref.detach(); // Detach the change detector\n                    });\n\n                }\n              })\n              .catch((error: any) => {\n                this.state = States.error\n                this.ref.detectChanges();\n              });\n          })\n          .catch((error: any) => {\n            this.state = States.error\n            this.ref.detectChanges();\n          });\n      } catch (error: any) {\n              if(this.onError){\n          this.onError(error)\n        }\n      }\n    }\n    else{\n      this.state = States.loaded;\n    }\n  }\n  isReceiptDisable(conversation:CometChat.Conversation){\n    let item:any = conversation.getConversationWith()\n    let message:CometChat.BaseMessage = conversation.getLastMessage()\n    if(!this.disableReceipt && message && message?.getCategory() != CometChatUIKitConstants.MessageCategory.action && message?.getCategory() != CometChatUIKitConstants.MessageCategory.call\n    && (!this.typingIndicator || (item?.uid != this.typingIndicator.getReceiverId() && item?.guid != this.typingIndicator.getReceiverId()))\n    && message.getSender()?.getUid() == this.loggedInUser?.getUid()\n   )\n    {\n      return true\n    }\n    else{\n      return false\n    }\n  }\n  /**\n   * Updates the conversation list's last message , badgeCount , user presence based on activities propagated by listeners\n   */\n  conversationUpdated = (\n    key: any,\n    item: CometChat.User | CometChat.Group | null = null,\n    message: CometChat.BaseMessage,\n    options = null\n  ) => {\n    try {\n      switch (key) {\n        case CometChatUIKitConstants.userStatusType.online:\n        case CometChatUIKitConstants.userStatusType.online: {\n          this.updateUser(item);\n          break;\n        }\n        case CometChatUIKitConstants.messages.MESSAGE_READ: {\n          this.updateConversation(message, false)\n          break;\n        }\n        case CometChatUIKitConstants.messages.MESSAGE_DELIVERED: {\n          this.updateConversation(message, false)\n          break;\n        }\n        case CometChatUIKitConstants.messages.TEXT_MESSAGE_RECEIVED:\n        case CometChatUIKitConstants.messages.MEDIA_MESSAGE_RECEIVED:\n        case CometChatUIKitConstants.messages.CUSTOM_MESSAGE_RECEIVED:\n          if(!this.disableReceipt){\n            this.markMessageAsDelivered(message);\n          }\n          this.updateConversation(message);\n          break;\n        case CometChatUIKitConstants.groupMemberAction.ADDED:\n        case CometChatUIKitConstants.groupMemberAction.BANNED:\n        case CometChatUIKitConstants.groupMemberAction.JOINED:\n        case CometChatUIKitConstants.groupMemberAction.KICKED:\n        case CometChatUIKitConstants.groupMemberAction.LEFT:\n        case CometChatUIKitConstants.groupMemberAction.UNBANNED:\n        case CometChatUIKitConstants.groupMemberAction.SCOPE_CHANGE:\n          this.updateConversation(message)\n          break;\n        case CometChatUIKitConstants.messages.MESSAGE_EDITED:\n        case CometChatUIKitConstants.messages.MESSAGE_DELETED:\n          this.conversationEditedDeleted(message);\n          break;\n      }\n    } catch (error: any) {\n            if(this.onError){\n        this.onError(error)\n      }\n    }\n  };\n  /**\n   * @param  {CometChat.BaseMessage} message\n   */\n  markMessageAsDelivered = (message: CometChat.BaseMessage) => {\n    //if chat window is not open, mark message as delivered\n    if (this.activeConversation?.getConversationType() == CometChatUIKitConstants.MessageReceiverType.user) {\n      if ((!this.activeConversation || (this.activeConversation?.getConversationWith() as CometChat.User)?.getUid() !== message?.getSender()?.getUid())\n        && !message.hasOwnProperty(\"deliveredAt\")) {\n        CometChat.markAsDelivered(message)\n      }\n    }\n    else {\n      if ((!this.activeConversation || (this.activeConversation?.getConversationWith() as CometChat.Group)?.getGuid() !== message?.getReceiverId())\n        && !message.hasOwnProperty(\"deliveredAt\")) {\n        CometChat.markAsDelivered(message)\n      }\n    }\n  };\n  /**\n   * @param  {CometChat.BaseMessage} readMessage\n   */\n  getUinx = () => {\n    return String(Math.round(+new Date() / 1000))\n  }\n  markAsRead(readMessage: CometChat.MessageReceipt) {\n    let conversationlist: CometChat.Conversation[] = [...this.conversationList]\n    const conversationKey = conversationlist.findIndex(\n      (conversationObj: CometChat.Conversation) => (conversationObj.getLastMessage() as CometChat.BaseMessage).getReceiverId() == readMessage.getSender().getUid()\n    );\n    if (conversationKey > -1) {\n      let newConversationObject!: CometChat.Conversation;\n      if (!(conversationlist[conversationKey].getLastMessage() as CometChat.TextMessage).getReadAt()) {\n        newConversationObject = conversationlist[conversationKey];\n        (newConversationObject.getLastMessage() as CometChat.TextMessage).setReadAt(readMessage.getReadAt());\n        (newConversationObject.getLastMessage() as CometChat.TextMessage).setMuid(this.getUinx());\n        conversationlist.splice(conversationKey, 1, newConversationObject);\n        this.conversationList = [...conversationlist];\n\n      }\n    }\n  }\n  /**\n   * Updates Detail when user comes online/offline\n   * @param\n   */\n  /**\n   * @param  {CometChat.User|CometChat.Group|null} user\n   */\n  updateUser(user: CometChat.User | CometChat.Group | null) {\n    try {\n      //when user updates\n      const conversationlist: CometChat.Conversation[] = [...this.conversationList];\n      //Gets the index of user which comes offline/online\n      const conversationKey = conversationlist.findIndex(\n        (conversationObj: CometChat.Conversation) =>\n          conversationObj.getConversationType() === CometChatUIKitConstants.MessageReceiverType.user &&\n          (conversationObj.getConversationWith() as CometChat.User).getUid() === (user as CometChat.User).getUid()\n      );\n      if (conversationKey > -1) {\n        let conversationObj: CometChat.Conversation = conversationlist[conversationKey];\n        let conversationWithObj: CometChat.User = (conversationObj.getConversationWith() as CometChat.User)\n        conversationWithObj.setStatus((user as CometChat.User).getStatus())\n        let newConversationObj: CometChat.Conversation = conversationObj\n        newConversationObj.setConversationWith(conversationWithObj);\n        (newConversationObj.getLastMessage() as CometChat.TextMessage).setMuid(this.getUinx())\n        conversationlist.splice(conversationKey, 1, newConversationObj);\n        this.conversationList = conversationlist;\n        this.ref.detectChanges()\n      }\n    } catch (error: any) {\n            if(this.onError){\n        this.onError(error)\n      }\n      this.ref.detectChanges();\n    }\n  }\n  /**\n   *\n   * Gets the last message\n   * @param conversation\n  /**\n   * @param  {CometChat.BaseMessage} message\n   * @param  {CometChat.Conversation|{}} conversation\n   */\n  makeLastMessage(message: CometChat.BaseMessage, conversation: CometChat.Conversation | {} = {}) {\n    const newMessage = message;\n    return newMessage;\n  }\n  /**\n   *\n   * Updates Conversations as Text/Custom Messages are received\n   * @param\n   *\n   */\n  /**\n   * @param  {CometChat.BaseMessage} message\n   * @param  {boolean} notification\n   */\n  updateConversation(message: CometChat.BaseMessage, notification: boolean = true) {\n    try {\n      this.makeConversation(message)\n        .then((response: any) => {\n\n          const conversationKey = response.conversationKey;\n          const conversationObj: CometChat.Conversation = response.conversationObj;\n          const conversationList = response.conversationList;\n          if (conversationKey > -1) {\n            // if sender is not logged in user then  increment count\n            let unreadMessageCount = this.loggedInUser?.getUid() != message.getSender().getUid() || this.loggedInUser?.getUid() == message.getReceiverId() ? this.makeUnreadMessageCount(\n              conversationObj\n            ) : this.makeUnreadMessageCount(conversationObj) - 1;\n            let lastMessageObj: CometChat.BaseMessage = this.makeLastMessage(message, conversationObj);\n            let newConversationObj: CometChat.Conversation = conversationObj\n            newConversationObj.setLastMessage(lastMessageObj);\n            newConversationObj.setUnreadMessageCount(unreadMessageCount);\n            (newConversationObj.getLastMessage() as CometChat.TextMessage).setMuid(this.getUinx())\n            conversationList.splice(conversationKey, 1);\n            conversationList.unshift(newConversationObj);\n            this.conversationList = [...conversationList];\n            if (notification && this.loggedInUser?.getUid() != message?.getSender()?.getUid()) {\n              this.playAudio();\n              this.ref.detectChanges()\n            }\n          } else {\n            let lastMessageObj = this.makeLastMessage(message);\n            conversationObj.setLastMessage(lastMessageObj);\n            conversationObj.setUnreadMessageCount(1)\n            conversationList.unshift(conversationObj);\n            this.conversationList = conversationList;\n            this.ref.detectChanges()\n            // this.ref.detectChanges()\n            if (notification && this.loggedInUser?.getUid() != message?.getSender()?.getUid()) {\n              this.playAudio();\n              this.ref.detectChanges()\n            }\n          }\n          this.ref.detectChanges()\n        })\n        .catch((error: any) => {\n          if(this.onError){\n            this.onError(error)\n          }\n          this.ref.detectChanges()\n        });\n    } catch (error: any) {\n            if(this.onError){\n        this.onError(error)\n      }\n    }\n    this.ref.detectChanges()\n  }\n  updateDeliveredMessage(messageReceipt: CometChat.MessageReceipt) {\n    let conversationList: CometChat.Conversation[] = [...this.conversationList];\n    let conversationKey: number = conversationList.findIndex(\n      (c: CometChat.Conversation) => (c.getLastMessage() as CometChat.TextMessage).getId() == Number(messageReceipt.getMessageId())\n    );\n    let conversationObj: CometChat.Conversation;\n    if (conversationKey > -1) {\n      conversationObj = conversationList[conversationKey];\n      if (!(conversationObj.getLastMessage() as CometChat.TextMessage).getDeliveredAt()) {\n        (conversationObj.getLastMessage() as CometChat.TextMessage).setDeliveredAt(Number(this.getUinx()));\n        (conversationObj.getLastMessage() as CometChat.TextMessage).setMuid(this.getUinx());\n        conversationList.splice(conversationKey, 1, conversationObj)\n        this.conversationList = [...conversationList];\n        this.ref.detectChanges()\n      }\n    }\n  }\n  /**\n   *\n   * Gets The Count of Unread Messages\n   * @param\n   */\n  /**\n   * @param  {any} conversation\n   * @param  {any} operator\n   */\n  makeUnreadMessageCount(conversation: CometChat.Conversation, operator: any = null) {\n    if (Object.keys(conversation).length === 0) {\n      return 1;\n    }\n    let unreadMessageCount:number = conversation.getUnreadMessageCount();\n    if (\n      this.activeConversation &&\n      this.activeConversation.getConversationId() === conversation.getConversationId()\n    ) {\n      unreadMessageCount += 1;\n    } else if (\n      (this.activeConversation &&\n        this.activeConversation.hasOwnProperty(\"guid\") &&\n        conversation.getConversationWith().hasOwnProperty(\"guid\") &&\n        (this.activeConversation.getConversationWith() as CometChat.Group).getGuid() === (conversation.getConversationWith() as CometChat.Group).getGuid()) ||\n      (this.activeConversation &&\n        this.activeConversation.hasOwnProperty(\"uid\") &&\n        conversation.getConversationWith().hasOwnProperty(\"uid\") &&\n        (this.activeConversation.getConversationWith() as CometChat.User).getUid() === (conversation.getConversationWith() as CometChat.User).getUid())\n    ) {\n      unreadMessageCount = 0;\n    } else {\n      if (operator && operator === \"decrement\") {\n        unreadMessageCount = unreadMessageCount ? unreadMessageCount - 1 : 0;\n      } else {\n        unreadMessageCount = unreadMessageCount + 1;\n      }\n    }\n    return unreadMessageCount;\n  }\n  /**\n   * Changes detail of conversations\n   * @param\n   */\n  /**\n   * @param  {CometChat.BaseMessage} message\n   */\n  makeConversation(message: CometChat.BaseMessage) {\n    const promise = new Promise((resolve, reject) => {\n      CometChat.CometChatHelper.getConversationFromMessage(message)\n        .then((conversation: CometChat.Conversation) => {\n          let conversationList: CometChat.Conversation[] = [...this.conversationList];\n          let conversationKey: number = conversationList.findIndex(\n            (c: CometChat.Conversation) => c?.getConversationId() === conversation.getConversationId()\n          );\n          let conversationObj: CometChat.Conversation = conversation;\n          if (conversationKey > -1) {\n            conversationObj = conversationList[conversationKey];\n          }\n          resolve({\n            conversationKey: conversationKey,\n            conversationObj: conversationObj,\n            conversationList: conversationList,\n          });\n          this.ref.detectChanges()\n        })\n        .catch((error: any) => reject(error));\n    });\n    return promise;\n  }\n  /**\n   * Updates Conversation View when message is edited or deleted\n   */\n  conversationEditedDeleted(message: CometChat.BaseMessage) {\n    try {\n      this.makeConversation(message)\n        .then((response: any) => {\n          const conversationKey = response.conversationKey;\n          const conversationObj: CometChat.Conversation = response.conversationObj;\n          const conversationList = response.conversationList;\n          if (conversationKey > -1) {\n            let lastMessageObj: CometChat.BaseMessage = conversationObj.getLastMessage();\n            if (lastMessageObj.getId() === message.getId()) {\n              conversationObj.setLastMessage(message);\n              (conversationObj.getLastMessage() as CometChat.TextMessage).setMuid(this.getUinx());\n              conversationList.splice(conversationKey, 1, conversationObj);\n              this.conversationList = [...conversationList];\n              this.ref.detectChanges()\n            }\n          }\n        })\n        .catch((error: any) => {\n          if(this.onError){\n            this.onError(error)\n          }\n          this.ref.detectChanges()\n        });\n    } catch (error:any) {\n            if(this.onError){\n        this.onError(error)\n      }\n    }\n  }\n  /**\n   * If User scrolls to the bottom of the current Conversation list than fetch next items of the Conversation list and append\n   * @param Event\n   */\n  /**\n   * Plays Audio When Message is Received\n   */\n  playAudio() {\n    try {\n      if(!this.disableSoundForMessages){\n        if(this.customSoundForMessages){\n          CometChatSoundManager.play(this.customSoundForMessages)\n        }\n        else{\n          CometChatSoundManager.play(CometChatSoundManager.Sound.incomingMessageFromOther)\n        }\n      }\n      else{\n        return\n      }\n    } catch (error: any) {\n            if(this.onError){\n        this.onError(error)\n      }\n    }\n  }\n  /*\n   * Updates the convesation list when deleted.\n   * Adding Conversation Object to CometchatService\n   */\n  /**\n   * @param  {CometChat.Conversation|{}} conversation\n   */\n  updateConversationList(conversation: CometChat.Conversation | null) {\n    let index = this.conversationList.findIndex((element: CometChat.Conversation) => element?.getConversationId() == conversation?.getConversationId());\n    this.conversationList.splice(index, 1);\n    this.ref.detectChanges()\n  }\n  /**\n   * showing dialog for confirm and cancel\n   * @param  {CometChat.Conversation|{}} conversation\n   */\n  showConfirmationDialog = (conversation: CometChat.Conversation) => {\n    this.isDialogOpen = true;\n    this.conversationToBeDeleted = conversation;\n    this.ref.detectChanges()\n  }\n  onOptionClick(event:any,conversation: CometChat.Conversation){\n    let option:CometChatOption = event?.detail?.data\n    this.conversationToBeDeleted = conversation;\n    if(option){\n      option.onClick!()\n    }\n  }\n  /**\n   * show confirm dialog screen\n   * @param  {CometChat.Conversation|{}} conversaton\n   */\n  // check is there is any active conversation and mark it as active\n  getActiveConversation(conversation: CometChat.Conversation) {\n    if(this.selectionMode == SelectionMode.none || !this.selectionMode ) {\n      return this.activeConversation && (this.activeConversation as any)?.conversationId == (conversation as any)?.conversationId\n    }\n    else {\n      return false\n    }\n  }\n  /**\n   * handle confirm dialog response\n   * @param  {string} value\n   */\n  // calling cometchat.deleteConversation method\n  deleteSelectedConversation(){\n    if (this.conversationToBeDeleted) {\n      if (this.activeConversation && this.activeConversation.getConversationId() == this.conversationToBeDeleted.getConversationId()) {\n        this.activeConversation = null\n      }\n      let conversationWith;\n      let conversationType = this.conversationToBeDeleted.getConversationType();\n      if (conversationType === CometChatUIKitConstants.MessageReceiverType.user) {\n        conversationWith = (this.conversationToBeDeleted.getConversationWith() as CometChat.User).getUid()\n      }\n      else {\n        conversationWith = (this.conversationToBeDeleted.getConversationWith() as CometChat.Group).getGuid()\n      }\n      CometChat.deleteConversation(conversationWith, conversationType).then(\n        deletedConversation => {\n          CometChatConversationEvents.ccConversationDeleted.next(this.conversationToBeDeleted!)\n          this.updateConversationList(this.conversationToBeDeleted)\n          this.conversationToBeDeleted = null;\n          this.ref.detectChanges()\n        },\n      );\n      this.isDialogOpen = false\n      this.ref.detectChanges()\n    }\n  }\n  // exposed methods to users.\n  updateLastMessage(message: CometChat.BaseMessage) {\n    this.updateConversation(message);\n  }\n  removeConversation(conversation: CometChat.Conversation) {\n    this.updateConversationList(conversation);\n  }\n  styles: any = {\n    wrapperStyle: () => {\n      return {\n        height: this.conversationsStyle.height,\n        width: this.conversationsStyle.width,\n        border: this.conversationsStyle.border || `1px solid ${this.themeService.theme.palette.getAccent400()}`,\n        borderRadius: this.conversationsStyle.borderRadius,\n        background: this.conversationsStyle.background || this.themeService.theme.palette.getBackground(),\n      }\n    },\n  }\n  subtitleStyle = (conversation:any) => {\n   if(this.typingIndicator && ( this.typingIndicator.getReceiverType() == CometChatUIKitConstants.MessageReceiverType.user && this.typingIndicator.getSender().getUid() == conversation.conversationWith?.uid || this.typingIndicator.getReceiverId() == conversation.conversationWith?.guid)){\n      return {\n        font: this.conversationsStyle.typingIndictorTextColor,\n        color: this.conversationsStyle.typingIndictorTextColor\n      }\n   }\n    return {\n      font:    this.conversationsStyle.lastMessageTextFont,\n      color:   this.conversationsStyle.lastMessageTextColor\n    }\n  }\n  itemThreadIndicatorStyle = () => {\n    return {\n      textFont: this.conversationsStyle.threadIndicatorTextFont || fontHelper(this.themeService.theme.typography.caption2),\n      textColor: this.conversationsStyle.threadIndicatorTextColor || this.themeService.theme.palette.getAccent400(),\n    };\n  }\n}\n","<div  class=\"cc-conversations\" [ngStyle]=\"styles.wrapperStyle()\">\n  <cometchat-backdrop [backdropStyle]=\"backdropStyle\" *ngIf=\"isDialogOpen\">\n    <cometchat-confirm-dialog [title]=\"confirmDialogTitle\" [messageText]=\"confirmDialogMessage\" [cancelButtonText]=\"cancelButtonText\" [confirmButtonText]=\"confirmButtonText\" (cc-confirm-clicked)=\"onConfirmClick()\" (cc-cancel-clicked)=\"onCancelClick()\" [confirmDialogStyle]=\"deleteConversationDialogStyle\">\n    </cometchat-confirm-dialog>\n  </cometchat-backdrop>\n  <div class=\"cc-conversations__menus\" *ngIf=\"menu\">\n\n      <ng-container *ngTemplateOutlet=\"menu\">\n      </ng-container>\n\n  </div>\n<cometchat-list [state]=\"state\"\n[searchIconURL]=\"searchIconURL\"  [hideError]=\"hideError\"\n[emptyStateText]=\"emptyStateText\" [loadingIconURL]=\"loadingIconURL\"\n[titleAlignment]=\"titleAlignment\" [loadingView]=\"loadingStateView\" [listStyle]=\"listStyle\" [emptyStateView]=\"emptyStateView\"\n[errorStateText]=\"errorStateText\" [errorView]=\"errorStateView\"\n[onScrolledToBottom]=\"getConversation\" [list]=\"conversationList\"  [listItemView]=\"listItemView ? listItemView : listItem\" [title]=\"title\"  [hideSearch]=\"hideSearch\"></cometchat-list>\n</div>\n<ng-template #listItem let-conversation>\n  <cometchat-list-item [hideSeparator]=\"hideSeparator\" [avatarStyle]=\"avatarStyle\" [statusIndicatorStyle]=\"setStatusIndicatorStyle(conversation)\"\n  [id]=\"conversation?.conversationId\" [isActive]=\"getActiveConversation(conversation)\"\n  (cc-listitem-clicked)=\"onClick(conversation)\" [title]=\"conversation?.conversationWith?.name\"\n  [statusIndicatorIcon]=\"checkGroupType(conversation)\" [statusIndicatorColor]=\"checkStatusType(conversation)\"\n  [listItemStyle]=\"listItemStyle\" [avatarURL]=\"conversation?.conversationWith?.avatar\" [avatarName]=\"conversation?.conversationWith?.name\">\n    <div slot=\"subtitleView\" *ngIf=\"subtitleView;else conversationSubtitle\">\n      <ng-container *ngTemplateOutlet=\"subtitleView\">\n      </ng-container>\n  </div>\n  <ng-template #conversationSubtitle>\n\n  <div class=\"cc-conversations__subtitle-view \" slot=\"subtitleView\" >\n    <div class=\"cc-conversations__threadview\" *ngIf=\"conversation?.lastMessage?.parentMessageId\">\n      <cometchat-label [labelStyle]=\"itemThreadIndicatorStyle()\" [text]=\"threadIndicatorText\"> </cometchat-label>\n      <cometchat-icon [URL]=\"threadIconURL\" [iconStyle]=\"iconStyle\"></cometchat-icon>\n\n    </div>\n<div class=\"cc-conversations__subtitle\">\n  <div class=\"cc-conversations__readreceipt\" *ngIf=\"isReceiptDisable(conversation)\">\n    <cometchat-receipt  [receipt]=\"getMessageReceipt(conversation)\" [receiptStyle]=\"receiptStyle\" [sentIcon]=\"sentIcon\" [errorIcon]=\"errorIcon\" [deliveredIcon]=\"deliveredIcon\" [readIcon]=\"readIcon\"></cometchat-receipt>\n  </div>\n\n  <div [ngStyle]=\"subtitleStyle(conversation)\" class=\"cc-subtitle__text\"> {{setSubtitle(conversation)}} </div>\n</div>\n\n  </div>\n  </ng-template>\n  <div slot=\"menuView\" class=\"cc-conversations__optionsview\" *ngIf=\"selectionMode == selectionmodeEnum.none\">\n    <div *ngIf=\"options\">\n      <cometchat-menu-list [data]=\"options(conversation)\" (cc-menu-clicked)=\"onOptionClick($event,conversation)\" [menuListStyle]=\"menustyle\">\n\n      </cometchat-menu-list>\n    </div>\n    <div *ngIf=\"!options && conversationOptions\">\n      <cometchat-menu-list [data]=\"conversationOptions\" (cc-menu-clicked)=\"onOptionClick($event,conversation)\" [menuListStyle]=\"menustyle\">\n\n      </cometchat-menu-list>\n    </div>\n</div>\n<div slot=\"tailView\"  class=\"cc-conversations__tail-view\">\n<div class=\"tail__view\" *ngIf=\"selectionMode == selectionmodeEnum.none\">\n  <div class=\"cc-date\">\n    <cometchat-date [dateStyle]=\"dateStyle\" [timestamp]=\"conversation?.lastMessage?.sentAt\" [pattern]=\"getDate()\"></cometchat-date>\n  </div>\n  <div class=\"cc-conversations__badge\">\n     <cometchat-badge [count]=\"conversation?.unreadMessageCount\" [badgeStyle]=\"badgeStyle\"></cometchat-badge>\n  </div>\n</div>\n<div class=\"cc-conversations__selection-view\" *ngIf=\"selectionMode != selectionmodeEnum.none\">\n  <ng-container *ngTemplateOutlet=\"tailView\">\n  </ng-container>\n</div>\n</div>\n  </cometchat-list-item>\n  <ng-template #tailView>\n    <div  *ngIf=\"selectionMode == selectionmodeEnum.single\">\n      <cometchat-radio-button (cc-radio-button-changed)=\"onSelect ? onSelect(conversation) : null\"></cometchat-radio-button>\n    </div>\n    <div  *ngIf=\"selectionMode == selectionmodeEnum.multiple\">\n      <cometchat-checkbox (cc-checkbox-changed)=\"onSelect ? onSelect(conversation) : null\"></cometchat-checkbox>\n    </div>\n  </ng-template>\n</ng-template>\n\n\n"]}