im-ui-mobile 0.1.0 → 0.1.2

package/types/libs/index.d.ts

@@ -19,8 +19,8 @@ export interface Chat {
     id?: string | number;
     targetId: number;
     type: 'PRIVATE' | 'GROUP';
-    showName: string;
-    headImage: string;
+    displayName: string;
+    avatar: string;
     isDnd: boolean;
     lastContent: string;
     lastSendTime?: number;
@@ -49,11 +49,11 @@ export interface Message {
     sendNickName?: string;
     atUserIds?: number[];
     sendId?: number;
-    recvId?: number;
+    receiveId?: number;
     groupId?: number;
     receipt?: boolean;
     receiptOk?: boolean;
-    readedCount?: number;
+    readCount?: number;
     quoteMessage?: Message;
     fileId?: string;
 }
@@ -63,7 +63,7 @@ export interface Message {
 export interface Friend {
     id: number;
     nickName: string;
-    headImage?: string;
+    avatar?: string;
     online: boolean;
     onlineWeb: boolean;
     onlineApp: boolean;
@@ -103,7 +103,7 @@ export interface GroupMember {
     id?: number;
     userId: number;
     showNickName: string;
-    headImage?: string;
+    avatar?: string;
     quit?: boolean;
     [key: string]: any;
 }
@@ -116,14 +116,14 @@ export interface Group {
     isBanned?: boolean;
     reason?: string;
     name: string;
-    headImage: string;
+    avatar: string;
     isDnd: boolean;
     quit?: boolean;
     topMessage?: string;
     memberCount?: number;
     createTime?: number;
     showGroupName: string;
-    headImageThumb?: string;
+    avatarThumb?: string;
     remarkGroupName?: string;
     remarkNickName?: string;
     notice?: string;
@@ -183,8 +183,8 @@ export interface RecorderFile {
 export interface UserInfo {
     id: number;
     nickName: string;
-    headImage: string;
-    headImageThumb?: string;
+    avatar: string;
+    avatarThumb?: string;
     email?: string;
     phone?: string;
     gender?: number;

package/types/utils/base64.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    encodeBase64: (str: string) => string;
+    decodeBase64: (str: string) => string;
+};
+export default _default;

package/types/utils/dom.d.ts

@@ -7,5 +7,8 @@ declare const _default: {
     hasHtmlSpecialChars: (text: string) => boolean;
     setSafeHTML: (element: HTMLElement, html: string) => void;
     safeHTML: (strings: TemplateStringsArray, ...values: any[]) => string;
+    nodesToHtml: (nodes: any[], options: any) => string;
+    extractPlainText: (nodes: any[]) => string;
+    escapeHtml: (text: string) => string;
 };
 export default _default;

package/types/utils/enums.d.ts

@@ -8,9 +8,8 @@ export declare enum MESSAGE_TYPE {
     AUDIO = 3,
     VIDEO = 4,
     RECALL = 10,
-    READED = 11,
+    READ = 11,
     RECEIPT = 12,
-    TIP_TIME = 20,
     TIP_TEXT = 21,
     LOADING = 30,
     ACT_RT_VOICE = 40,
@@ -66,8 +65,8 @@ export declare enum TERMINAL_TYPE {
 export declare enum MESSAGE_STATUS {
     FAILED = -2,// 发送失败
     SENDING = -1,// 发送中(消息没到服务器)
-    PENDING = 0,// 未送达(消息已到服务器，但对方没收到)
-    DELIVERED = 1,// 已送达(对方已收到，但是未读消息)
+    SENT = 0,// 未送达(消息已到服务器，但对方没收到)
+    RECEIVED = 1,// 已送达(对方已收到，但是未读消息)
     RECALL = 2,// 已撤回
-    READED = 3
+    READ = 3 // 已读
 }

package/types/utils/validator.d.ts

@@ -0,0 +1,74 @@
+/**
+ * 密码校验选项接口
+ */
+export interface PasswordValidationOptions {
+    /** 最小长度，默认8 */
+    minLength?: number;
+    /** 是否要求大写字母，默认true */
+    requireUppercase?: boolean;
+    /** 是否要求小写字母，默认true */
+    requireLowercase?: boolean;
+    /** 是否要求数字，默认true */
+    requireNumbers?: boolean;
+    /** 是否要求特殊字符，默认true */
+    requireSpecialChars?: boolean;
+}
+
+/**
+ * 密码校验结果接口
+ */
+export interface PasswordValidationResult {
+    /** 是否通过校验 */
+    isValid: boolean;
+    /** 密码强度（弱/中/强） */
+    strength: '弱' | '中' | '强';
+    /** 错误消息数组 */
+    messages: string[];
+}
+
+/**
+ * 校验函数声明
+ */
+export declare function isNumber(value: string | number): boolean;
+export declare function isInteger(value: string | number): boolean;
+export declare function isDecimal(value: string | number, decimalPlaces?: number): boolean;
+export declare function isPositiveInteger(value: string | number): boolean;
+export declare function isMobilePhone(phone: string): boolean;
+export declare function isInternationalPhone(phone: string): boolean;
+export declare function isLandlinePhone(phone: string): boolean;
+export declare function isEmail(email: string): boolean;
+export declare function isEmailStrict(email: string): boolean;
+export declare function isChineseIDCard(idCard: string): boolean;
+export declare function isURL(url: string): boolean;
+export declare function validatePassword(
+    password: string,
+    options?: PasswordValidationOptions
+): PasswordValidationResult;
+export declare function isChineseName(name: string): boolean;
+export declare function isLicensePlate(plate: string): boolean;
+
+/**
+ * 校验工具模块默认导出接口
+ */
+export interface ValidatorModule {
+    isNumber: typeof isNumber;
+    isInteger: typeof isInteger;
+    isDecimal: typeof isDecimal;
+    isPositiveInteger: typeof isPositiveInteger;
+    isMobilePhone: typeof isMobilePhone;
+    isInternationalPhone: typeof isInternationalPhone;
+    isLandlinePhone: typeof isLandlinePhone;
+    isEmail: typeof isEmail;
+    isEmailStrict: typeof isEmailStrict;
+    isChineseIDCard: typeof isChineseIDCard;
+    isURL: typeof isURL;
+    validatePassword: typeof validatePassword;
+    isChineseName: typeof isChineseName;
+    isLicensePlate: typeof isLicensePlate;
+}
+
+/**
+ * 默认导出
+ */
+declare const validator: ValidatorModule;
+export default validator;

package/utils/base64.js

@@ -0,0 +1,18 @@
+// 编码字符串为 base64（支持中文）
+const encodeBase64 = (str) => {
+    return btoa(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, (match, p1) => {
+        return String.fromCharCode('0x' + p1);
+    }));
+}
+
+// 解码 base64 字符串
+const decodeBase64 = (str) => {
+    return decodeURIComponent(atob(str).split('').map(c => {
+        return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
+    }).join(''));
+}
+
+export default {
+    encodeBase64,
+    decodeBase64
+}

package/utils/dom.js

@@ -136,6 +136,355 @@ const safeHTML = (strings, ...values) => {
   return result;
 };
 
+
+
+/**
+ * 将富文本节点数组转换回 HTML 字符串
+ * @param {Array|Object} nodes - 富文本节点数组或单个节点
+ * @param {Object} options - 转换选项
+ * @returns {string} HTML 字符串
+ */
+function nodesToHtml(nodes, options = {}) {
+  const defaultOptions = {
+    escapeSpecialChars: false,
+    selfClosingTags: ['img', 'br', 'hr', 'input', 'meta', 'link', 'source'],
+    keepStyle: true,
+    keepClass: true,
+    restoreLinks: true, // 是否恢复链接为a标签
+    keepDataAttributes: true, // 是否保留data-属性
+  };
+
+  const mergedOptions = { ...defaultOptions, ...options };
+
+  // 处理节点数组
+  const nodeArray = Array.isArray(nodes) ? nodes : [nodes];
+
+  return nodeArray.map(node => processNode(node, mergedOptions)).join('');
+}
+
+/**
+ * 处理单个节点
+ * @param {Object} node - 节点对象
+ * @param {Object} options - 选项
+ * @returns {string} 处理后的HTML
+ */
+function processNode(node, options) {
+  if (!node) return '';
+
+  // 处理文本节点
+  if (node.type === 'text' || node.text !== undefined) {
+    const text = node.text || '';
+    return options.escapeSpecialChars ? escapeHtml(text) : text;
+  }
+
+  // 处理子节点为字符串的情况
+  if (typeof node.children === 'string') {
+    const content = options.escapeSpecialChars ? escapeHtml(node.children) : node.children;
+
+    // 如果没有标签名，直接返回内容
+    if (!node.name) {
+      return content;
+    }
+
+    const attrs = processAttributes(node.attrs || {}, options);
+
+    // 检查是否是链接节点，尝试恢复为a标签
+    if (options.restoreLinks && isLinkNode(node)) {
+      return restoreLinkNode(node, content);
+    }
+
+    return `<${node.name}${attrs}>${content}</${node.name}>`;
+  }
+
+  // 处理子节点数组
+  const tagName = node.name || 'div';
+  const attrs = processAttributes(node.attrs || {}, options);
+
+  // 处理子节点
+  let children = '';
+  if (node.children) {
+    if (Array.isArray(node.children)) {
+      children = node.children.map(child => processNode(child, options)).join('');
+    } else {
+      children = processNode(node.children, options);
+    }
+  }
+
+  // 检查是否是链接节点，尝试恢复为a标签
+  if (options.restoreLinks && isLinkNode(node)) {
+    return restoreLinkNode(node, children);
+  }
+
+  // 自闭合标签处理
+  if (options.selfClosingTags.includes(tagName.toLowerCase()) && !children.trim()) {
+    return `<${tagName}${attrs} />`;
+  }
+
+  return `<${tagName}${attrs}>${children}</${tagName}>`;
+}
+
+/**
+ * 处理属性
+ * @param {Object} attrs - 属性对象
+ * @param {Object} options - 选项
+ * @returns {string} 属性字符串
+ */
+function processAttributes(attrs, options) {
+  if (!attrs || Object.keys(attrs).length === 0) {
+    return '';
+  }
+
+  const processedAttrs = [];
+
+  for (const [name, value] of Object.entries(attrs)) {
+    // 跳过某些属性
+    if (!shouldKeepAttribute(name, value, options)) {
+      continue;
+    }
+
+    const attrValue = typeof value === 'string'
+      ? escapeHtmlAttribute(value)
+      : String(value);
+
+    processedAttrs.push(`${name}="${attrValue}"`);
+  }
+
+  return processedAttrs.length > 0 ? ' ' + processedAttrs.join(' ') : '';
+}
+
+/**
+ * 判断是否保留属性
+ * @param {string} name - 属性名
+ * @param {any} value - 属性值
+ * @param {Object} options - 选项
+ * @returns {boolean} 是否保留
+ */
+function shouldKeepAttribute(name, value, options) {
+  // 空值不处理
+  if (value === null || value === undefined || value === '') {
+    return false;
+  }
+
+  // 根据选项过滤样式和类名
+  if (name === 'style' && !options.keepStyle) {
+    return false;
+  }
+
+  if (name === 'class' && !options.keepClass) {
+    return false;
+  }
+
+  // 处理data-属性
+  if (name.startsWith('data-')) {
+    // 如果是链接节点的data属性，保留用于恢复链接
+    if (name === 'data-link-url' || name === 'data-link-id') {
+      return true;
+    }
+    // 其他data属性根据选项决定
+    return options.keepDataAttributes;
+  }
+
+  return true;
+}
+
+/**
+ * 判断是否是链接节点
+ * @param {Object} node - 节点对象
+ * @returns {boolean} 是否是链接节点
+ */
+function isLinkNode(node) {
+  return node.attrs && (
+    node.attrs['data-link-url'] ||
+    node.attrs.class && node.attrs.class.includes('im-parse-link')
+  );
+}
+
+/**
+ * 恢复链接节点为a标签
+ * @param {Object} node - 链接节点
+ * @param {string} content - 节点内容
+ * @returns {string} a标签HTML
+ */
+function restoreLinkNode(node, content) {
+  const attrs = node.attrs || {};
+  const url = attrs['data-link-url'];
+
+  if (!url) {
+    // 如果没有URL，返回原始节点
+    const originalAttrs = processAttributes(attrs, {});
+    return `<${node.name || 'span'}${originalAttrs}>${content}</${node.name || 'span'}>`;
+  }
+
+  // 解码URL
+  let decodedUrl;
+  try {
+    decodedUrl = decodeURIComponent(url);
+  } catch {
+    decodedUrl = url;
+  }
+
+  // 构建a标签属性
+  const linkAttrs = {
+    href: decodedUrl,
+    style: attrs.style || '',
+    class: attrs.class ? attrs.class.replace('im-parse-link', '').trim() : '',
+  };
+
+  const linkAttrStr = processAttributes(linkAttrs, {});
+
+  return `<a${linkAttrStr}>${content}</a>`;
+}
+
+/**
+ * 转义 HTML 特殊字符
+ * @param {string} text - 原始文本
+ * @returns {string} 转义后的文本
+ */
+function escapeHtml(text) {
+  const escapeMap = {
+    '&': '&amp;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#39;',
+    '`': '&#96;',
+  };
+
+  return text.replace(/[&<>"'`]/g, match => escapeMap[match] || match);
+}
+
+/**
+ * 转义 HTML 属性值中的特殊字符
+ * @param {string} text - 原始文本
+ * @returns {string} 转义后的文本
+ */
+function escapeHtmlAttribute(text) {
+  return text
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;')
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+}
+
+// /**
+//  * 专门用于 im-parse 组件的转换函数
+//  * @param {Array} parsedNodes - im-parse组件的parsedNodes
+//  * @param {string} originalContent - 原始HTML内容（可选）
+//  * @param {Object} options - 转换选项
+//  * @returns {string} HTML字符串
+//  */
+// function imParseNodesToHtml(parsedNodes, originalContent = '', options = {}) {
+//   try {
+//     // 默认选项
+//     const defaultOptions = {
+//       restoreLinks: true,
+//       keepStyle: false, // 通常不需要保留im-parse添加的内联样式
+//       keepClass: false, // 通常不需要保留im-parse添加的类名
+//       escapeSpecialChars: true,
+//     };
+
+//     const mergedOptions = { ...defaultOptions, ...options };
+
+//     // 转换为HTML
+//     const html = nodesToHtml(parsedNodes, mergedOptions);
+
+//     // 如果有原始内容，可以尝试更智能的恢复
+//     if (originalContent && mergedOptions.restoreLinks) {
+//       return smartRestoreLinks(html, originalContent);
+//     }
+
+//     return html;
+//   } catch (error) {
+//     console.error('转换回 HTML 失败:', error);
+//     return originalContent || '';
+//   }
+// }
+
+/**
+ * 智能恢复链接（基于原始内容）
+ * @param {string} html - 转换后的HTML
+ * @param {string} original - 原始HTML
+ * @returns {string} 恢复链接后的HTML
+ */
+function smartRestoreLinks(html, original) {
+  // 从原始内容中提取链接信息
+  const linkMatches = [];
+  const linkRegex = /<a\s+(?:[^>]*?\s+)?href=(["'])(.*?)\1[^>]*?>([\s\S]*?)<\/a>/gi;
+  let match;
+
+  while ((match = linkRegex.exec(original)) !== null) {
+    linkMatches.push({
+      url: match[2],
+      text: match[3],
+      fullMatch: match[0]
+    });
+  }
+
+  // 如果没有链接，直接返回
+  if (linkMatches.length === 0) {
+    return html;
+  }
+
+  // 尝试用正则替换恢复链接
+  let restoredHtml = html;
+
+  // 替换im-parse生成的链接占位符
+  linkMatches.forEach((link, index) => {
+    const placeholderRegex = new RegExp(
+      `<span[^>]*?data-link-url=["']${escapeRegExp(encodeURIComponent(link.url))}["'][^>]*?>([\\s\\S]*?)<\\/span>`,
+      'gi'
+    );
+
+    restoredHtml = restoredHtml.replace(placeholderRegex, () => {
+      return `<a href="${escapeHtml(link.url)}">${link.text}</a>`;
+    });
+  });
+
+  return restoredHtml;
+}
+
+/**
+ * 转义正则表达式特殊字符
+ * @param {string} string - 原始字符串
+ * @returns {string} 转义后的字符串
+ */
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * 从im-parse节点中提取纯文本
+ * @param {Array|Object} nodes - 节点数组或单个节点
+ * @returns {string} 纯文本
+ */
+function extractPlainText(nodes) {
+  if (!nodes) return '';
+
+  const nodeArray = Array.isArray(nodes) ? nodes : [nodes];
+
+  return nodeArray.map(node => {
+    if (node.type === 'text' || node.text !== undefined) {
+      return node.text || '';
+    }
+
+    if (typeof node.children === 'string') {
+      return node.children;
+    }
+
+    if (node.children) {
+      if (Array.isArray(node.children)) {
+        return extractPlainText(node.children);
+      }
+      return extractPlainText(node.children);
+    }
+
+    return '';
+  }).join('');
+}
+
+
+
 export default {
   html2Escape,
   htmlEscape,
@@ -144,5 +493,8 @@ export default {
   escapeTextContent,
   hasHtmlSpecialChars,
   setSafeHTML,
-  safeHTML
+  safeHTML,
+  nodesToHtml,
+  extractPlainText,
+  escapeHtml,
 };

package/utils/enums.js

@@ -8,9 +8,8 @@ export const MESSAGE_TYPE = {
   AUDIO: 3,
   VIDEO: 4,
   RECALL: 10,
-  READED: 11,
+  READ: 11,
   RECEIPT: 12,
-  TIP_TIME: 20,
   TIP_TEXT: 21,
   LOADING: 30,
   ACT_RT_VOICE: 40,
@@ -69,8 +68,8 @@ export const TERMINAL_TYPE = {
 export const MESSAGE_STATUS = {
   FAILED: -2, // 发送失败
   SENDING: -1, // 发送中(消息没到服务器)
-  PENDING: 0, // 未送达(消息已到服务器，但对方没收到)
-  DELIVERED: 1, // 已送达(对方已收到，但是未读消息)
+  SENT: 0, // 未送达(消息已到服务器，但对方没收到)
+  RECEIVED: 1, // 已送达(对方已收到，但是未读消息)
   RECALL: 2, // 已撤回
-  READED: 3, // 消息已读
+  READ: 3, // 消息已读
 };