zsl-im-sdk 1.0.0 → 1.0.2

package/dist/types/message-type.type.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageStatus = exports.MessageTypeData = exports.MessageType = void 0;
+// 消息类型枚举
+var MessageType;
+(function (MessageType) {
+    MessageType["TEXT"] = "TEXT";
+    MessageType["IMAGE"] = "IMAGE";
+    MessageType["VIDEO"] = "VIDEO";
+    MessageType["CUSTOM"] = "CUSTOM";
+    MessageType["TEXT_QUOTE"] = "TEXT_QUOTE";
+    MessageType["AUDIO"] = "AUDIO";
+    MessageType["IMAGE_TRANSMIT"] = "IMAGE_TRANSMIT";
+    MessageType["EMOJI_PACK"] = "EMOJI_PACK";
+    MessageType["RED_ENVELOPE"] = "RED_ENVELOPE";
+    MessageType["MAP"] = "MAP";
+    MessageType["GROUP_NOTICE"] = "GROUP_NOTICE";
+    MessageType["UPDATE_GROUP_NAME"] = "UPDATE_GROUP_NAME";
+    MessageType["ARTICLE"] = "ARTICLE";
+    MessageType["SHARE_SBCF"] = "SHARE_SBCF";
+    MessageType["SHARE_MALL"] = "SHARE_MALL";
+})(MessageType || (exports.MessageType = MessageType = {}));
+// 消息类型枚举
+exports.MessageTypeData = {
+    TEXT: "TEXT",
+    IMAGE: "IMAGE",
+    VIDEO: "VIDEO",
+    CUSTOM: "CUSTOM",
+    TEXT_QUOTE: "TEXT_QUOTE",
+    AUDIO: "AUDIO",
+    IMAGE_TRANSMIT: "IMAGE_TRANSMIT",
+    EMOJI_PACK: "EMOJI_PACK",
+    RED_ENVELOPE: "RED_ENVELOPE",
+    MAP: "MAP",
+    GROUP_NOTICE: "GROUP_NOTICE",
+    UPDATE_GROUP_NAME: "UPDATE_GROUP_NAME",
+    ARTICLE: "ARTICLE",
+    SHARE_SBCF: "SHARE_SBCF",
+    SHARE_MALL: "SHARE_MALL",
+};
+// 消息状态枚举
+var MessageStatus;
+(function (MessageStatus) {
+    MessageStatus["SENT"] = "SENT";
+    MessageStatus["DELIVERED"] = "DELIVERED";
+    MessageStatus["READ"] = "READ";
+    MessageStatus["RECALLED"] = "RECALLED";
+})(MessageStatus || (exports.MessageStatus = MessageStatus = {}));

package/dist/types/socket-data.type.d.ts

@@ -0,0 +1,38 @@
+import { MessageType } from './message-type.type';
+export declare enum SocketAction {
+    SEND_MESSAGE = "SEND_MESSAGE",
+    READ_RECEIPT = "READ_RECEIPT",
+    RECALL_MESSAGE = "RECALL_MESSAGE",
+    PING = "PING",
+    PONG = "PONG",
+    ACK = "ACK",
+    MESSAGE = "MESSAGE",
+    DELIVERED = "DELIVERED",
+    RECALLED = "RECALLED",
+    ERROR = "ERROR"
+}
+export interface ISendMessage {
+    id?: string | number;
+    conversationId?: string;
+    senderId?: string | number;
+    recipientId?: string | number;
+    messageType?: MessageType;
+    content?: string;
+    mediaUrl?: string;
+    metadata?: string;
+    time?: string;
+}
+export interface IReadReceipt {
+    conversationId?: string;
+    lastReadMessageId?: number;
+}
+export interface IRecalledMessage {
+    messageId?: number;
+}
+export interface IPing {
+}
+export type Payload = ISendMessage | IReadReceipt | IRecalledMessage | IPing;
+export interface SocketData<T = Payload> {
+    action: SocketAction;
+    payload: T;
+}

package/dist/types/socket-data.type.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketAction = void 0;
+// SocketAction枚举
+var SocketAction;
+(function (SocketAction) {
+    // client -> server
+    SocketAction["SEND_MESSAGE"] = "SEND_MESSAGE";
+    SocketAction["READ_RECEIPT"] = "READ_RECEIPT";
+    SocketAction["RECALL_MESSAGE"] = "RECALL_MESSAGE";
+    SocketAction["PING"] = "PING";
+    SocketAction["PONG"] = "PONG";
+    // server -> client
+    SocketAction["ACK"] = "ACK";
+    SocketAction["MESSAGE"] = "MESSAGE";
+    SocketAction["DELIVERED"] = "DELIVERED";
+    SocketAction["RECALLED"] = "RECALLED";
+    SocketAction["ERROR"] = "ERROR";
+})(SocketAction || (exports.SocketAction = SocketAction = {}));

package/dist/types.d.ts

@@ -0,0 +1,62 @@
+/**
+ * SDK 核心类型定义
+ */
+/** 消息类型 */
+export interface IMessage {
+    id: string;
+    conversationId: string;
+    content: string;
+    messageType: string;
+    senderId: string | number;
+    createdAt: string;
+    status: 'SENDING' | 'SENT' | 'FAILED';
+    icon?: string;
+    recipientId?: string;
+    mediaUrl?: string;
+}
+/** 用户类型 */
+export interface IUser {
+    id: string | number;
+    name: string;
+    avatar?: string;
+}
+/** 会话类型 */
+export interface IConversation {
+    conversationId: string;
+    conversationType: 'P2P' | 'GROUP';
+    lastMessageAt: string;
+    lastMessageContent: string;
+    lastMessageType: string;
+    unreadCount: number;
+    user: {
+        userId: string | number;
+        displayName: string;
+        account: string;
+        avatarUrl: string;
+    };
+    [key: string]: any;
+}
+/** Store 状态类型 */
+export interface IState {
+    conversation: {
+        conversations: IConversation[];
+        selectedConversationId: string;
+    };
+    message: {
+        messages: Record<string, IMessage[]>;
+        messageQueue: IMessage[];
+    };
+    user: {
+        currentUser: IUser | null;
+        users: Record<string | number, IUser>;
+    };
+    websocket: {
+        isConnected: boolean;
+        reconnectAttempts: number;
+        imInstance: any;
+    };
+    global: {
+        loading: boolean;
+        error: string | null;
+    };
+}

package/dist/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * SDK 核心类型定义
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/http.d.ts

@@ -0,0 +1,41 @@
+type Method = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'OPTIONS';
+export interface IResponse<T = any> {
+    data: T;
+    message?: string;
+    msg?: string;
+    success: boolean;
+    code?: number;
+}
+export interface HttpConfig {
+    baseURL?: string;
+    timeout?: number;
+    headers?: Record<string, string>;
+    beforeRequest?: (options: any) => void;
+    afterResponse?: (response: any, options: any) => any;
+}
+export declare class HttpError extends Error {
+    code: number | string;
+    constructor(code: number | string, message: string);
+}
+export declare class HttpClient {
+    private baseURL;
+    private timeout;
+    private headers;
+    private beforeRequest?;
+    private afterResponse?;
+    constructor(config?: HttpConfig);
+    setBaseURL(url: string): void;
+    setHeaders(headers: Record<string, string>): void;
+    setBeforeRequest(callback: (options: any) => void): void;
+    setAfterResponse(callback: (response: any, options: any) => any): void;
+    request<T = any>(method: Method, url: string, data?: any, options?: any): Promise<T>;
+    get<T = any>(url: string, params?: any, options?: any): Promise<T>;
+    post<T = any>(url: string, data?: any, options?: any): Promise<T>;
+    put<T = any>(url: string, data?: any, options?: any): Promise<T>;
+    delete<T = any>(url: string, data?: any, options?: any): Promise<T>;
+    upload<T = any>(url: string, filePath: string, name: string, formData?: Record<string, any>, options?: any): Promise<T>;
+    download(url: string, options?: any): Promise<string>;
+}
+declare const http: HttpClient;
+export declare const setBaseURL: (url: string) => void;
+export default http;

package/dist/utils/http.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setBaseURL = exports.HttpClient = exports.HttpError = void 0;
+// HTTP错误类
+class HttpError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'HttpError';
+    }
+}
+exports.HttpError = HttpError;
+// HTTP客户端类
+class HttpClient {
+    constructor(config = {}) {
+        this.baseURL = config.baseURL || '';
+        this.timeout = config.timeout || 60000;
+        this.headers = {
+            'Content-Type': 'application/json',
+            ...config.headers
+        };
+        this.beforeRequest = config.beforeRequest;
+        this.afterResponse = config.afterResponse;
+    }
+    // 设置基础URL
+    setBaseURL(url) {
+        this.baseURL = url;
+    }
+    // 设置默认headers
+    setHeaders(headers) {
+        this.headers = { ...this.headers, ...headers };
+    }
+    // 添加请求拦截器
+    setBeforeRequest(callback) {
+        this.beforeRequest = callback;
+    }
+    // 添加响应拦截器
+    setAfterResponse(callback) {
+        this.afterResponse = callback;
+    }
+    // 发送请求
+    request(method, url, data, options = {}) {
+        return new Promise((resolve, reject) => {
+            // 构建请求选项
+            const requestOptions = {
+                url: this.baseURL + url,
+                method,
+                data,
+                header: { ...this.headers, ...options.header },
+                timeout: options.timeout || this.timeout,
+                success: (response) => {
+                    try {
+                        // 处理响应拦截器
+                        const processedResponse = this.afterResponse ? this.afterResponse(response, requestOptions) : response.data;
+                        resolve(processedResponse);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                },
+                fail: (error) => {
+                    reject(new HttpError(error.errMsg, '网络请求失败'));
+                }
+            };
+            // 处理请求拦截器
+            if (this.beforeRequest) {
+                this.beforeRequest(requestOptions);
+            }
+            // 发送请求
+            uni.request(requestOptions);
+        });
+    }
+    // GET请求
+    get(url, params, options) {
+        return this.request('GET', url, params, options);
+    }
+    // POST请求
+    post(url, data, options) {
+        return this.request('POST', url, data, options);
+    }
+    // PUT请求
+    put(url, data, options) {
+        return this.request('PUT', url, data, options);
+    }
+    // DELETE请求
+    delete(url, data, options) {
+        return this.request('DELETE', url, data, options);
+    }
+    // 文件上传
+    upload(url, filePath, name, formData, options = {}) {
+        return new Promise((resolve, reject) => {
+            const uploadOptions = {
+                url: this.baseURL + url,
+                filePath,
+                name,
+                formData,
+                header: { ...this.headers, ...options.header },
+                success: (response) => {
+                    try {
+                        const data = typeof response.data === 'string' ? JSON.parse(response.data) : response.data;
+                        resolve(data);
+                    }
+                    catch (error) {
+                        reject(new HttpError('PARSE_ERROR', '响应数据解析失败'));
+                    }
+                },
+                fail: (error) => {
+                    reject(new HttpError(error.errMsg, '文件上传失败'));
+                }
+            };
+            uni.uploadFile(uploadOptions);
+        });
+    }
+    // 文件下载
+    download(url, options = {}) {
+        return new Promise((resolve, reject) => {
+            const downloadOptions = {
+                url: this.baseURL + url,
+                header: { ...this.headers, ...options.header },
+                success: (response) => {
+                    resolve(response.tempFilePath);
+                },
+                fail: (error) => {
+                    reject(new HttpError(error.errMsg, '文件下载失败'));
+                }
+            };
+            uni.downloadFile(downloadOptions);
+        });
+    }
+}
+exports.HttpClient = HttpClient;
+// 创建默认HTTP客户端
+// 移除默认配置的baseURL，改为支持动态设置
+const http = new HttpClient({
+    headers: {
+        'Content-Type': 'application/json'
+    },
+    afterResponse: (response) => {
+        try {
+            // debugger;
+            const data = typeof response.data === 'string' ? JSON.parse(response.data) : response.data;
+            if (data.success === false) {
+                throw new HttpError(data.code || 'ERROR', data.message || data.msg || '请求失败');
+            }
+            return data.data || data;
+        }
+        catch (error) {
+            // 如果响应不是JSON格式，返回原始数据
+            console.error('HTTP响应解析失败:', error);
+            throw new HttpError('PARSE_ERROR', '响应数据格式不正确');
+        }
+    }
+});
+// 导出设置BaseURL的方法
+const setBaseURL = (url) => {
+    http.setBaseURL(url);
+};
+exports.setBaseURL = setBaseURL;
+exports.default = http;

package/dist/websocket.d.ts

@@ -0,0 +1,46 @@
+export * from "./types";
+import { MessageType, SocketData } from "./types/index";
+export type EventType = "message" | "connect" | "disconnect" | "error" | "reconnect" | "recalled";
+export type EventCallback<T = any> = (data: T) => void;
+export interface IMOptions {
+    url: string;
+    token: string;
+    userId: string | number;
+    maxReconnectCount?: number;
+    reconnectInterval?: number;
+    heartbeatInterval?: number;
+}
+export default class IM {
+    private ws;
+    private url;
+    private token;
+    private userId;
+    private isConnected;
+    private reconnectTimer;
+    private reconnectCount;
+    private maxReconnectCount;
+    private reconnectInterval;
+    private messageQueue;
+    private listeners;
+    private heartbeatTimer;
+    private heartbeatInterval;
+    constructor(options: IMOptions);
+    private getWsUrl;
+    connect(): Promise<void>;
+    disconnect(): void;
+    private handleReconnect;
+    private handleMessage;
+    send(data: SocketData): Promise<void>;
+    sendText(conversationId: string, recipientId: string | number, content: string, messageType: MessageType, mediaUrl: string | undefined): Promise<void>;
+    sendReadReceipt(conversationId: string, lastReadMessageId?: number): Promise<void>;
+    sendRecallMessage(messageId: number): Promise<void>;
+    private sendPingPong;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private flushMessageQueue;
+    private getCurrentTime;
+    on<T = any>(event: EventType, callback: EventCallback<T>): void;
+    off<T = any>(event: EventType, callback: EventCallback<T>): void;
+    private emit;
+    getConnectionStatus(): boolean;
+}