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

package/dist/types/src/constants/CometChatUIKitConstants.d.ts

@@ -0,0 +1,139 @@
+export declare class CometChatUIKitConstants {
+    static MessageCategory: Readonly<{
+        message: string;
+        custom: string;
+        action: string;
+        call: string;
+    }>;
+    static MessageTypes: Readonly<{
+        text: string;
+        file: string;
+        image: string;
+        audio: string;
+        video: string;
+        delete: "delete";
+        edited: "edited";
+        groupMember: "groupMember";
+    }>;
+    static groupMemberAction: Readonly<{
+        ROLE: "role";
+        BLOCK: "block";
+        REMOVE: "remove";
+        JOINED: string;
+        LEFT: string;
+        ADDED: string;
+        BANNED: string;
+        UNBANNED: string;
+        KICKED: string;
+        INVITED: string;
+        SCOPE_CHANGE: string;
+    }>;
+    static MessageReceiverType: Readonly<{
+        user: string;
+        group: string;
+    }>;
+    static userStatusType: Readonly<{
+        online: string;
+        offline: string;
+    }>;
+    static MessageOption: Readonly<{
+        editMessage: "edit";
+        deleteMessage: "delete";
+        replyMessage: "reply";
+        replyInThread: "replyInThread";
+        translateMessage: "translate";
+        reactToMessage: "react";
+        messageInformation: "messageInformation";
+        copyMessage: "copy";
+        shareMessage: "share";
+        forwardMessage: "forward";
+        sendMessagePrivately: "sendMessagePrivately";
+        replyMessagePrivately: "replyMessagePrivately";
+    }>;
+    static GroupOptions: Readonly<{
+        leave: "leave";
+        delete: "delete";
+        viewMembers: "viewMembers";
+        addMembers: "addMembers";
+        bannedMembers: "bannedMembers";
+    }>;
+    static GroupMemberOptions: Readonly<{
+        kick: "kick";
+        ban: "ban";
+        unban: "unban";
+        changeScope: "changeScope";
+    }>;
+    static groupMemberScope: Readonly<{
+        owner: "owner";
+        admin: string;
+        participant: string;
+        moderator: string;
+    }>;
+    static UserOptions: Readonly<{
+        block: "block";
+        unblock: "unblock";
+        viewProfile: "viewProfile";
+    }>;
+    static ConversationOptions: Readonly<{
+        delete: "delete";
+    }>;
+    static GroupTypes: Readonly<{
+        private: string;
+        password: string;
+        public: string;
+    }>;
+    static liveReaction: Readonly<{
+        timeout: 1500;
+    }>;
+    static messages: Readonly<{
+        MESSAGE_DELIVERED: "onMessagesDelivered";
+        MESSAGE_READ: "onMessagesRead";
+        MESSAGE_DELETED: "onMessageDeleted";
+        MESSAGE_EDITED: "onMessageEdited";
+        MESSAGE_SENT: "messageSent";
+        TEXT_MESSAGE_RECEIVED: "onTextMessageReceived";
+        MEDIA_MESSAGE_RECEIVED: "onMediaMessageReceived";
+        CUSTOM_MESSAGE_RECEIVED: "onCustomMessageReceived";
+        TRANSIENT_MESSAGE_RECEIVED: "onTransientMessageReceived";
+        INTERACTIVE_MESSAGE_RECEIVED: "onInteractiveMessageReceived";
+        INTERACTION_GOAL_COMPLETED: "onInteractionGoalCompleted";
+        DELIVERY: "delivery";
+        READ: "read";
+        APP_SYSTEM: "app_system";
+        MESSAGE_REACTION_ADDED: "onMessageReactionAdded";
+        MESSAGE_REACTION_REMOVED: "onMessageReactionRemoved";
+    }>;
+    static details: Readonly<{
+        primary: "primary";
+        secondary: "secondary";
+    }>;
+    static calls: Readonly<{
+        meeting: "meeting";
+        ongoing: string;
+        ended: string;
+        initiated: string;
+        cancelled: string;
+        rejected: string;
+        unanswered: string;
+        busy: string;
+        activecall: "cometchat:activecall";
+        default: string;
+        grid: string;
+        single: string;
+        spotlight: string;
+        tile: string;
+    }>;
+    static goalType: Readonly<{
+        allOf: import("@cometchat/chat-sdk-javascript").GoalType.ALL_OF;
+        anyOf: import("@cometchat/chat-sdk-javascript").GoalType.ANY_OF;
+        anyAction: import("@cometchat/chat-sdk-javascript").GoalType.ANY_ACTION;
+        none: import("@cometchat/chat-sdk-javascript").GoalType.NONE;
+    }>;
+    static requestBuilderLimits: Readonly<{
+        reactionListLimit: 10;
+        reactionInfoLimit: 10;
+        messageListLimit: 30;
+        usersLimit: 30;
+        groupsLimit: 30;
+    }>;
+}

package/dist/types/src/constants/CometChatUtilityConstants.d.ts

@@ -0,0 +1,9 @@
+export declare class CometChatUtilityConstants {
+    static TextFormatter: Readonly<{
+        KEY_UP_DEBOUNCE_TIME: 300;
+    }>;
+    static MentionsTextFormatter: Readonly<{
+        MENTIONS_LIMIT: 10;
+        MENTIONS_HOVER_TIMEOUT: 500;
+    }>;
+}

package/dist/types/src/constants/index.d.ts

@@ -0,0 +1 @@
+export * from './';

package/dist/types/src/events/CometChatCallEvents.d.ts

@@ -0,0 +1,10 @@
+import { Subject } from 'rxjs';
+/**
+ * Call event subjects for handling various call-related actions (like outgoing calls, call acceptance, rejections, etc.)
+ */
+export declare class CometChatCallEvents {
+    static ccOutgoingCall: Subject<CometChat.Call>;
+    static ccCallAccepted: Subject<CometChat.Call>;
+    static ccCallRejected: Subject<CometChat.Call>;
+    static ccCallEnded: Subject<CometChat.Call>;
+}

package/dist/types/src/events/CometChatConversationEvents.d.ts

@@ -0,0 +1,13 @@
+import { Subject } from 'rxjs';
+/**
+ * Conversation event subjects for handling actions related to conversations (e.g., conversation deletion)
+ */
+export declare class CometChatConversationEvents {
+    static ccConversationDeleted: Subject<CometChat.Conversation>;
+    /**
+      * Publishes a conversation event.
+      * @param {Subject<CometChat.Conversation>} event - The event to publish.
+      * @param {CometChat.Conversation} conversation - The conversation associated with the event.
+      */
+    static publishEvent(event: Subject<CometChat.Conversation>, conversation: CometChat.Conversation): void;
+}

package/dist/types/src/events/CometChatGroupEvents.d.ts

@@ -0,0 +1,63 @@
+import { Subject } from 'rxjs';
+/**
+ * Group event subjects for handling various group-related actions (e.g., group creation, member actions, ownership changes, etc.)
+ */
+export declare class CometChatGroupEvents {
+    static ccGroupCreated: Subject<CometChat.Group>;
+    static ccGroupDeleted: Subject<CometChat.Group>;
+    static ccGroupMemberJoined: Subject<IGroupMemberJoined>;
+    static ccGroupLeft: Subject<IGroupLeft>;
+    static ccGroupMemberAdded: Subject<IGroupMemberAdded>;
+    static ccGroupMemberScopeChanged: Subject<IGroupMemberScopeChanged>;
+    static ccGroupMemberKicked: Subject<IGroupMemberKickedBanned>;
+    static ccGroupMemberBanned: Subject<IGroupMemberKickedBanned>;
+    static ccGroupMemberUnbanned: Subject<IGroupMemberUnBanned>;
+    static ccOwnershipChanged: Subject<IOwnershipChanged>;
+    /**
+     * Publishes a group event.
+     * @param {Subject<CometChat.Group>} event - The event to publish.
+     * @param {any} group - The group associated with the event.
+     */
+    static publishEvent(event: Subject<CometChat.Group>, group: any): void;
+}
+/**
+ * Interfaces for various group-related events
+ */
+export interface IGroupMemberScopeChanged {
+    message: CometChat.Action;
+    updatedUser: CometChat.GroupMember;
+    scopeChangedTo: any;
+    scopeChangedFrom: any;
+    group: CometChat.Group;
+}
+export interface IOwnershipChanged {
+    group: CometChat.Group;
+    newOwner: CometChat.GroupMember;
+}
+export interface IGroupMemberKickedBanned {
+    message: CometChat.Action;
+    kickedFrom: CometChat.Group;
+    kickedUser: CometChat.User;
+    kickedBy: CometChat.User;
+}
+export interface IGroupMemberUnBanned {
+    message?: CometChat.Action;
+    unbannedUser: CometChat.User;
+    unbannedBy: CometChat.User;
+    unbannedFrom: CometChat.Group;
+}
+export interface IGroupMemberAdded {
+    messages: CometChat.Action[];
+    usersAdded: CometChat.User[];
+    userAddedIn: CometChat.Group;
+    userAddedBy: CometChat.User;
+}
+export interface IGroupMemberJoined {
+    joinedUser: CometChat.User;
+    joinedGroup: CometChat.Group;
+}
+export interface IGroupLeft {
+    userLeft: CometChat.User;
+    leftGroup: CometChat.Group;
+    message: CometChat.Action;
+}

package/dist/types/src/events/CometChatMessageEvents.d.ts

@@ -0,0 +1,43 @@
+import { MessageStatus } from '../Enums/Enums';
+import { Subject } from 'rxjs';
+/**
+ * Message event subjects for handling actions related to messages (e.g., message sent, edited, deleted, etc.)
+ */
+export declare class CometChatMessageEvents {
+    static ccMessageSent: Subject<IMessages>;
+    static ccMessageEdited: Subject<IMessages>;
+    static ccMessageTranslated: Subject<IMessages>;
+    static ccLiveReaction: Subject<string>;
+    static ccMessageRead: Subject<CometChat.BaseMessage>;
+    static ccMessageDeleted: Subject<CometChat.BaseMessage>;
+    /**
+     * Publishes a message event.
+     * @param {Subject<any>} event - The event to publish.
+     * @param {any} item - The item (message, etc.) associated with the event.
+     */
+    static publishEvent(event: any, item?: any): void;
+    /**
+    * message events wrapper of SDK listeners (e.g., media message, typing       indicator, read receipts, etc.)
+    */
+    static onTextMessageReceived: Subject<CometChat.TextMessage>;
+    static onMediaMessageReceived: Subject<CometChat.MediaMessage>;
+    static onCustomMessageReceived: Subject<CometChat.CustomMessage>;
+    static onTypingStarted: Subject<CometChat.TypingIndicator>;
+    static onTypingEnded: Subject<CometChat.TypingIndicator>;
+    static onMessagesDelivered: Subject<CometChat.MessageReceipt>;
+    static onMessagesRead: Subject<CometChat.MessageReceipt>;
+    static onMessagesDeliveredToAll: Subject<CometChat.MessageReceipt>;
+    static onMessagesReadByAll: Subject<CometChat.MessageReceipt>;
+    static onMessageEdited: Subject<CometChat.BaseMessage>;
+    static onMessageDeleted: Subject<CometChat.BaseMessage>;
+    static onTransientMessageReceived: Subject<CometChat.TransientMessage>;
+    static onMessageReactionAdded: Subject<CometChat.ReactionEvent>;
+    static onMessageReactionRemoved: Subject<CometChat.ReactionEvent>;
+}
+/**
+* Interface for message-related events
+*/
+export interface IMessages {
+    message: CometChat.BaseMessage;
+    status: MessageStatus;
+}

package/dist/types/src/events/CometChatUIEvents.d.ts

@@ -0,0 +1,59 @@
+import { Subject } from "rxjs";
+import { MouseEventSource, PanelAlignment } from "../Enums/Enums";
+/**
+ * UI event subjects for handling various UI-related actions (e.g., showing panels, modals, dialogs, etc.)
+
+ */
+export declare class CometChatUIEvents {
+    static ccHidePanel: Subject<PanelAlignment | void>;
+    static ccShowPanel: Subject<IPanel>;
+    static ccShowModal: Subject<IModal>;
+    static ccHideModal: Subject<void>;
+    static ccShowDialog: Subject<IDialog>;
+    static ccHideDialog: Subject<void>;
+    static ccActiveChatChanged: Subject<IActiveChatChanged>;
+    static ccShowOngoingCall: Subject<IShowOngoingCall>;
+    static ccOpenChat: Subject<IOpenChat>;
+    static ccComposeMessage: Subject<string>;
+    static ccMouseEvent: Subject<IMouseEvent>;
+    static ccShowMentionsCountWarning: Subject<IMentionsCountWarning>;
+    static ccActivePopover: Subject<string>;
+}
+/**
+* Interface for ui-related events
+*/
+export interface IOpenChat {
+    user?: CometChat.User;
+    group?: CometChat.Group;
+}
+export interface IShowOngoingCall {
+    child: any;
+}
+export interface IPanel {
+    child?: any;
+    configuration?: any;
+    message?: CometChat.BaseMessage;
+    position?: PanelAlignment;
+}
+export interface IModal {
+    child?: any;
+}
+export interface IActiveChatChanged {
+    user?: CometChat.User;
+    group?: CometChat.Group;
+    message?: CometChat.BaseMessage;
+    unreadMessageCount?: number;
+}
+export interface IDialog {
+    child: any;
+    confirmCallback: any;
+}
+export interface IMouseEvent {
+    event: Event;
+    source: MouseEventSource;
+    body?: {};
+}
+export interface IMentionsCountWarning {
+    showWarning: boolean;
+    id?: string;
+}

package/dist/types/src/events/CometChatUserEvents.d.ts

@@ -0,0 +1,16 @@
+import { Subject } from 'rxjs';
+/**
+ * Class to handle user-related events such as blocking and unblocking users
+ */
+export declare class CometChatUserEvents {
+    static ccUserBlocked: Subject<CometChat.User>;
+    static ccUserUnblocked: Subject<CometChat.User>;
+    /**
+     * Publishes a user event (like blocking/unblocking a user).
+     * This function will emit the event using the 'next()' method of the Subject.
+     *
+     * @param {Subject<CometChat.User>} event - The user event to be published (e.g., block or unblock).
+     * @param {any} item - The item (user) associated with the event.
+     */
+    static publishEvent(event: Subject<CometChat.User>, item: any): void;
+}

package/dist/types/src/formatters/CometChatFormatters/CometChatMentionsFormatter/CometChatMentionsFormatter.d.ts

@@ -0,0 +1,210 @@
+import { CometChatTextFormatter } from "../CometChatTextFormatter";
+import { MentionsTargetElement, MentionsVisibility } from "../../../Enums/Enums";
+/**
+ * Class that handles the text formatting for mentions in CometChat.
+ * CometChatMentionsFormatter is a child class of CometChatTextFormatter.
+ * It extends the functionality of text formatting to specifically handle user mentions
+ * in the text, it keeps track of the mentions in the text, format them for display and
+ * other functionalities.
+ * It is used in CometChatMessageComposer component and extension decorators like link preview, message translation, text moderator.
+ *
+ * @extends {CometChatTextFormatter}
+ */
+export declare class CometChatMentionsFormatter extends CometChatTextFormatter {
+    /**
+     * List of users for mentions.
+     */
+    private cometChatUserGroupMembers;
+    /**
+     * Mapping of CSS classes for mentions.
+     */
+    private mentionsCssClassMapping;
+    /**
+     * Specifies the visibility of mentions.
+     */
+    private visibleIn;
+    /**
+     * Regular expression for validating search input.
+     *
+     * The search input is considered valid if it meets all of the following conditions:
+     * - It starts with an "@" symbol.
+     * - After the "@" symbol, it can optionally contain alphanumeric characters or periods.
+     * - If there are spaces, they should not be immediately after the "@" symbol.
+     * - After a space, it can optionally contain alphanumeric characters or periods.
+     *
+     * If the search input does not meet these conditions, the regular expression match will fail, indicating invalid input.
+     *
+     * @type {RegExp}
+     * @private
+     */
+    private invalidCharactersRegexForSearch;
+    /**
+     * Count of mentions in the text.
+     */
+    private mentionsCount;
+    /**
+     * Map of mentions, linking user ids with their names.
+     */
+    private mentionsMap?;
+    /**
+     * Observer for observing changes to the text.
+     */
+    observer: MutationObserver;
+    /**
+     * Callback function for when a match is found by the regex used for search.
+     */
+    keyUpCallBack: Function;
+    private warningDisplayed;
+    private allowMultipleSpaces;
+    private mouseOverEventDispatched;
+    constructor();
+    /**
+     * Observes changes in targetNode.
+     *
+     * @param {HTMLElement} targetNode - The HTML element to observe for changes.
+     */
+    observeChange(targetNode: HTMLElement): void;
+    /**
+     * Retrieves the count of mentions.
+     *
+     * @returns {number} - The count of mentions.
+     */
+    getMentionsCount(): number;
+    /**
+     * Sets the count of mentions.
+     *
+     * @param {number} mentionsCount - The count of mentions to be set.
+     */
+    setMentionsCount(mentionsCount: number): void;
+    /**
+     * Set Regex for Checking Invalid Characters in Search Term
+     * @param pattern
+     */
+    setInvalidCharactersRegexForSearch(pattern: RegExp): void;
+    /**
+     * Sets the current caret position and selection range.
+     *
+     * @param {Selection} currentCaretPosition - The current caret position.
+     * @param {Range} currentRange - The current selection range.
+     */
+    setCaretPositionAndRange(currentCaretPosition: Selection, currentRange: Range): void;
+    /**
+     * Sets the reference to the input element.
+     *
+     * @param {HTMLElement} inputElementReference - The reference to the input element.
+     */
+    setInputElementReference(inputElementReference: HTMLElement): void;
+    /**
+     * Sets the regex pattern for matching text.
+     *
+     * @param {Array<RegExp>} regexPatterns - The array of regex patterns.
+     */
+    setRegexPattern(regexPatterns: Array<RegExp>): void;
+    /**
+     * Retrieves the CometChatUserGroupMembers.
+     *
+     * @returns {Array<CometChatUserGroupMembers>} - The current CometChatUserGroupMembers.
+     */
+    getCometChatUserGroupMembers(): (import("@cometchat/chat-sdk-javascript").User | import("@cometchat/chat-sdk-javascript").GroupMember)[];
+    /**
+     * Sets the CometChatUserGroupMembers.
+     *
+     * @param {Array<CometChatUserGroupMembers>} CometChatUserGroupMembers - The CometChatUserGroupMembers to be set.
+     */
+    setCometChatUserGroupMembers(CometChatUserGroupMembers: Array<CometChat.User | CometChat.GroupMember>): void;
+    resetCometChatUserGroupMembers(): void;
+    /**
+     * Sets the callback function for handling key down events.
+     *
+     * @param {Function} keyUpCallBack - The callback function for handling key up events.
+     */
+    setKeyUpCallBack(keyUpCallBack: Function): void;
+    /**
+     * Sets the keydown callback function.
+     * @param {Function} keyDownCallBack - The keydown callback function.
+     */
+    setKeyDownCallBack(keyDownCallBack: Function): void;
+    getAllowMultipleSpaces(): boolean;
+    setAllowMultipleSpaces(allowMultipleSpaces: boolean): void;
+    cleanup(): void;
+    /**
+     * This will be called by composer before sending the message. This can be used to set metadata, tags on message
+     * @param {CometChat.BaseMessage} message
+     * @return {CometChat.BaseMessage} - message with metadata added
+     */
+    formatMessageForSending(message: CometChat.BaseMessage): CometChat.BaseMessage;
+    reset(): void;
+    stopTracking(): void;
+    /**
+     * Formats the input text if provided, otherwise edits the text at the cursor position.
+     * @param {string|null} inputText - The input text to be formatted.
+     * @returns {string|void} - The formatted input text, or void if inputText is not provided.
+     */
+    getFormattedText(inputText: string | null, params?: {
+        mentionsTargetElement: MentionsTargetElement;
+    }): string | void;
+    /**
+     * This function adds the mention span to the input text.
+     * @param {string} inputText - The input text where the span needs to be added.
+     * @returns {string} - The modified input text.
+     */
+    protected addMentionsSpan(inputText: string): string;
+    /**
+     * Registers event listeners for click, mouseover, mouseout on the element
+     * @param {HTMLElement} element - The element on which the events need to be registered
+     * @param {DOMTokenList} domTokenList - The classes to be added
+     * @return {HTMLElement} - The element with the registered event listeners
+     */
+    registerEventListeners(element: HTMLElement, domTokenList: DOMTokenList): HTMLElement;
+    /**
+     * Replaces mentions which are span tags with corresponding user UIDs
+     *
+     * @param {string | null | undefined} inputText - The text in which the mentions need to be replaced
+     * @return {string} - The text after replacing the mentions with uids
+     */
+    protected replaceMentionsSpanWithUid(inputText: string | null | undefined): string;
+    /**
+     * Handles the keydown events, updating the mention state as necessary
+     *
+     * @param {KeyboardEvent} event - The keydown event
+     */
+    onKeyDown(event: KeyboardEvent): void;
+    /**
+     * Validates the text input based on the invalidCharactersRegexForSearch regular expression.
+     *
+     * @param {string | null} text - The text to validate. If null, the function will return null.
+     * @returns {string | null} - Returns the original text if valid, otherwise returns null.
+     */
+    validateText(text: string | null): string | null;
+    /**
+     * Handles the keyup events, updating the mention state as necessary
+     *
+     * @param {KeyboardEvent} event - The keydown event
+     */
+    onKeyUp(event: KeyboardEvent): null | undefined;
+    /**
+     * Adds the given HTML at the caret position.
+     *
+     * @param {string} newHtml - The HTML to be added.
+     * @param {Selection} currentCaretPosition - The current caret position
+     * @param {Range} currentRange - The current range
+     * @returns {void}
+     */
+    protected addAtCaretPosition(newHtml: string, currentCaretPosition: Selection, currentRange: Range): void;
+    /**
+     * Matches the regex with the given inputText and replaces the matched text with respective spans
+     *
+     * @param {string | null} inputText - The text in which the regex patterns needs to be matched
+     * @return {string} - The text after replacing the matched text with spans
+     */
+    onRegexMatch(inputText?: string | null): string;
+    /**
+     * Retrieves the original text after replacing mentions span with UIDs
+     *
+     * @param {string | null | undefined} inputText - The input text to be formatted.
+     * @returns {string} The original text after replacing mentions span with UIDs
+     */
+    getOriginalText(inputText: string | null | undefined): string;
+    setVisibleIn(visibleIn: MentionsVisibility): void;
+    getVisibleIn(): MentionsVisibility;
+}