vanshi-sdk 1.0.4

package/dist/index.mjs

@@ -0,0 +1,983 @@
+// src/plugins/socketio/client.ts
+import io from "socket.io-client";
+
+// src/sdk/runtime.ts
+var SDK_TOKEN_KEY = "VanshiSdk_Token";
+var SDK_LOGIN_KEY = "VanshiSdk_isLogin";
+function getBrowserStorage() {
+  if (typeof localStorage === "undefined") {
+    return void 0;
+  }
+  return localStorage;
+}
+var SdkRuntimeError = class extends Error {
+  constructor(result) {
+    super(result.message || `SDK request failed${result.code !== void 0 ? `: ${String(result.code)}` : ""}`);
+    this.name = "SdkRuntimeError";
+    this.code = result.code;
+    this.data = result.data;
+    this.raw = result.raw;
+    this.parsed = result.parsed;
+  }
+};
+function parseJsonSafely(value) {
+  if (value == null) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    return value;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+function isSuccessCode(code) {
+  return code === 0 || code === "0" || code === true;
+}
+function toSdkEnvelope(response) {
+  if (response && typeof response === "object") {
+    return response;
+  }
+  return {};
+}
+function unwrapSdkData(response) {
+  const result = unwrapSdkDetailedData(response);
+  if (!result.success) {
+    throw new SdkRuntimeError(result);
+  }
+  return result.data;
+}
+function unwrapSdkResponse(response) {
+  const envelope = toSdkEnvelope(response);
+  const parsed = parseJsonSafely(envelope.data);
+  if (parsed && typeof parsed === "object" && "code" in parsed) {
+    return parsed;
+  }
+  return {
+    code: envelope.code,
+    message: envelope.message,
+    data: parsed !== void 0 ? parsed : envelope.data
+  };
+}
+function unwrapSdkDetailedData(response) {
+  const envelope = toSdkEnvelope(response);
+  const parsed = parseJsonSafely(envelope.data);
+  if (parsed && typeof parsed === "object" && "code" in parsed) {
+    const success = isSuccessCode(parsed.code);
+    return {
+      success,
+      code: parsed.code,
+      message: parsed.message || envelope.message,
+      data: parsed.data,
+      raw: response,
+      parsed
+    };
+  }
+  if (envelope.code !== void 0 || envelope.message !== void 0) {
+    return {
+      success: isSuccessCode(envelope.code),
+      code: envelope.code,
+      message: envelope.message,
+      data: parsed !== void 0 ? parsed : envelope.data,
+      raw: response,
+      parsed
+    };
+  }
+  return {
+    success: true,
+    data: parsed !== void 0 ? parsed : envelope.data,
+    raw: response,
+    parsed
+  };
+}
+function getStoredToken() {
+  return getBrowserStorage()?.getItem(SDK_TOKEN_KEY) || "";
+}
+function setSdkSession(token) {
+  const storage = getBrowserStorage();
+  if (!storage) {
+    return;
+  }
+  storage.setItem(SDK_TOKEN_KEY, token);
+  storage.setItem(SDK_LOGIN_KEY, "true");
+}
+function clearSdkSession() {
+  const storage = getBrowserStorage();
+  if (!storage) {
+    return;
+  }
+  storage.removeItem(SDK_TOKEN_KEY);
+  storage.removeItem(SDK_LOGIN_KEY);
+}
+function getSocketUrl() {
+  const globalUrl = typeof window !== "undefined" ? window.__VANSHI_SOCKET_URL : void 0;
+  return globalUrl || "wss://ws-vanshi-chat-sdk.xchatclub.com";
+}
+function getUploadUrl() {
+  const globalHttpUrl = typeof window !== "undefined" ? window.__VANSHI_HTTP_URL : void 0;
+  return globalHttpUrl || "https://vanshi-chat-api.xchatclub.com/api/files/sdkUpload";
+}
+
+// src/sdk/session.ts
+var reconnectLoginHandler = null;
+function registerReconnectLoginHandler(handler) {
+  reconnectLoginHandler = handler;
+}
+async function restoreSessionAfterReconnect() {
+  if (!reconnectLoginHandler) {
+    return false;
+  }
+  const token = getStoredToken();
+  if (!token) {
+    return false;
+  }
+  try {
+    return await reconnectLoginHandler(token);
+  } catch {
+    return false;
+  }
+}
+function clearSessionState() {
+  clearSdkSession();
+}
+
+// src/plugins/socketio/client.ts
+function parseSocketConnectErrorPayload(value) {
+  if (!value) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value);
+      if (parsed && typeof parsed === "object") {
+        return parsed;
+      }
+    } catch {
+      return void 0;
+    }
+  }
+  if (typeof value === "object") {
+    return value;
+  }
+  return void 0;
+}
+function normalizeSocketConnectError(error) {
+  const rawMessage = error && typeof error === "object" && "message" in error ? error.message : void 0;
+  const rawData = error && typeof error === "object" && "data" in error ? error.data : void 0;
+  const payload = parseSocketConnectErrorPayload(rawData) || parseSocketConnectErrorPayload(rawMessage);
+  const normalized = new Error(
+    payload?.message || (typeof rawMessage === "string" ? rawMessage : "") || "socket connect failed"
+  );
+  normalized.name = "SocketConnectError";
+  normalized.code = payload?.code;
+  normalized.data = payload;
+  normalized.requestId = payload?.requestId;
+  normalized.raw = error;
+  return normalized;
+}
+var SocketClient = class {
+  constructor() {
+    this.pending = /* @__PURE__ */ new Map();
+    this.emitQueue = [];
+    this.connectPromise = null;
+    this.url = "";
+    this.handleResponse = (res) => {
+      const entry = this.pending.get(res.id);
+      if (!entry)
+        return;
+      clearTimeout(entry.timer);
+      this.pending.delete(res.id);
+      res.error ? entry.reject(res.error) : entry.resolve(res.payload);
+    };
+  }
+  connect(url, auth, opts = {}) {
+    if (this.connectPromise)
+      return this.connectPromise;
+    if (this.isConnected())
+      return Promise.resolve();
+    if (this.socket) {
+      try {
+        this.socket.off();
+        this.socket.io.off();
+        this.socket = void 0;
+      } catch {
+      }
+    }
+    if (this.isConnected())
+      return Promise.resolve();
+    const { baseUrl, namespace } = this.parseUrl(url);
+    this.url = url;
+    const ioOpts = {
+      ...opts,
+      transports: ["websocket"],
+      // 🔥 只保留 websocket，不会多条连接
+      query: { namespace },
+      forceNew: true,
+      reconnection: true,
+      reconnectionAttempts: 9999,
+      reconnectionDelay: 1e4,
+      timeout: 15e3
+    };
+    this.connectPromise = new Promise((resolve, reject) => {
+      const socket = io(`${baseUrl}/im/user`, ioOpts);
+      this.socket = socket;
+      console.log("[SocketClient] \u65B0\u8FDE\u63A5\u521B\u5EFA\uFF1A", `${baseUrl}/im/user`);
+      const handleConnect = () => {
+        socket.off("connect_error", handleError);
+        socket.on("api:response", this.handleResponse);
+        this.processEmitQueue();
+        resolve();
+      };
+      const handleError = (err) => {
+        const normalizedError = normalizeSocketConnectError(err);
+        console.error("[SocketClient] \u8FDE\u63A5\u5931\u8D25\uFF1A:", normalizedError);
+        socket.off("connect", handleConnect);
+        reject(normalizedError);
+      };
+      socket.once("connect", handleConnect);
+      socket.once("connect_error", handleError);
+      socket.on("disconnect", (reason) => {
+        this.cleanupAllPending("disconnected: " + reason);
+        this.connectPromise = null;
+      });
+      socket.io.off("reconnect");
+      socket.io.on("reconnect", async () => {
+        console.log("[SocketClient] \u91CD\u8FDE\u6210\u529F \u2192 \u7B49\u5F85 socket \u5B8C\u5168\u5C31\u7EEA", this.socket?.connected);
+        await new Promise(
+          (resolveReconnect) => setTimeout(resolveReconnect, 200)
+        );
+        if (!this.isConnected() || !this.socket) {
+          console.log("[SocketClient] socket \u672A\u5C31\u7EEA\uFF0C\u8DF3\u8FC7\u767B\u5F55");
+          return;
+        }
+        try {
+          console.log("[SocketClient] \u5F00\u59CB\u81EA\u52A8\u767B\u5F55 \u2705");
+          const res = await restoreSessionAfterReconnect();
+          if (res) {
+            this.processEmitQueue();
+          } else {
+            clearSessionState();
+          }
+        } catch (err) {
+          console.error("[SocketClient] \u81EA\u52A8\u767B\u5F55\u5931\u8D25", err);
+          clearSessionState();
+        }
+      });
+    });
+    this.connectPromise.finally(() => {
+      this.connectPromise = null;
+    });
+    return this.connectPromise;
+  }
+  disconnect() {
+    if (!this.socket)
+      return;
+    try {
+      this.socket.off("api:response", this.handleResponse);
+      this.socket.io.off("reconnect");
+      this.socket.disconnect();
+    } catch {
+    }
+    this.socket = void 0;
+    this.cleanupAllPending("client disconnected");
+  }
+  emitWithAck(event, payload, timeoutMs = 1e4) {
+    if (this.isConnected()) {
+      return this.createEmitPromise(event, payload, timeoutMs);
+    }
+    if (this.connectPromise) {
+      return new Promise((resolve, reject) => {
+        this.emitQueue.push({ event, payload, timeoutMs, resolve, reject });
+      });
+    }
+    return Promise.reject(new Error("socket not initialized"));
+  }
+  request(path, payload, timeoutMs = 1e4) {
+    if (!this.socket) {
+      return Promise.reject(new Error("socket not initialized"));
+    }
+    const id = this.generateId();
+    const envelope = { id, path, payload };
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error("request timeout"));
+      }, timeoutMs);
+      this.pending.set(id, { resolve, reject, timer });
+      try {
+        this.socket.emit("api:request", envelope);
+      } catch (err) {
+        clearTimeout(timer);
+        this.pending.delete(id);
+        reject(err);
+      }
+    });
+  }
+  on(event, handler) {
+    this.socket?.on(event, handler);
+  }
+  off(event, handler) {
+    if (!this.socket)
+      return;
+    handler ? this.socket.off(event, handler) : this.socket.off(event);
+  }
+  isConnected() {
+    return !!this.socket?.connected;
+  }
+  parseUrl(url) {
+    let baseUrl = url;
+    let namespace = "/im/user";
+    try {
+      const urlObj = new URL(url);
+      const queryNs = urlObj.searchParams.get("namespace");
+      if (queryNs)
+        namespace = queryNs;
+      baseUrl = urlObj.origin + urlObj.pathname.replace(/\/$/, "");
+    } catch {
+      console.warn("[Socket] URL parse failed:", url);
+    }
+    return { baseUrl, namespace };
+  }
+  generateId() {
+    return Date.now().toString(36) + Math.random().toString(36).slice(2, 9);
+  }
+  createEmitPromise(event, payload, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      let timedOut = false;
+      const timer = setTimeout(() => {
+        timedOut = true;
+        reject(new Error("ack timeout"));
+      }, timeoutMs);
+      try {
+        this.socket.emit(event, payload, (response) => {
+          if (timedOut)
+            return;
+          clearTimeout(timer);
+          if (response?.code !== void 0) {
+            isSuccessCode(response.code) ? resolve(response) : reject(new Error(response.message || `code=${response.code}`));
+          } else {
+            resolve(response);
+          }
+        });
+      } catch (err) {
+        clearTimeout(timer);
+        reject(err);
+      }
+    });
+  }
+  processEmitQueue() {
+    if (!this.isConnected())
+      return;
+    while (this.emitQueue.length) {
+      const item = this.emitQueue.shift();
+      this.createEmitPromise(item.event, item.payload, item.timeoutMs).then(item.resolve).catch(item.reject);
+    }
+  }
+  cleanupAllPending(reason) {
+    for (const [, entry] of this.pending) {
+      clearTimeout(entry.timer);
+      entry.reject(new Error(reason));
+    }
+    this.pending.clear();
+    for (const item of this.emitQueue) {
+      item.reject(new Error(reason));
+    }
+    this.emitQueue = [];
+  }
+};
+var socketClient = new SocketClient();
+var client_default = socketClient;
+
+// src/plugins/request/index.ts
+async function request(config) {
+  if (!config || !config.path) {
+    return Promise.reject(new Error("invalid request config"));
+  }
+  const path = config.path;
+  const isSdkApi = path.startsWith("/sdk/") || path.startsWith("sdk/");
+  if (isSdkApi) {
+    const eventName = path.replace(/^\/?sdk\//, "");
+    const timeoutMs2 = typeof config.timeoutMs === "number" ? config.timeoutMs : 1e4;
+    if (!client_default.isConnected()) {
+      return Promise.reject(new Error("socket not connected"));
+    }
+    try {
+      const res = await client_default.emitWithAck(
+        eventName,
+        config.data,
+        timeoutMs2
+      );
+      if (res && typeof res === "object" && typeof res.code === "number") {
+        return res;
+      }
+      return { code: 0, message: "", data: res };
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  }
+  if (!client_default.isConnected()) {
+    return Promise.reject(new Error("socket not connected"));
+  }
+  const timeoutMs = typeof config.timeoutMs === "number" ? config.timeoutMs : 1e4;
+  return client_default.request(config.path, config.data, timeoutMs);
+}
+
+// src/apis/SdkQueryConversationPostApi.ts
+var postSdkQueryConversationApiRequest = (data) => {
+  return request({
+    path: "/sdk/queryConversation",
+    method: "POST",
+    data
+  });
+};
+
+// src/apis/SdkDeleteAllConversationsPostApi.ts
+var postSdkDeleteAllConversationsApiRequest = (data) => {
+  return request({
+    path: "/sdk/deleteAllConversations",
+    method: "POST",
+    data
+  });
+};
+
+// src/apis/SdkDeleteConversationPostApi.ts
+var postSdkDeleteConversationApiRequest = (data) => {
+  return request({
+    path: "/sdk/deleteConversation",
+    method: "POST",
+    data
+  });
+};
+
+// src/apis/SdkClearConversationTotalUnreadMessageCountPostApi.ts
+var postSdkClearConversationTotalUnreadMessageCountApiRequest = (data) => {
+  return request({
+    path: "/sdk/clearConversationTotalUnreadMessageCount",
+    method: "POST",
+    data
+  });
+};
+
+// src/apis/SdkClearConversationUnreadMessageCountPostApi.ts
+var postSdkClearConversationUnreadMessageCountApiRequest = (data) => {
+  return request({
+    path: "/sdk/clearConversationUnreadMessageCount",
+    method: "POST",
+    data
+  });
+};
+
+// src/sdk/conversation.ts
+async function queryConversation(payload) {
+  const response = await postSdkQueryConversationApiRequest(payload);
+  return unwrapSdkData(response) ?? [];
+}
+async function deleteAllConversations() {
+  const response = await postSdkDeleteAllConversationsApiRequest(
+    { config: true }
+  );
+  return unwrapSdkResponse(response);
+}
+async function deleteConversation(payload) {
+  const response = await postSdkDeleteConversationApiRequest(payload);
+  return unwrapSdkResponse(response);
+}
+async function clearConversationTotalUnreadMessageCount() {
+  const response = await postSdkClearConversationTotalUnreadMessageCountApiRequest(
+    {}
+  );
+  return unwrapSdkResponse(response);
+}
+async function clearConversationUnreadMessageCount(conversationID, conversationType) {
+  const response = await postSdkClearConversationUnreadMessageCountApiRequest(
+    {
+      conversationID,
+      conversationType: String(conversationType)
+    }
+  );
+  return unwrapSdkResponse(response);
+}
+
+// src/sdk/initSocket.ts
+async function initSocket() {
+  const baseUrl = getSocketUrl();
+  if (!client_default.isConnected()) {
+    await client_default.connect(baseUrl);
+  }
+}
+function isSocketConnected() {
+  return client_default.isConnected();
+}
+function on(event, handler) {
+  client_default.on(event, handler);
+}
+function off(event, handler) {
+  client_default.off(event, handler);
+}
+
+// src/apis/SdkLoginPostApi.ts
+var postSdkLoginApiRequest = (data) => {
+  return request({
+    path: "/sdk/login",
+    method: "POST",
+    data
+  });
+};
+var postSdkLogoutApiRequest = (data) => {
+  return request({
+    path: "/sdk/logout",
+    method: "POST",
+    data
+  });
+};
+
+// src/sdk/loginCore.ts
+async function performLogin(payload, { requestLogin, setSession = setSdkSession, clearSession = clearSdkSession }) {
+  try {
+    const resp = await requestLogin(payload);
+    if (unwrapSdkData(resp)) {
+      setSession(payload.token);
+      return true;
+    }
+  } catch (error) {
+    clearSession();
+    throw error;
+  }
+  clearSession();
+  return false;
+}
+
+// src/sdk/login.ts
+async function login(payload) {
+  return performLogin(payload, {
+    requestLogin: postSdkLoginApiRequest
+  });
+}
+registerReconnectLoginHandler((token) => login({ token }));
+async function logout(disconnect = true) {
+  let success = false;
+  try {
+    const resp = await postSdkLogoutApiRequest(
+      {}
+    );
+    let res = JSON.parse(resp);
+    const result = unwrapSdkData(res);
+    success = Boolean(result) || isSuccessCode(res.code);
+  } catch {
+    success = false;
+  } finally {
+    clearSdkSession();
+  }
+  return success;
+}
+
+// src/apis/SdkSendMessagePostApi.ts
+var postSdkSendMessageApiRequest = (data) => {
+  return request({
+    path: "/sdk/sendMessage",
+    method: "POST",
+    data
+  });
+};
+
+// src/apis/SdkSendMediaMessagePostApi.ts
+var postSdkSendMediaMessageApiRequest = (data) => {
+  return request({
+    path: "/sdk/sendMediaMessage",
+    method: "POST",
+    data
+  });
+};
+
+// src/apis/SdkQueryHistoryMessagePostApi.ts
+var postSdkQueryHistoryMessageApiRequest = (data) => {
+  return request({
+    path: "/sdk/queryHistoryMessage",
+    method: "POST",
+    data
+  });
+};
+
+// src/apis/SdkDeleteAllConversationMessagesPostApi.ts
+var postSdkDeleteAllConversationMessagesApiRequest = (data) => {
+  return request({
+    path: "/sdk/deleteAllConversationMessages",
+    method: "POST",
+    data
+  });
+};
+
+// src/apis/SdkDeleteMessagesPostApi.ts
+var postSdkDeleteMessagesApiRequest = (data) => {
+  return request({
+    path: "/sdk/deleteMessages",
+    method: "POST",
+    data
+  });
+};
+
+// src/apis/SdkRevokeMessagePostApi.ts
+var postSdkRevokeMessageApiRequest = (data) => {
+  return request({
+    path: "/sdk/revokeMessage",
+    method: "POST",
+    data
+  });
+};
+
+// helper/index.ts
+function isSameUid(id, uid) {
+  return id?.toString() === uid?.toString();
+}
+var getVideoDurationAndFirstFrame = (file) => {
+  return new Promise((resolve, reject) => {
+    const video = document.createElement("video");
+    const canvas = document.createElement("canvas");
+    const ctx = canvas.getContext("2d");
+    let duration = 0;
+    let videoWidth = 0;
+    let videoHeight = 0;
+    video.preload = "metadata";
+    video.muted = true;
+    video.playsInline = true;
+    video.autoplay = true;
+    video.onloadedmetadata = () => {
+      canvas.width = video.videoWidth || 640;
+      canvas.height = video.videoHeight || 360;
+      window.URL.revokeObjectURL(video.src);
+      duration = video?.duration;
+      videoWidth = video.videoWidth || 640;
+      videoHeight = video.videoHeight || 360;
+    };
+    video.oncanplay = () => {
+      video.oncanplay = null;
+      video.pause();
+      ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+      canvas.toBlob(
+        (blob) => {
+          if (!blob) {
+            reject(new Error("\u622A\u53D6\u7B2C\u4E00\u5E27\u5931\u8D25"));
+            return;
+          }
+          const firstFrameFile = new File(
+            [blob],
+            `video_first_frame_${Date.now()}.jpg`,
+            { type: "image/jpeg" }
+          );
+          URL.revokeObjectURL(video.src);
+          video.src = "";
+          canvas.width = 0;
+          canvas.height = 0;
+          resolve({
+            duration,
+            firstFrameFile,
+            // 这就是你要的文件流
+            videoWidth,
+            videoHeight
+          });
+        },
+        "image/jpeg",
+        0.9
+        // 图片质量 0-1
+      );
+    };
+    video.onerror = () => {
+      URL.revokeObjectURL(video.src);
+      reject(new Error("\u89C6\u9891\u6587\u4EF6\u635F\u574F\u6216\u683C\u5F0F\u4E0D\u652F\u6301"));
+    };
+    video.src = URL.createObjectURL(file);
+  });
+};
+function getAudioDuration(file) {
+  return new Promise((resolve, reject) => {
+    const audio = document.createElement("audio");
+    audio.preload = "metadata";
+    audio.onloadedmetadata = () => {
+      const duration = audio.duration;
+      URL.revokeObjectURL(audio.src);
+      resolve(duration);
+    };
+    audio.onerror = () => {
+      URL.revokeObjectURL(audio.src);
+      reject(new Error("\u97F3\u9891\u6587\u4EF6\u65E0\u6CD5\u8BFB\u53D6\u6216\u683C\u5F0F\u4E0D\u652F\u6301"));
+    };
+    audio.src = URL.createObjectURL(file);
+  });
+}
+
+// src/apis/SdkDeleteAllMessagePostApi.ts
+var postSdkDeleteAllMessageApiRequest = (data) => {
+  return request({
+    path: "/sdk/deleteAllMessage",
+    method: "POST",
+    data
+  });
+};
+
+// src/sdk/message.ts
+async function getImageSize(file) {
+  return new Promise((resolve, reject) => {
+    const url = URL.createObjectURL(file);
+    const img = new Image();
+    img.onload = () => {
+      resolve({
+        width: img.naturalWidth,
+        height: img.naturalHeight
+      });
+      URL.revokeObjectURL(url);
+    };
+    img.onerror = () => {
+      URL.revokeObjectURL(url);
+      reject(new Error("\u56FE\u7247\u6587\u4EF6\u65E0\u6CD5\u8BFB\u53D6\u6216\u683C\u5F0F\u4E0D\u652F\u6301"));
+    };
+    img.src = url;
+  });
+}
+async function uploadSdkFile(file) {
+  const formData = new FormData();
+  formData.append("file", file);
+  const response = await fetch(getUploadUrl(), {
+    method: "POST",
+    headers: {
+      Authorization: getStoredToken()
+    },
+    body: formData
+  });
+  if (!response.ok) {
+    throw new Error(`file upload failed: ${response.status}`);
+  }
+  const payload = await response.json();
+  if (payload.Code !== 0 && payload.Code !== "0") {
+    throw new Error(payload.Message || "file upload failed");
+  }
+  if (!payload.Result) {
+    throw new Error("file upload result is empty");
+  }
+  return payload.Result;
+}
+async function enrichMediaMessage(message) {
+  const file = message.file;
+  if (!file) {
+    throw new Error("media message file is required");
+  }
+  const enrichedMessage = {
+    ...message,
+    fileName: file.name || message.fileName || "",
+    fileSize: String(file.size)
+  };
+  if (isSameUid(message.type, "11" /* Image */)) {
+    const { width, height } = await getImageSize(file);
+    enrichedMessage.thumbnailWidth = String(width);
+    enrichedMessage.thumbnailHeight = String(height);
+  } else if (isSameUid(message.type, "13" /* Audio */)) {
+    const duration = await getAudioDuration(file);
+    enrichedMessage.duration = String(duration);
+  } else if (isSameUid(message.type, "14" /* Video */)) {
+    const res = await getVideoDurationAndFirstFrame(file);
+    enrichedMessage.duration = String(res.duration);
+    enrichedMessage.thumbnailWidth = String(res.videoWidth);
+    enrichedMessage.thumbnailHeight = String(res.videoHeight);
+    enrichedMessage.thumbnailDownloadUrl = await uploadSdkFile(res.firstFrameFile);
+  }
+  const fileDownloadUrl = await uploadSdkFile(file);
+  enrichedMessage.fileDownloadUrl = fileDownloadUrl;
+  if (isSameUid(message.type, "11" /* Image */)) {
+    enrichedMessage.thumbnailDownloadUrl = fileDownloadUrl;
+  }
+  delete enrichedMessage.file;
+  return enrichedMessage;
+}
+async function sendMessage(payload) {
+  const response = await postSdkSendMessageApiRequest(payload);
+  return unwrapSdkData(response);
+}
+async function sendMediaMessage(payload) {
+  const response = await postSdkSendMediaMessageApiRequest({
+    ...payload,
+    message: await enrichMediaMessage(payload.message)
+  });
+  return unwrapSdkData(response);
+}
+async function queryHistoryMessage(payload) {
+  const response = await postSdkQueryHistoryMessageApiRequest(payload);
+  return unwrapSdkData(response);
+}
+async function deleteAllConversationMessages() {
+  const response = await postSdkDeleteAllConversationMessagesApiRequest(
+    {
+      config: {
+        isAlsoDeleteServerMessage: true
+        // 是否同时删除服务器消息，默认为 false
+      }
+    }
+  );
+  return unwrapSdkResponse(response);
+}
+async function deleteMessages(conversationID, conversationType, messageList) {
+  const response = await postSdkDeleteMessagesApiRequest({
+    conversationID: Number(conversationID),
+    conversationType: conversationType.toString(),
+    messageList: messageList.map((msg) => ({
+      messageID: msg.messageID,
+      type: Number(msg.type)
+    }))
+  });
+  return unwrapSdkResponse(response);
+}
+async function revokeMessage(message, config) {
+  const response = await postSdkRevokeMessageApiRequest({ message, config });
+  return unwrapSdkResponse(response);
+}
+async function deleteAllMessage(conversationID, conversationType) {
+  const response = await postSdkDeleteAllMessageApiRequest({
+    conversationID: Number(conversationID),
+    conversationType: conversationType.toString()
+  });
+  return unwrapSdkResponse(response);
+}
+
+// src/apis/SdkQueryGroupMessageReceiptReadMemberListPostApi.ts
+var postSdkQueryGroupMessageReceiptReadMemberListApiRequest = (data) => {
+  return request({
+    path: "/sdk/queryGroupMessageReceiptReadMemberList",
+    method: "POST",
+    data
+  });
+};
+
+// src/apis/SdkQueryGroupMessageReceiptUnreadMemberListPostApi.ts
+var postSdkQueryGroupMessageReceiptUnreadMemberListApiRequest = (data) => {
+  return request({
+    path: "/sdk/queryGroupMessageReceiptUnreadMemberList",
+    method: "POST",
+    data
+  });
+};
+
+// src/apis/SdkQueryMessageReceiptsInfoPostApi.ts
+var postSdkQueryMessageReceiptsInfoApiRequest = (data) => {
+  return request({
+    path: "/sdk/queryMessageReceiptsInfo",
+    method: "POST",
+    data
+  });
+};
+
+// src/apis/SdkSendMessageReceiptsReadPostApi.ts
+var postSdkSendMessageReceiptsReadApiRequest = (data) => {
+  return request({
+    path: "/sdk/sendMessageReceiptsRead",
+    method: "POST",
+    data
+  });
+};
+
+// src/sdk/messageReceipts.ts
+async function sendMessageReceiptsRead(conversationID, conversationType, messageList) {
+  const response = await postSdkSendMessageReceiptsReadApiRequest({
+    conversationID,
+    conversationType: conversationType.toString(),
+    messageList
+  });
+  return unwrapSdkResponse(response);
+}
+async function queryMessageReceiptsInfo(conversationID, conversationType, messageList) {
+  const response = await postSdkQueryMessageReceiptsInfoApiRequest({
+    conversationID: Number(conversationID),
+    conversationType: conversationType.toString(),
+    messageList
+  });
+  return unwrapSdkResponse(response);
+}
+async function queryGroupMessageReceiptUnreadMemberList(groupID, config, message) {
+  const response = await postSdkQueryGroupMessageReceiptUnreadMemberListApiRequest({
+    groupID,
+    config,
+    message
+  });
+  return unwrapSdkResponse(response);
+}
+async function queryGroupMessageReceiptReadMemberList(groupID, config, message) {
+  const response = await postSdkQueryGroupMessageReceiptReadMemberListApiRequest({
+    groupID,
+    config,
+    message
+  });
+  return unwrapSdkResponse(response);
+}
+
+// src/sdk/index.ts
+var VanshiSdk = {
+  // 创建 ws 实例
+  create: initSocket,
+  // 退出 SDK 登录并断开 ws 连接
+  logout,
+  // 判断当前 ws 是否连接
+  isConnected: isSocketConnected,
+  // 监听推送事件
+  on,
+  // 解除推送事件监听
+  off,
+  // 登录 SDK
+  login,
+  // 查询会话列表
+  queryConversation,
+  // 删除全部会话列表
+  deleteAllConversations,
+  // 删除单个会话
+  deleteConversation,
+  // 清除全部会话未读数
+  clearConversationTotalUnreadMessageCount,
+  // 清除单个会话未读数
+  clearConversationUnreadMessageCount,
+  // 查询历史消息
+  queryHistoryMessage,
+  // 发送文本消息
+  sendMessage,
+  // 发送媒体消息
+  sendMediaMessage,
+  // 删除全部会话消息
+  deleteAllConversationMessages,
+  // 删除指定消息
+  deleteMessages,
+  // 删除当前会话全部消息
+  deleteAllMessage,
+  // 撤回消息
+  revokeMessage,
+  // 发送已读回执
+  sendMessageReceiptsRead,
+  // 查询一批消息回执信息
+  queryMessageReceiptsInfo,
+  // 查询群消息未读成员列表。
+  queryGroupMessageReceiptUnreadMemberList,
+  // 查询群消息已读成员列表。
+  queryGroupMessageReceiptReadMemberList
+};
+var sdk_default = VanshiSdk;
+export {
+  clearConversationTotalUnreadMessageCount,
+  clearConversationUnreadMessageCount,
+  initSocket as create,
+  sdk_default as default,
+  deleteAllConversationMessages,
+  deleteAllConversations,
+  deleteAllMessage,
+  deleteConversation,
+  deleteMessages,
+  isSocketConnected as isConnected,
+  login,
+  logout,
+  off,
+  on,
+  queryConversation,
+  queryGroupMessageReceiptReadMemberList,
+  queryGroupMessageReceiptUnreadMemberList,
+  queryHistoryMessage,
+  queryMessageReceiptsInfo,
+  revokeMessage,
+  sendMediaMessage,
+  sendMessage,
+  sendMessageReceiptsRead
+};