@droppii-org/chat-mobile 0.2.0

package/src/types/chat.ts

@@ -0,0 +1,118 @@
+import {
+  type MessageItem,
+  type SessionType,
+  type MessageReceiveOptType,
+  type GroupAtType,
+} from '@droppii/openim-rn-client-sdk';
+
+export interface ChatProviderProps {
+  children: React.ReactNode;
+}
+
+export enum DChatApplicationType {
+  BIZ = 'BIZ',
+  MALL = 'MALL',
+}
+
+export enum DChatCategory {
+  BIZ_BIZ = 'BIZ_BIZ',
+  BIZ_MALL = 'BIZ_MALL',
+  GROUP = 'GROUP',
+  BIZ_BOT_PDP = 'BIZ_BOT_PDP',
+  BIZ_BOT_CRM = 'BIZ_BOT_CRM',
+}
+
+export enum DChatType {
+  SINGLE = 'SINGLE',
+  GROUP = 'GROUP',
+}
+
+export enum DMemberRole {
+  AGENT = 'AGENT',
+  MEMBER = 'MEMBER',
+}
+
+export interface DConversationPeerUser {
+  id: string;
+  username?: string;
+  fullName?: string;
+  avatar?: string;
+  type: string;
+  botName?: string;
+}
+
+export interface DConversationPeer {
+  type: 'USER' | 'GROUP';
+  user: DConversationPeerUser | null;
+  group: null; // to be defined when group is implemented
+}
+
+export interface DConversationItem {
+  // Droppii API fields
+  conversationId: string;
+  chatCategory: DChatCategory;
+  chatType: DChatType;
+  applicationType: string;
+  memberRole: DMemberRole;
+  pinnedAt: string | null;
+  isMuted: boolean;
+  peer: DConversationPeerUser;
+  // Merged from OpenIM (available after getConversationListSplit merge)
+  lastMessage?: DMessageItem;
+  unreadCount?: number;
+  conversationType?: SessionType;
+  userID?: string;
+  groupID?: string;
+  showName?: string;
+  faceURL?: string;
+  recvMsgOpt?: MessageReceiveOptType;
+  groupAtType?: GroupAtType;
+  latestMsgSendTime?: number;
+  draftText?: string;
+  draftTextTime?: number;
+  isPinned?: boolean;
+  isNotInGroup?: boolean;
+  isPrivateChat?: boolean;
+  isMsgDestruct?: boolean;
+  attachedInfo?: string;
+  ex?: string;
+}
+
+export interface DConversationQueryParams {
+  applicationType: string;
+  page: number;
+  pageSize: number;
+}
+
+export interface DMessageItem extends MessageItem {
+  isInternal?: boolean;
+  atUserIDList?: unknown;
+  attachedInfo?: 'null';
+  options?: DMessageOption;
+}
+
+export interface DMessageOption {
+  conversationUpdate: boolean;
+  offlinePush: boolean;
+  senderConversationUpdate: boolean;
+  unreadCount: boolean;
+}
+
+export interface DMessagePushInfo {
+  title: string;
+  desc: string;
+  /**
+   * @instance DMessagePushInfoEx
+   */
+  ex: string;
+  signalInfo: string;
+  iospushSound: 'default';
+  iosbadgeCount: boolean;
+}
+
+export interface DMessagePushInfoEx {
+  icon: string; // url
+  conversationId: string;
+  title: string;
+  desc: string;
+}

package/src/types/message.ts

@@ -0,0 +1,17 @@
+export const DChatMessageType = {
+  Text: 'TEXT',
+  Link: 'LINK',
+  Image: 'IMAGE',
+  Video: 'VIDEO',
+  File: 'FILE',
+  Order: 'ORDER',
+  Unsupported: 'UNSUPPORTED',
+} as const;
+
+export type DChatMessageType =
+  (typeof DChatMessageType)[keyof typeof DChatMessageType];
+
+export const CUSTOM_MESSAGE_DATA_TYPE = {
+  LINK: 'LINK',
+  ORDER: 'ORDER',
+} as const;

package/src/utils/conversation.ts

@@ -0,0 +1,106 @@
+import {
+  SessionType,
+  type ConversationItem,
+} from '@droppii/openim-rn-client-sdk';
+import {
+  type DConversationItem,
+  type DMessageItem,
+  DChatCategory,
+} from '../types/chat';
+
+export const conversationCompare = (
+  a: ConversationItem,
+  b: ConversationItem
+) => {
+  if (a.isPinned !== b.isPinned) return a.isPinned ? -1 : 1;
+
+  const aCompare =
+    a.draftTextTime > a.latestMsgSendTime
+      ? a.draftTextTime
+      : a.latestMsgSendTime;
+  const bCompare =
+    b.draftTextTime > b.latestMsgSendTime
+      ? b.draftTextTime
+      : b.latestMsgSendTime;
+
+  return bCompare - aCompare;
+};
+
+export const dConversationCompare = (
+  a: DConversationItem,
+  b: DConversationItem
+) => {
+  const aIsPinned = a.pinnedAt != null;
+  const bIsPinned = b.pinnedAt != null;
+
+  if (aIsPinned !== bIsPinned) return aIsPinned ? -1 : 1;
+
+  const aCreateTime = a.lastMessage?.createTime ?? 0;
+  const bCreateTime = b.lastMessage?.createTime ?? 0;
+
+  return bCreateTime - aCreateTime;
+};
+
+export const mergeOpenIMIntoConversation = (
+  droppii: DConversationItem,
+  openim: ConversationItem
+): DConversationItem => {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const { latestMsg, conversationID, ...openimRest } = openim;
+
+  let lastMessage: DMessageItem | undefined = droppii.lastMessage;
+  if (latestMsg) {
+    try {
+      lastMessage = JSON.parse(latestMsg) as DMessageItem;
+    } catch {
+      // keep droppii lastMessage if parse fails
+    }
+  }
+
+  return {
+    ...droppii,
+    ...openimRest,
+    lastMessage,
+  };
+};
+
+export const getConversationID = (
+  sessionType: SessionType,
+  senderID?: string,
+  receiverID?: string
+) => {
+  const prefix =
+    sessionType === SessionType.Single
+      ? 'si'
+      : sessionType === SessionType.Notification
+        ? 'sn'
+        : 'sg';
+
+  return [prefix, senderID, receiverID].filter(Boolean).join('_');
+};
+
+export const isBotCrmChat = (chatCategory: DChatCategory) =>
+  chatCategory === DChatCategory.BIZ_BOT_CRM ||
+  chatCategory === DChatCategory.BIZ_BOT_PDP;
+
+export const resolveDisplayName = (
+  item: DConversationItem,
+  t: (key: string) => string
+) => {
+  if (isBotCrmChat(item.chatCategory)) {
+    const botName = item.peer.botName?.trim();
+    if (botName) return botName;
+    return t('thread_card_bot_crm_name');
+  }
+
+  const fullName = item.peer.fullName?.trim();
+  if (fullName) return fullName;
+  const username = item.peer.username?.trim();
+  if (username) return username;
+  return t('thread_card_fallback_name');
+};
+
+export const resolveAvatarUrl = (item: DConversationItem) => {
+  if (isBotCrmChat(item.chatCategory)) return null;
+  return item.peer.avatar;
+};

package/src/utils/giftedChatMessage.ts

@@ -0,0 +1,137 @@
+import { MessageStatus, MessageType } from '@droppii/openim-rn-client-sdk';
+import type { IMessage } from 'react-native-gifted-chat';
+import type { DChatMessageType } from '../types/message';
+import type { DMessageItem } from '../types/chat';
+import { resolveChatMessageType } from './resolveMessageType';
+
+export type DGiftedChatMessage = IMessage & {
+  openIMMessage: DMessageItem;
+  messageType: DChatMessageType;
+};
+
+const SYSTEM_MESSAGE_TYPES = new Set<MessageType>([
+  MessageType.FriendAdded,
+  MessageType.OANotification,
+  MessageType.GroupCreated,
+  MessageType.GroupInfoUpdated,
+  MessageType.MemberQuit,
+  MessageType.GroupOwnerTransferred,
+  MessageType.MemberKicked,
+  MessageType.MemberInvited,
+  MessageType.MemberEnter,
+  MessageType.GroupDismissed,
+  MessageType.GroupMemberMuted,
+  MessageType.GroupMemberCancelMuted,
+  MessageType.GroupMuted,
+  MessageType.GroupCancelMuted,
+  MessageType.GroupAnnouncementUpdated,
+  MessageType.GroupNameUpdated,
+  MessageType.RevokeMessage,
+]);
+
+const getMessageText = (message: DMessageItem): string => {
+  switch (message.contentType) {
+    case MessageType.TextMessage:
+      return message.textElem?.content ?? message.content;
+    case MessageType.AtTextMessage:
+      return message.atTextElem?.text ?? message.content;
+    case MessageType.QuoteMessage:
+      return message.quoteElem?.text ?? message.content;
+    case MessageType.PictureMessage:
+      return '';
+    case MessageType.VoiceMessage:
+      return message.soundElem?.sourceUrl ? '' : '[Tin nhắn thoại]';
+    case MessageType.VideoMessage:
+      return message.videoElem?.videoUrl ? '' : '[Video]';
+    case MessageType.FileMessage:
+      return message.fileElem?.fileName ?? message.content;
+    case MessageType.CardMessage:
+      return message.cardElem?.nickname ?? message.content;
+    case MessageType.LocationMessage:
+      return message.locationElem?.description ?? message.content;
+    case MessageType.CustomMessage:
+      return message.customElem?.description ?? message.content;
+    case MessageType.FaceMessage:
+      return '[Sticker]';
+    default:
+      if (message.notificationElem?.detail) {
+        return message.notificationElem.detail;
+      }
+      return message.content || '';
+  }
+};
+
+const mapMessageStatus = (
+  message: DMessageItem
+): Pick<IMessage, 'pending' | 'sent' | 'received'> => {
+  switch (message.status) {
+    case MessageStatus.Sending:
+      return { pending: true };
+    case MessageStatus.Succeed:
+      return { sent: true, received: message.isRead };
+    case MessageStatus.Failed:
+      return { pending: true };
+    default:
+      return {};
+  }
+};
+
+export const mapOpenIMMessageToGiftedChat = (
+  message: DMessageItem
+): DGiftedChatMessage => {
+  const gifted: DGiftedChatMessage = {
+    _id: message.clientMsgID || message.serverMsgID,
+    text: getMessageText(message),
+    createdAt: new Date(message.sendTime || message.createTime),
+    user: {
+      _id: String(message.sendID),
+      name: message.senderNickname,
+      avatar: message.senderFaceUrl || undefined,
+    },
+    openIMMessage: message,
+    messageType: resolveChatMessageType(message),
+    ...mapMessageStatus(message),
+  };
+
+  if (SYSTEM_MESSAGE_TYPES.has(message.contentType)) {
+    gifted.system = true;
+  }
+
+  if (message.contentType === MessageType.PictureMessage) {
+    const imageUrl =
+      message.pictureElem?.snapshotPicture?.url ||
+      message.pictureElem?.bigPicture?.url ||
+      message.pictureElem?.sourcePicture?.url;
+
+    if (imageUrl) {
+      gifted.image = imageUrl;
+    }
+  }
+
+  if (
+    message.contentType === MessageType.VideoMessage &&
+    message.videoElem?.videoUrl
+  ) {
+    gifted.video = message.videoElem.videoUrl;
+  }
+
+  if (
+    message.contentType === MessageType.VoiceMessage &&
+    message.soundElem?.sourceUrl
+  ) {
+    gifted.audio = message.soundElem.sourceUrl;
+  }
+
+  return gifted;
+};
+
+export const mapOpenIMMessagesToGiftedChat = (
+  messages: DMessageItem[]
+): DGiftedChatMessage[] => {
+  return messages
+    .map(mapOpenIMMessageToGiftedChat)
+    .sort(
+      (a, b) =>
+        new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+    );
+};

package/src/utils/message.ts

@@ -0,0 +1,136 @@
+import { SessionType, type MessageItem } from '@droppii/openim-rn-client-sdk';
+import type { DMessageItem } from '../types/chat';
+import { getConversationID } from './conversation';
+
+const getMessageTime = (message: DMessageItem) =>
+  message.sendTime || message.createTime || 0;
+
+const getMessageKey = (message: DMessageItem) =>
+  message.clientMsgID || message.serverMsgID;
+
+export const mergeMessages = (
+  current: DMessageItem[],
+  incoming: DMessageItem[]
+): DMessageItem[] => {
+  const map = new Map<string, DMessageItem>();
+
+  for (const message of [...current, ...incoming]) {
+    const key = getMessageKey(message);
+    if (key) {
+      map.set(key, message);
+    }
+  }
+
+  return Array.from(map.values()).sort(
+    (a, b) => getMessageTime(a) - getMessageTime(b)
+  );
+};
+
+export const normalizeCreatedMessage = (
+  message: MessageItem | string
+): MessageItem => {
+  let normalized: unknown = message;
+
+  while (typeof normalized === 'string') {
+    normalized = JSON.parse(normalized);
+  }
+
+  if (normalized == null || typeof normalized !== 'object') {
+    throw new Error('Invalid OpenIM message payload');
+  }
+
+  return normalized as MessageItem;
+};
+
+export type HistoryPaginationAnchor = {
+  clientMsgID: string;
+  lastMinSeq?: number;
+};
+
+export const resolveHistoryLastMinSeq = (
+  history: { lastMinSeq?: number },
+  fallbackMessage?: DMessageItem
+): number => {
+  if (history.lastMinSeq != null) {
+    return history.lastMinSeq;
+  }
+
+  return fallbackMessage?.seq ?? 0;
+};
+
+export const getHistoryPaginationAnchor = (
+  messages: DMessageItem[]
+): HistoryPaginationAnchor | null => {
+  if (!messages.length) {
+    return null;
+  }
+
+  const oldest = messages.reduce(
+    (prev, curr) => (getMessageTime(curr) < getMessageTime(prev) ? curr : prev),
+    messages[0]!
+  );
+
+  if (!oldest?.clientMsgID) {
+    return null;
+  }
+
+  return {
+    clientMsgID: oldest.clientMsgID,
+    // lastMinSeq: oldest.seq ?? 0,
+  };
+};
+
+export const hasNewHistoryMessages = (
+  current: DMessageItem[],
+  incoming: DMessageItem[]
+): boolean => {
+  const currentKeys = new Set(
+    current.map((message) => getMessageKey(message)).filter(Boolean)
+  );
+
+  return incoming.some((message) => {
+    const key = getMessageKey(message);
+    return !!key && !currentKeys.has(key);
+  });
+};
+
+export const belongsToConversation = (
+  message: MessageItem,
+  conversationId: string,
+  groupID?: string
+): boolean => {
+  const runtimeConversationId = (
+    message as MessageItem & {
+      conversationID?: string;
+    }
+  ).conversationID;
+
+  if (runtimeConversationId === conversationId) {
+    return true;
+  }
+
+  if (groupID) {
+    return (
+      message.groupID === groupID ||
+      conversationId === `sg_${groupID}` ||
+      conversationId.endsWith(`_${groupID}`)
+    );
+  }
+
+  if (message.sessionType !== SessionType.Single) {
+    return false;
+  }
+
+  const forwardId = getConversationID(
+    message.sessionType,
+    message.sendID,
+    message.recvID
+  );
+  const reverseId = getConversationID(
+    message.sessionType,
+    message.recvID,
+    message.sendID
+  );
+
+  return conversationId === forwardId || conversationId === reverseId;
+};

package/src/utils/resolveMessageType.ts

@@ -0,0 +1,49 @@
+import { MessageType } from '@droppii/openim-rn-client-sdk';
+import type { DMessageItem } from '../types/chat';
+import { CUSTOM_MESSAGE_DATA_TYPE, DChatMessageType } from '../types/message';
+
+const parseCustomDataType = (message: DMessageItem): string | undefined => {
+  const data = message.customElem?.data;
+  if (!data) {
+    return undefined;
+  }
+
+  try {
+    const parsed = JSON.parse(data) as { type?: string; messageType?: string };
+    return parsed.type ?? parsed.messageType;
+  } catch {
+    return undefined;
+  }
+};
+
+export const resolveChatMessageType = (
+  message: DMessageItem
+): DChatMessageType => {
+  switch (message.contentType) {
+    case MessageType.TextMessage:
+    case MessageType.AtTextMessage:
+    case MessageType.QuoteMessage:
+      return DChatMessageType.Text;
+    case MessageType.PictureMessage:
+      return DChatMessageType.Image;
+    case MessageType.VideoMessage:
+      return DChatMessageType.Video;
+    case MessageType.FileMessage:
+      return DChatMessageType.File;
+    case MessageType.CustomMessage: {
+      const customType = parseCustomDataType(message);
+
+      if (customType === CUSTOM_MESSAGE_DATA_TYPE.ORDER) {
+        return DChatMessageType.Order;
+      }
+
+      if (customType === CUSTOM_MESSAGE_DATA_TYPE.LINK) {
+        return DChatMessageType.Link;
+      }
+
+      return DChatMessageType.Unsupported;
+    }
+    default:
+      return DChatMessageType.Unsupported;
+  }
+};